file_name large_stringlengths 4 140 | prefix large_stringlengths 0 39k | suffix large_stringlengths 0 36.1k | middle large_stringlengths 0 29.4k | fim_type large_stringclasses 4
values |
|---|---|---|---|---|
sevencow.py | # -*- coding: utf-8 -*-
import os
import hmac
import time
import json
import mimetypes
import functools
from urlparse import urlparse
from urllib import urlencode
from base64 import urlsafe_b64encode
from hashlib import sha1
import requests
version_info = (0, 1, 2)
VERSION = __version__ = '.'.join( map(str, version_info) )
"""
Usage:
cow = Cow(ACCESS_KEY, SECRET_KEY)
b = cow.get_bucket(BUCKET)
b.put('a')
b.put('a', 'b')
b.put('a', names={'a': 'x'})
b.put('a', 'b', names={'a': 'x', 'b': 'y'})
b.stat('a')
b.stat('a', 'b')
b.delete('a')
b.delete('a', 'b')
b.copy('a', 'c')
b.copy(('a', 'c'), ('b', 'd'))
b.move('a', 'c')
b.move(('a', 'c'), ('b', 'd'))
"""
RS_HOST = 'http://rs.qbox.me'
UP_HOST = 'http://up.qbox.me'
RSF_HOST = 'http://rsf.qbox.me'
class CowException(Exception):
def __init__(self, url, status_code, reason, content):
self.url = url
self.status_code = status_code
self.reason = reason
self.content = content
Exception.__init__(self, '%s, %s' % (reason, content))
def signing(secret_key, data):
return urlsafe_b64encode(
hmac.new(secret_key, data, sha1).digest()
)
def requests_error_handler(func):
@functools.wraps(func)
def deco(*args, **kwargs):
try:
return func(*args, **kwargs)
except AssertionError as e:
req = e.args[0]
raise CowException(
req.url, req.status_code, req.reason, req.content
)
return deco
def expected_argument_type(pos, types):
def deco(func):
@functools.wraps(func)
def wrap(*args, **kwargs):
if not isinstance(args[pos], types):
raise TypeError(
"{0} Type error, Expected {1}".format(args[pos], types)
)
return func(*args, **kwargs)
return wrap
return deco
class UploadToken(object):
def __init__(self, access_key, secret_key, scope, ttl=3600):
self.access_key = access_key
self.secret_key = secret_key
self.scope = scope
self.ttl = ttl
self._token = None
self.generated = int(time.time())
@property
def token(self):
if int(time.time()) - self.generated > self.ttl - 60:
# 还有一分钟也认为过期了， make new token
self._token = self._make_token()
if not self._token:
self._token = self._make_token()
return self._token
def _make_token(self):
self.generated = int(time.time())
info = {
'scope': self.scope,
'deadline': self.generated + self.ttl
}
info = urlsafe_b64encode(json.dumps(info))
token = signing(self.secret_key, info)
return '%s:%s:%s' % (self.access_key, token, info)
class Cow(object):
def __init__(self, access_key, secret_key):
self.access_key = access_key
self.secret_key = secret_key |
self.stat = functools.partial(self._stat_rm_handler, 'stat')
self.delete = functools.partial(self._stat_rm_handler, 'delete')
self.copy = functools.partial(self._cp_mv_handler, 'copy')
self.move = functools.partial(self._cp_mv_handler, 'move')
def get_bucket(self, bucket):
"""对一个bucket的文件进行操作，
推荐使用此方法得到一个bucket对象,
然后对此bucket的操作就只用传递文件名即可
"""
return Bucket(self, bucket)
def generate_access_token(self, url, params=None):
uri = urlparse(url)
token = uri.path
if uri.query:
token = '%s?%s' % (token, uri.query)
token = '%s\n' % token
if params:
if isinstance(params, basestring):
token += params
else:
token += urlencode(params)
return '%s:%s' % (self.access_key, signing(self.secret_key, token))
def build_requests_headers(self, token):
return {
'Content-Type': 'application/x-www-form-urlencoded',
'Authorization': 'QBox %s' % token
}
@requests_error_handler
def api_call(self, url, params=None):
token = self.generate_access_token(url, params=params)
if params:
res = requests.post(url, data=params, headers=self.build_requests_headers(token))
else:
res = requests.post(url, headers=self.build_requests_headers(token))
assert res.status_code == 200, res
return res.json() if res.text else ''
def list_buckets(self):
"""列出所有的buckets"""
url = '%s/buckets' % RS_HOST
return self.api_call(url)
def create_bucket(self, name):
"""不建议使用API建立bucket
测试发现API建立的bucket默认无法设置<bucket_name>.qiniudn.com的二级域名
请直接到web界面建立
"""
url = '%s/mkbucket/%s' % (RS_HOST, name)
return self.api_call(url)
def drop_bucket(self, bucket):
"""删除整个bucket"""
url = '%s/drop/%s' % (RS_HOST, bucket)
return self.api_call(url)
def list_files(self, bucket, marker=None, limit=None, prefix=None):
"""列出bucket中的文件"""
query = ['bucket=%s' % bucket]
if marker:
query.append('marker=%s' % marker)
if limit:
query.append('limit=%s' % limit)
if prefix:
query.append('prefix=%s' % prefix)
url = '%s/list?%s' % (RSF_HOST, '&'.join(query))
return self.api_call(url)
def generate_upload_token(self, scope, ttl=3600):
"""上传文件的uploadToken"""
if scope not in self.upload_tokens:
self.upload_tokens[scope] = UploadToken(self.access_key, self.secret_key, scope, ttl=ttl)
return self.upload_tokens[scope].token
@requests_error_handler
@expected_argument_type(2, (basestring, list, tuple))
def put(self, scope, filename, names=None):
"""上传文件
filename 如果是字符串，表示上传单个文件，
如果是list或者tuple，表示上传多个文件
names 是dict，key为filename, value为上传后的名字
如果不设置，默认为文件名
"""
url = '%s/upload' % UP_HOST
token = self.generate_upload_token(scope)
names = names or {}
def _uploaded_name(filename):
return names.get(filename, None) or os.path.basename(filename)
def _put(filename):
files = {
'file': (filename, open(filename, 'rb')),
}
action = '/rs-put/%s' % urlsafe_b64encode(
'%s:%s' % (scope, _uploaded_name(filename))
)
_type, _encoding = mimetypes.guess_type(filename)
if _type:
action += '/mimeType/%s' % urlsafe_b64encode(_type)
data = {
'auth': token,
'action': action,
}
res = requests.post(url, files=files, data=data)
assert res.status_code == 200, res
return res.json()
if isinstance(filename, basestring):
# 单个文件
return _put(filename)
# 多文件
return [_put(f) for f in filename]
@expected_argument_type(2, (list, tuple))
def _cp_mv_handler(self, action, args):
"""copy move方法
action: 'copy' or 'move'
args: [src_bucket, src_filename, des_bucket, des_filename]
or [(src_bucket, src_filename, des_bucket, des_filename), (), ...]
args 第一种形式就是对一个文件进行操作，第二种形式是多个文件批量操作
用户不用直接调用这个方法
"""
if isinstance(args[0], basestring):
return self._cp_mv_single(action, args)
if isinstance(args[0], (list, tuple)):
return self._cp_mv_batch(action, args)
@expected_argument_type(3, (basestring, list, tuple))
def _stat_rm_handler(self, action, bucket, filename):
"""stat delete方法
action: 'stat' or 'delete'
bucket: 哪个bucket
filenmae: 'aabb' or ['aabb', 'ccdd', ...]
filename 第一种形式就是对一个文件进行操作，第二种形式是多个文件批量操作
用户不用直接调用这个方法
"""
if isinstance(filename, basestring):
return self._stat_rm_single(action, bucket, filename)
if isinstance(filename, (list, tuple)):
return self._stat_rm_batch(action, bucket, filename)
def _cp_mv_single(self, action, args):
src_bucket, src_filename, des_bucket, des_filename = args
url = '%s/%s/%s/%s' % (
RS_HOST,
action,
urlsafe_b64encode('%s:%s' % (src_bucket, src_filename)),
urlsafe_b64encode('%s:%s' % (des_bucket, des_filename)),
)
return self.api_call(url)
def _cp_mv_batch(self, action, args):
url = '%s/batch' % RS_HOST
def _one_param(arg):
return 'op=/%s/%s/%s' % (
action,
urlsafe_b64encode('%s:%s' % (arg[0], arg[1])),
urlsafe_b64encode('%s:%s' % (arg[2], arg[3])),
)
param = '&'.join( map(_one_param, args) )
return self.api_call(url, param)
def _stat_rm_single(self, action, bucket, filename):
url = '%s/%s/%s' % (
RS_HOST, action, urlsafe_b64encode('%s:%s' % (bucket, filename))
)
return self.api_call(url)
def _stat_rm_batch(self, action, bucket, filenames):
url = '%s/batch' % RS_HOST
param = [
'op=/%s/%s' % (
action, urlsafe_b64encode('%s:%s' % (bucket, f))
) for f in filenames
]
param = '&'.join(param)
return self.api_call(url, param)
def transform_argument(func):
@functools.wraps(func)
def deco(self, *args, **kwargs):
filename = args[0] if len(args) == 1 else args
return func(self, filename, **kwargs)
return deco
class Bucket(object):
def __init__(self, cow, bucket):
self.cow = cow
self.bucket = bucket
@transform_argument
def put(self, *args, **kwargs):
names = kwargs.get('names', None)
if names and not isinstance(names, dict):
raise TypeError(
"names Type error, Expected dict, But got Type of {0}".format(type(names))
)
return self.cow.put(self.bucket, args[0], names=names)
@transform_argument
def stat(self, *args):
return self.cow.stat(self.bucket, args[0])
@transform_argument
def delete(self, *args):
return self.cow.delete(self.bucket, args[0])
@transform_argument
def copy(self, *args):
return self.cow.copy(self._build_cp_mv_args(args[0]))
@transform_argument
def move(self, *args):
return self.cow.move(self._build_cp_mv_args(args[0]))
def list_files(self, marker=None, limit=None, prefix=None):
return self.cow.list_files(self.bucket, marker=marker, limit=limit, prefix=prefix)
def _build_cp_mv_args(self, filename):
if isinstance(filename[0], basestring):
args = [self.bucket, filename[0], self.bucket, filename[1]]
else:
args = []
for src, des in filename:
args.append( (self.bucket, src, self.bucket, des) )
return args | self.upload_tokens = {} | random_line_split |
sevencow.py | # -*- coding: utf-8 -*-
import os
import hmac
import time
import json
import mimetypes
import functools
from urlparse import urlparse
from urllib import urlencode
from base64 import urlsafe_b64encode
from hashlib import sha1
import requests
version_info = (0, 1, 2)
VERSION = __version__ = '.'.join( map(str, version_info) )
"""
Usage:
cow = Cow(ACCESS_KEY, SECRET_KEY)
b = cow.get_bucket(BUCKET)
b.put('a')
b.put('a', 'b')
b.put('a', names={'a': 'x'})
b.put('a', 'b', names={'a': 'x', 'b': 'y'})
b.stat('a')
b.stat('a', 'b')
b.delete('a')
b.delete('a', 'b')
b.copy('a', 'c')
b.copy(('a', 'c'), ('b', 'd'))
b.move('a', 'c')
b.move(('a', 'c'), ('b', 'd'))
"""
RS_HOST = 'http://rs.qbox.me'
UP_HOST = 'http://up.qbox.me'
RSF_HOST = 'http://rsf.qbox.me'
class CowException(Exception):
def __init__(self, url, status_code, reason, content):
self.url = url
self.status_code = status_code
self.reason = reason
self.content = content
Exception.__init__(self, '%s, %s' % (reason, content))
def signing(secret_key, data):
return urlsafe_b64encode(
hmac.new(secret_key, data, sha1).digest()
)
def requests_error_handler(func):
@functools.wraps(func)
def deco(*args, **kwargs):
try:
return func(*args, **kwargs)
except AssertionError as e:
req = e.args[0]
raise CowException(
req.url, req.status_code, req.reason, req.content
)
return deco
def expected_argument_type(pos, types):
def deco(func):
@functools.wraps(func)
def wrap(*args, **kwargs):
if not isinstance(args[pos], types):
raise TypeError(
"{0} Type error, Expected {1}".format(args[pos], types)
)
return func(*args, **kwargs)
return wrap
return deco
class UploadToken(object):
def __init__(self, access_key, secret_key, scope, ttl=3600):
self.access_key = access_key
self.secret_key = secret_key
self.scope = scope
self.ttl = ttl
self._token = None
self.generated = int(time.time())
@property
def token(self):
if int(time.time()) - self.generated > self.ttl - 60:
# 还有一分钟也认为过期了， make new token
self._token = self._make_token()
if not self._token:
self._token = self._make_token()
return self._token
def _make_token(self):
self.generated = int(time.time())
info = {
'scope': self.scope,
'deadline': self.generated + self.ttl
}
info = urlsafe_b64encode(json.dumps(info))
token = signing(self.secret_key, info)
return '%s:%s:%s' % (self.access_key, token, info)
class Cow(object):
def __init__(self, access_key, secret_key):
self.access_key = access_key
self.secret_key = secret_key
self.upload_tokens = {}
self.stat = functools.partial(self._stat_rm_handler, 'stat')
self.delete = functools.partial(self._stat_rm_handler, 'delete')
self.copy = functools.partial(self._cp_mv_handler, 'copy')
self.move = functools.partial(self._cp_mv_handler, 'move')
def get_bucket(self, bucket):
"""对一个bucket的文件进行操作，
推荐使用此方法得到一个bucket对象,
然后对此bucket的操作就只用传递文件名即可
"""
return Bucket(self, bucket)
def generate_access_token(self, url, params=None):
uri = urlparse(url)
token = uri.path
if uri.query:
token = '%s?%s' % (token, uri.query)
token = '%s\n' % token
if params:
if isinstance(params, basestring):
token += params
else:
token += urlencode(params)
return '%s:%s' % (self.access_key, signing(self.secret_key, token))
def build_requests_headers(self, token):
return {
'Content-Type': 'application/x-www-form-urlencoded',
'Authorization': 'QBox %s' % token
}
@requests_error_handler
def api_call(self, url, params=None):
token = self.generate_access_token(url, params=params)
if params:
res = requests.post(url, data=params, headers=self.build_requests_headers(token))
else:
res = requests.post(url, headers=self.build_requests_headers(token))
assert res.status_code == 200, res
return res.json() if res.text else ''
def list_buckets(self):
"""列出所有的buckets"""
url = '%s/buckets' % RS_HOST
return self.api_call(url)
def create_bucket(self, name):
"""不建议使用API建立bucket
测试发现API建立的bucket默认无法设置<bucket_name>.qiniudn.com的二级域名
请直接到web界面建立
"""
url = '%s/mkbucket/%s' % (RS_HOST, name)
return self.api_call(url)
def drop_bucket(self, bucket):
"""删除整个bucket"""
url = '%s/drop/%s' % (RS_HOST, bucket)
return self.api_call(url)
def list_files(self, bucket, marker=None, limit=None, prefix=None):
"""列出bucket中的文件"""
query = ['bucket=%s' % bucket]
if marker:
query.append('marker=%s' % marker)
if limit:
query.append('limit=%s' % limit)
if prefix:
query.append('prefix=%s' % prefix)
url = '%s/list?%s' % (RSF_HOST, '&'.join(query))
return self.api_call(url)
def generate_upload_token(self, scope, ttl=3600):
"""上传文件的uploadToken"""
if scope not in self.upload_tokens:
self.upload_tokens[scope] = UploadToken(self.access_key, self.secret_key, scope, ttl=ttl)
return self.upload_tokens[scope].token
@requests_error_handler
@expected_argument_type(2, (basestring, list, tuple))
def put(self, scope, filename, names=None):
"""上传文件
filename 如果是字符串，表示上传单个文件，
如果是list或者tuple，表示上传多个文件
names 是dict，key为filename, value为上传后的名字
如果不设置，默认为文件名
"""
url = '%s/upload' % UP_HOST
token = self.generate_upload_token(scope)
names = names or {}
def _uploaded_name(filename):
return names.get(filename, None) or os.path.basename(filename)
def _put(filename):
files = {
'file': (filename, open(filename, 'rb')),
}
action = '/rs-put/%s' % urlsafe_b64encode(
'%s:%s' % (scope, _uploaded_name(filename))
)
_type, _encoding = mimetypes.guess_type(filename)
if _type:
action += '/mimeType/%s' % urlsafe_b64encode(_type)
data = {
'auth': token,
'action': action,
}
res = requests.post(url, files=files, data=data)
assert res.status_code == 200, res
return res.json()
if isinstance(filename, basestring):
# 单个文件
return _put(filename)
# 多文件
return [_put(f) for f in filename]
@expected_argument_type(2, (list, tuple))
def _cp_mv_handler(self, action, args):
"""copy move方法
action: 'copy' or 'move'
args: [src_bucket, src_filename, des_bucket, des_filename]
or [(src_bucket, src_filename, des_bucket, des_filename), (), ...]
args 第一种形式就是对一个文件进行操作，第二种形式是多个文件批量操作
用户不用直接调用这个方法
"""
if isinstance(args[0], basestring):
return self._cp_mv_single(action, args)
if isinstance(args[0], (list, tuple)):
return self._cp_mv_batch(action, args)
@expected_argument_type(3, (basestring, list, tuple))
def _stat_rm_handler(self, action, bucket, filename):
"""stat delete方法
action: 'stat' or 'delete'
bucket: 哪个bucket
filenmae: 'aabb' or ['aabb', 'ccdd', ...]
filename 第一种形式就是对一个文件进行操作，第二种形式是多个文件批量操作
用户不用直接调用这个方法
"""
if isinstance(filename, basestring):
return self._stat_rm_single(action, bucket, filename)
if isinstance(filename, (list, tuple)):
return self._stat_rm_batch(action, bucket, filename)
def _cp_mv_single(self, action, args):
src_bucket, src_filename, des_bucket, des_filename = args
url = '%s/%s/%s/%s' % (
RS_HOST,
action,
urlsafe_b64encode('%s:%s' % (src_bucket, src_filename)),
urlsafe_b64encode('%s:%s' % (des_bucket, des_filename)),
)
return self.api_call(url)
def _cp_mv_batch(self, action, args):
url = '%s/batch' % RS_HOST
def _one_param(arg):
return 'op=/%s/%s/%s' % (
action,
urlsafe_b64encode('%s:%s' % (arg[0], arg[1])),
urlsafe_b64encode('%s:%s' % (arg[2], arg[3])),
)
param = '&'.join( map(_one_param, args) )
return self.api_call(url, param)
def _stat_rm_single(self, action, bucket, filename):
url = '%s/%s/%s' % (
RS_HOST, action, urlsafe_b64encode('%s:%s' % (bucket, filename))
)
return self.api_call(url)
def _stat_rm_batch(self, action, bucket, filenames):
url = '%s/batch' % RS_HOST
param = [
'op=/%s/%s' % (
action, urlsafe_b64encode('%s:%s' % (bucket, f))
) for f in filenames
]
param = '&'.join(param)
return self.api_call(url, param)
def transform_argument(func):
@functools.wraps(func)
def deco(self, *args, **kwargs):
filename = args[0] if len(args) == 1 else args
return func(self, filename, **kwargs)
return deco
class Bucket(object):
def __init__(self, cow, bucket):
self.cow = cow
self.bucket = bucket
@transform_argument
def put(self, *args, **kwargs):
names = kwargs.get('names', None)
if names and not isinstance(names, dict):
raise TypeError(
"names Type error, Expected dict, But got Type of {0}".format(type(names))
)
return self.cow.put(self.bucket, args[0], names=names)
@transform_argument
def stat(self, *args):
return self.cow.stat(self.b | ucket, args[0])
@transform_argument
def delete(self, *args):
return self.cow.delete(self.bucket, args[0])
@transform_argument
def copy(self, *args):
return self.cow.copy(self._build_cp_mv_args(args[0]))
@transform_argument
def move(self, *args):
return self.cow.move(self._build_cp_mv_args(args[0]))
def list_files(self, marker=None, limit=None, prefix=None):
return self.cow.list_files(self.bucket, marker=marker, limit=limit, prefix=prefix)
def _build_cp_mv_args(self, filename):
if isinstance(filename[0], basestring):
args = [self.bucket, filename[0], self.bucket, filename[1]]
else:
args = []
for src, des in filename:
args.append( (self.bucket, src, self.bucket, des) )
return args
| identifier_body | |
sevencow.py | # -*- coding: utf-8 -*-
import os
import hmac
import time
import json
import mimetypes
import functools
from urlparse import urlparse
from urllib import urlencode
from base64 import urlsafe_b64encode
from hashlib import sha1
import requests
version_info = (0, 1, 2)
VERSION = __version__ = '.'.join( map(str, version_info) )
"""
Usage:
cow = Cow(ACCESS_KEY, SECRET_KEY)
b = cow.get_bucket(BUCKET)
b.put('a')
b.put('a', 'b')
b.put('a', names={'a': 'x'})
b.put('a', 'b', names={'a': 'x', 'b': 'y'})
b.stat('a')
b.stat('a', 'b')
b.delete('a')
b.delete('a', 'b')
b.copy('a', 'c')
b.copy(('a', 'c'), ('b', 'd'))
b.move('a', 'c')
b.move(('a', 'c'), ('b', 'd'))
"""
RS_HOST = 'http://rs.qbox.me'
UP_HOST = 'http://up.qbox.me'
RSF_HOST = 'http://rsf.qbox.me'
class CowException(Exception):
def __init__(self, url, status_code, reason, content):
self.url = url
self.status_code = status_code
self.reason = reason
self.content = content
Exception.__init__(self, '%s, %s' % (reason, content))
def signing(secret_key, data):
return urlsafe_b64encode(
hmac.new(secret_key, data, sha1).digest()
)
def requests_error_handler(func):
@functools.wraps(func)
def deco(*args, **kwargs):
try:
return func(*args, **kwargs)
except AssertionError as e:
req = e.args[0]
raise CowException(
req.url, req.status_code, req.reason, req.content
)
return deco
def expected_argument_type(pos, types):
def deco(func):
@functools.wraps(func)
def wrap(*args, **kwargs):
if not isinstance(args[pos], types):
raise TypeError(
"{0} Type error, Expected {1}".format(args[pos], types)
)
return func(*args, **kwargs)
return wrap
return deco
class UploadToken(object):
def __init__(self, access_key, secret_key, scope, ttl=3600):
self.access_key = access_key
self.secret_key = secret_key
self.scope = scope
self.ttl = ttl
self._token = None
self.generated = int(time.time())
@property
def token(self):
if int(time.time()) - self.generated > self.ttl - 60:
# 还有一分钟也认为过期了， make new token
self._token = self._make_token()
if not self._token:
self._token = self._make_token()
return self._token
def _make_token(self):
self.generated = int(time.time())
info = {
'scope': self.scope,
'deadline': self.generated + self.ttl
}
info = urlsafe_b64encode(json.dumps(info))
token = signing(self.secret_key, info)
return '%s:%s:%s' % (self.access_key, token, info)
class Cow(object):
def __init__(self, access_key, secret_key):
self.access_key = access_key
self.secret_key = secret_key
self.upload_tokens = {}
self.stat = functools.partial(self._stat_rm_handler, 'stat')
self.delete = functools.partial(self._stat_rm_handler, 'delete')
self.copy = functools.partial(self._cp_mv_handler, 'copy')
self.move = functools.partial(self._cp_mv_handler, 'move')
def get_bucket(self, bucket):
"""对一个bucket的文件进行操作，
推荐使用此方法得到一个bucket对象,
然后对此bucket的操作就只用传递文件名即可
"""
return Bucket(self, bucket)
def generate_access_token(self, url, params=None):
uri = urlparse(url)
token = uri.path
if uri.query:
token = '%s?%s' % (token, uri.query)
token = '%s\n' % token
if params:
if isinstance(params, basestring):
token += params
else:
token += urlencode(params)
return '%s:%s' % (self.access_key, signing(self.secret_key, token))
def build_requests_headers(self, token):
return {
'Content-Type': 'application/x-www-form-urlencoded',
'Authorization': 'QBox %s' % token
}
@requests_error_handler
def api_call(self, url, params=None):
token = self.generate_access_token(url, params=params)
if params:
res = requests.post(url, data=params, headers=self.build_requests_headers(token))
else:
res = requests.post(url, headers=self.build_requests_headers(token))
assert res.status_code == 200, res
return res.json() if res.text else ''
def list_buckets(self):
"""列出所有的buckets"""
url = '%s/buckets' % RS_HOST
return self.api_call(url)
def create_bucket(self, name):
"""不建议使用API建立bucket
测试发现API建立的bucket默认无法设置<bucket_name>.qiniudn.com的二级域名
请直接到web界面建立
"""
url = '%s/mkbucket/%s' % (RS_HOST, name)
return self.api_call(url)
def drop_bucket(self, bucket):
"""删除整个bucket"""
url = '%s/drop/%s' % (RS_HOST, bucket)
return self.api_call(url)
def list_files(self, bucket, marker=None, limit=None, prefix=None):
"""列出bucket中的文件"""
query = ['bucket=%s' % bucket]
if marker:
query.append('marker=%s' % marker)
if limit:
query.append('limit=%s' % limit)
if prefix:
query.append('prefix=%s' % prefix)
url = '%s/list?%s' % (RSF_HOST, '&'.join(query))
return self.api_call(url)
def generate_upload_token(self, scope, ttl=3600):
"""上传文件的uploadToken"""
if scope not in self.upload_tokens:
self.upload_tokens[scope] = UploadToken(self.access_key, self.secret_key, scope, ttl=ttl)
return self.upload_tokens[scope].token
@requests_error_handler
@expected_argument_type(2, (basestring, list, tuple))
def put(self, scope, filename, names=None):
"""上传文件
filename 如果是字符串，表示上传单个文件，
如果是list或者tuple，表示上传多个文件
names 是dict，key为filename, value为上传后的名字
如果不设置，默认为文件名
"""
u | = '%s/upload' % UP_HOST
token = self.generate_upload_token(scope)
names = names or {}
def _uploaded_name(filename):
return names.get(filename, None) or os.path.basename(filename)
def _put(filename):
files = {
'file': (filename, open(filename, 'rb')),
}
action = '/rs-put/%s' % urlsafe_b64encode(
'%s:%s' % (scope, _uploaded_name(filename))
)
_type, _encoding = mimetypes.guess_type(filename)
if _type:
action += '/mimeType/%s' % urlsafe_b64encode(_type)
data = {
'auth': token,
'action': action,
}
res = requests.post(url, files=files, data=data)
assert res.status_code == 200, res
return res.json()
if isinstance(filename, basestring):
# 单个文件
return _put(filename)
# 多文件
return [_put(f) for f in filename]
@expected_argument_type(2, (list, tuple))
def _cp_mv_handler(self, action, args):
"""copy move方法
action: 'copy' or 'move'
args: [src_bucket, src_filename, des_bucket, des_filename]
or [(src_bucket, src_filename, des_bucket, des_filename), (), ...]
args 第一种形式就是对一个文件进行操作，第二种形式是多个文件批量操作
用户不用直接调用这个方法
"""
if isinstance(args[0], basestring):
return self._cp_mv_single(action, args)
if isinstance(args[0], (list, tuple)):
return self._cp_mv_batch(action, args)
@expected_argument_type(3, (basestring, list, tuple))
def _stat_rm_handler(self, action, bucket, filename):
"""stat delete方法
action: 'stat' or 'delete'
bucket: 哪个bucket
filenmae: 'aabb' or ['aabb', 'ccdd', ...]
filename 第一种形式就是对一个文件进行操作，第二种形式是多个文件批量操作
用户不用直接调用这个方法
"""
if isinstance(filename, basestring):
return self._stat_rm_single(action, bucket, filename)
if isinstance(filename, (list, tuple)):
return self._stat_rm_batch(action, bucket, filename)
def _cp_mv_single(self, action, args):
src_bucket, src_filename, des_bucket, des_filename = args
url = '%s/%s/%s/%s' % (
RS_HOST,
action,
urlsafe_b64encode('%s:%s' % (src_bucket, src_filename)),
urlsafe_b64encode('%s:%s' % (des_bucket, des_filename)),
)
return self.api_call(url)
def _cp_mv_batch(self, action, args):
url = '%s/batch' % RS_HOST
def _one_param(arg):
return 'op=/%s/%s/%s' % (
action,
urlsafe_b64encode('%s:%s' % (arg[0], arg[1])),
urlsafe_b64encode('%s:%s' % (arg[2], arg[3])),
)
param = '&'.join( map(_one_param, args) )
return self.api_call(url, param)
def _stat_rm_single(self, action, bucket, filename):
url = '%s/%s/%s' % (
RS_HOST, action, urlsafe_b64encode('%s:%s' % (bucket, filename))
)
return self.api_call(url)
def _stat_rm_batch(self, action, bucket, filenames):
url = '%s/batch' % RS_HOST
param = [
'op=/%s/%s' % (
action, urlsafe_b64encode('%s:%s' % (bucket, f))
) for f in filenames
]
param = '&'.join(param)
return self.api_call(url, param)
def transform_argument(func):
@functools.wraps(func)
def deco(self, *args, **kwargs):
filename = args[0] if len(args) == 1 else args
return func(self, filename, **kwargs)
return deco
class Bucket(object):
def __init__(self, cow, bucket):
self.cow = cow
self.bucket = bucket
@transform_argument
def put(self, *args, **kwargs):
names = kwargs.get('names', None)
if names and not isinstance(names, dict):
raise TypeError(
"names Type error, Expected dict, But got Type of {0}".format(type(names))
)
return self.cow.put(self.bucket, args[0], names=names)
@transform_argument
def stat(self, *args):
return self.cow.stat(self.bucket, args[0])
@transform_argument
def delete(self, *args):
return self.cow.delete(self.bucket, args[0])
@transform_argument
def copy(self, *args):
return self.cow.copy(self._build_cp_mv_args(args[0]))
@transform_argument
def move(self, *args):
return self.cow.move(self._build_cp_mv_args(args[0]))
def list_files(self, marker=None, limit=None, prefix=None):
return self.cow.list_files(self.bucket, marker=marker, limit=limit, prefix=prefix)
def _build_cp_mv_args(self, filename):
if isinstance(filename[0], basestring):
args = [self.bucket, filename[0], self.bucket, filename[1]]
else:
args = []
for src, des in filename:
args.append( (self.bucket, src, self.bucket, des) )
return args
| rl | identifier_name |
class_vertice_graph.py | """ The goal of this file is to have all the information on a graph. """
import sys, os, inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0, parentdir)
import numpy as np
import matplotlib.pyplot as plt
import copy
import exceptions
inf = np.inf
#Change this bool according to the situation
non_oriented = False
class Vertice:
"""" All the information of one vertice are contained here. """
def __init__(self, index, coordinates):
""" Entry : index of the vertice in list_of_vertices
and the coordinates of the vertice. """
self.index = index
self.coordinates = np.array([coordinates[0],coordinates[1]])
self._edges_list = [] # no neighbour by default
self.priority = inf # priority by default
self.visited = False # vertice is by default not visited
self.cost_dijkstra = inf # cost is by default inf
self.antecedent = -inf # antecedent not defined before using Dijkstra
#implemente apres passage par panda
self.index_edges_list = []#seulement implemente apres passage par panda
#database
self.id = None #identifiant idfm de la gare
self.gare_name = None #nom de la gare
self.color = None #couleur de la gare
self.is_a_station= True # boolean True, si le noeud est veritablement une gare. False sinon
def get_lines_connected(self):
list_of_line = []
for edge in self._edges_list:
if edge.id not in list_of_line:
list_of_line.append(edge.id)
return list_of_line
@property
def edges_list(self):
""" Returns the list of neighbour. """
return self._edges_list
# We suppose that the index and the coordinates never change.
# The other properties can.
@edges_list.setter
def | (self, edges_list):
""" An element of edges_list is an edge """
for e in edges_list:
exceptions.check_pertinent_edge(self, e)
self._edges_list = edges_list
def neighbours_list(self, list_tuple, id=0):
self._edges_list.clear()
"""interface with old constructor , tuple=(neighbour_vertice,cost) is an element of list_tuple """
for tuple in list_tuple:
E = Edge(self, tuple[0], id, tuple[1])
self._edges_list.append(E)
def number_of_neighbours(self):
return len(self._edges_list)
def is_linked(self, other):
"""returns True if there is an edge between self and other"""
for edge in self._edges_list:
if other.index == edge.linked[1].index:
return True
return False
def push_edge(self, edge, coords_verif=False):
if coords_verif:
exceptions.check_pertinent_edge_coords_verif(self, edge)
else:
exceptions.check_pertinent_edge(self, edge)
self._edges_list.append(edge)
"""
def cost_between(self, other):
for edge in self._edges_list:
[vertice, vertice_voisin] = edge.linked
if vertice_voisin == other:
return edge.given_cost"""
def __repr__(self):
return f"Vertice {str(self.index)}"
def __lt__(self, other):
return self.priority < other.priority
class Edge:
def __init__(self, vertice1, vertice2, id, given_cost=0):
self.linked = [vertice1,vertice2]
self.id = id #identifiant de la liaison. ici id=nom de la ligne a laqualle appartient la liaison
self._given_cost = given_cost #cout de deplacement de la liason donne par l'utilisateur ou la base de donnee
#data_base
self.color=None #couleur de la liason
self.connection_with_displayable=None #indice de la liason developpee( trace reel) dans la table de connection connection_table_edge_and_diplayable_edge de la classe graph
self.index=None
def set_given_cost(self,cost):
self._given_cost=cost
#ne pas mettre @property ici, on veut une methode pas un attribut
def euclidian_cost(self):
return np.sqrt(self.square_euclidian_cost())
def square_euclidian_cost(self):
return np.dot(np.transpose(self.linked[0].coordinates-self.linked[1].coordinates),(self.linked[0].coordinates-self.linked[1].coordinates))
def customized_cost1(self):
V_metro = 25.1 / 3.6 #vitesse moyenne en km/h /3.6 -> vitesse moyenne en m/s
V_train = 49.6 / 3.6
V_tram = 18 / 3.6
V_pieton = 4 / 3.6
if self.id in ["A","B","C","D","E","H","I","J","K","L","M","N","P","R","U","TER","GL"]:
return self._given_cost/V_train
if self.id in [str(i) for i in range(1,15)]+["ORL","CDG","3b","7b"]:
return self._given_cost/V_metro
if self.id in ["T"+str(i) for i in range(1,12)]+["T3A","T3B","FUN"]:
return self._given_cost/V_tram
if self.id in ["RER Walk"]:
return self._given_cost/V_pieton
raise ValueError(" Dans customized_cost1 " +self.id+" non pris en compte dans le calcul de distance")
def __eq__(self,other):
"""2 edges are equal iff same cordinates and same id """
boul0 = self.linked[0].coordinates[0]==other.linked[0].coordinates[0] and self.linked[0].coordinates[1]==other.linked[0].coordinates[1]
boul1 = self.linked[1].coordinates[0]==other.linked[1].coordinates[0] and self.linked[1].coordinates[1]==other.linked[1].coordinates[1]
boulid = self.id==other.id
return boul0 and boul1 and boulid
def __ne__(self,other):
"""2 edges are not equal iff they are not equal :) """
return (self==other)==False
#ne pas mettre @property ici, on veut une methode pas un attribut
def given_cost(self):
return self._given_cost
def __repr__(self):
return f"Edge [{str(self.linked[0].index)}, {str(self.linked[1].index)}] !oriented!"
class Graph:
""" All the information of a graph are contained here. """
def __init__(self,list_of_vertices):
""" Entry : the list of vertices. """
self.list_of_vertices = list_of_vertices
self.number_of_vertices = len(list_of_vertices)
self.connection_table_edge_and_diplayable_edge=[]
self.list_of_edges=[]
self.number_of_disp_edges=0
self.number_of_edges=0
def push_diplayable_edge(self,bidim_array):
self.connection_table_edge_and_diplayable_edge.append(copy.deepcopy(bidim_array))
self.number_of_disp_edges+=1
def push_edge(self,e):
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_edge_without_doublons(self, e):
if e not in self.list_of_edges:
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_vertice(self,vertice):
self.list_of_vertices.append(vertice)
self.number_of_vertices += 1
def push_vertice_without_doublons(self, vertice):
bool,index = self.is_vertice_in_graph_based_on_xy_with_tolerance(vertice,10**(-8))
#bool,index = self.is_vertice_in_graph_based_on_xy(vertice)
if bool == False:
self.push_vertice(vertice)
else:
vertice.coordinates=self.list_of_vertices[index].coordinates
for edge in vertice.edges_list:
if edge not in self.list_of_vertices[index].edges_list:
self.list_of_vertices[index].push_edge(edge,True)
def is_vertice_in_graph_based_on_xy(self,vertice):
for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if v.coordinates[0] == vertice.coordinates[0] and v.coordinates[1] == vertice.coordinates[1]:
return True,i
return False,None
def is_vertice_in_graph_based_on_xy_with_tolerance(self, vertice, epsilon):
for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if ((v.coordinates[0] - vertice.coordinates[0])**2) + ((v.coordinates[1] - vertice.coordinates[1])**2) < epsilon:
return True, i
return False, None
def __getitem__(self, key):#implement instance[key]
if key >= 0 and key < self.number_of_vertices:
return self.list_of_vertices[key]
else :
raise IndexError
def laplace_matrix(self):
""" Returns the laplace matrix. """
n = self.number_of_vertices
laplace_matrix = np.zeros((n, n))
for i in range(n):
laplace_matrix[i][i] = 1
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
laplace_matrix[i][edge.linked[1].index] = 1
return laplace_matrix
def A_matrix(self,type_cost=Edge.given_cost):
""" Returns the laplace matrix. """
n = self.number_of_vertices
A_matrix = np.zeros((n, n))
for i in range(n):
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
cost = type_cost(edge)
A_matrix[i][edge.linked[1].index] = cost
A_matrix[edge.linked[1].index][i] = cost
return A_matrix
def pairs_of_vertices(self):
"""Returns the pairs of connected vertices.
Beware ! There might be non-connected vertices in the graph. """
pairs_of_vertices = []
for vertice in self.list_of_vertices:
for edge in vertice.edges_list:
if non_oriented:
if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:
pairs_of_vertices.append((vertice, edge.linked[1]))
if not non_oriented:
if (vertice, edge.linked[1]) not in pairs_of_vertices:
pairs_of_vertices.append((vertice, edge.linked[1]))
return pairs_of_vertices
def number_of_edges(self):
a=self.pairs_of_vertices()
assert self.number_of_edges==len(a), "problem in Graph.pairs_of_vertices"
return self.number_of_edges
def search_index_by_coordinates(self,coord):
"""search the index of vertice at coordinates: """
for i in range(len(self.list_of_vertices)):
if self[i].coordinates[0]==coord[0] and self[i].coordinates[1]==coord[1]:
return i
def set_right_edges(self):
"""verify that the graph is coherent """
for v in self:
for e in v.edges_list:
e.linked[0]=v
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
for e in self.list_of_edges:
e.linked[0]=self[self.search_index_by_coordinates(e.linked[0].coordinates)]
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
def plot(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
x = e.linked[0].coordinates[0]
y = e.linked[0].coordinates[1]
dx = e.linked[1].coordinates[0] - x
dy = e.linked[1].coordinates[1] - y
plt.plot([x,x+dx], [y,y+dy], color=c)
# plt.arrow(x,y,dx,dy)
plt.axis = 'off'
plt.show()
def plot_dev(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
for i in range(len(self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable])-1):
x = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][0]
y = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][1]
dx = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][0]-x
dy = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][1]-y
plt.plot([x,x+dx], [y,y+dy], color=c)
plt.axis = 'off'
plt.show()
| edges_list | identifier_name |
class_vertice_graph.py | """ The goal of this file is to have all the information on a graph. """
import sys, os, inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0, parentdir)
import numpy as np
import matplotlib.pyplot as plt
import copy
import exceptions
inf = np.inf
#Change this bool according to the situation
non_oriented = False
class Vertice:
"""" All the information of one vertice are contained here. """
def __init__(self, index, coordinates):
""" Entry : index of the vertice in list_of_vertices
and the coordinates of the vertice. """
self.index = index
self.coordinates = np.array([coordinates[0],coordinates[1]])
self._edges_list = [] # no neighbour by default
self.priority = inf # priority by default
self.visited = False # vertice is by default not visited
self.cost_dijkstra = inf # cost is by default inf
self.antecedent = -inf # antecedent not defined before using Dijkstra
#implemente apres passage par panda
self.index_edges_list = []#seulement implemente apres passage par panda
#database
self.id = None #identifiant idfm de la gare
self.gare_name = None #nom de la gare
self.color = None #couleur de la gare
self.is_a_station= True # boolean True, si le noeud est veritablement une gare. False sinon
def get_lines_connected(self):
list_of_line = []
for edge in self._edges_list:
if edge.id not in list_of_line:
list_of_line.append(edge.id)
return list_of_line
@property
def edges_list(self):
""" Returns the list of neighbour. """
return self._edges_list
# We suppose that the index and the coordinates never change.
# The other properties can.
@edges_list.setter
def edges_list(self, edges_list):
""" An element of edges_list is an edge """
for e in edges_list:
exceptions.check_pertinent_edge(self, e)
self._edges_list = edges_list
def neighbours_list(self, list_tuple, id=0):
self._edges_list.clear()
"""interface with old constructor , tuple=(neighbour_vertice,cost) is an element of list_tuple """
for tuple in list_tuple:
E = Edge(self, tuple[0], id, tuple[1])
self._edges_list.append(E)
def number_of_neighbours(self):
return len(self._edges_list)
def is_linked(self, other):
"""returns True if there is an edge between self and other"""
for edge in self._edges_list:
if other.index == edge.linked[1].index:
return True
return False
def push_edge(self, edge, coords_verif=False):
if coords_verif:
exceptions.check_pertinent_edge_coords_verif(self, edge)
else:
exceptions.check_pertinent_edge(self, edge)
self._edges_list.append(edge)
"""
def cost_between(self, other):
for edge in self._edges_list:
[vertice, vertice_voisin] = edge.linked
if vertice_voisin == other:
return edge.given_cost"""
def __repr__(self):
return f"Vertice {str(self.index)}"
def __lt__(self, other):
return self.priority < other.priority
class Edge:
def __init__(self, vertice1, vertice2, id, given_cost=0):
self.linked = [vertice1,vertice2]
self.id = id #identifiant de la liaison. ici id=nom de la ligne a laqualle appartient la liaison
self._given_cost = given_cost #cout de deplacement de la liason donne par l'utilisateur ou la base de donnee
#data_base
self.color=None #couleur de la liason
self.connection_with_displayable=None #indice de la liason developpee( trace reel) dans la table de connection connection_table_edge_and_diplayable_edge de la classe graph
self.index=None
def set_given_cost(self,cost):
self._given_cost=cost
#ne pas mettre @property ici, on veut une methode pas un attribut
def euclidian_cost(self):
return np.sqrt(self.square_euclidian_cost())
def square_euclidian_cost(self):
return np.dot(np.transpose(self.linked[0].coordinates-self.linked[1].coordinates),(self.linked[0].coordinates-self.linked[1].coordinates))
def customized_cost1(self):
V_metro = 25.1 / 3.6 #vitesse moyenne en km/h /3.6 -> vitesse moyenne en m/s
V_train = 49.6 / 3.6
V_tram = 18 / 3.6
V_pieton = 4 / 3.6
if self.id in ["A","B","C","D","E","H","I","J","K","L","M","N","P","R","U","TER","GL"]:
return self._given_cost/V_train
if self.id in [str(i) for i in range(1,15)]+["ORL","CDG","3b","7b"]:
return self._given_cost/V_metro
if self.id in ["T"+str(i) for i in range(1,12)]+["T3A","T3B","FUN"]:
return self._given_cost/V_tram
if self.id in ["RER Walk"]:
return self._given_cost/V_pieton
raise ValueError(" Dans customized_cost1 " +self.id+" non pris en compte dans le calcul de distance")
def __eq__(self,other):
"""2 edges are equal iff same cordinates and same id """
boul0 = self.linked[0].coordinates[0]==other.linked[0].coordinates[0] and self.linked[0].coordinates[1]==other.linked[0].coordinates[1]
boul1 = self.linked[1].coordinates[0]==other.linked[1].coordinates[0] and self.linked[1].coordinates[1]==other.linked[1].coordinates[1]
boulid = self.id==other.id
return boul0 and boul1 and boulid
def __ne__(self,other):
"""2 edges are not equal iff they are not equal :) """
return (self==other)==False
#ne pas mettre @property ici, on veut une methode pas un attribut
def given_cost(self):
return self._given_cost
def __repr__(self):
return f"Edge [{str(self.linked[0].index)}, {str(self.linked[1].index)}] !oriented!"
class Graph:
""" All the information of a graph are contained here. """
def __init__(self,list_of_vertices):
""" Entry : the list of vertices. """
self.list_of_vertices = list_of_vertices | self.number_of_edges=0
def push_diplayable_edge(self,bidim_array):
self.connection_table_edge_and_diplayable_edge.append(copy.deepcopy(bidim_array))
self.number_of_disp_edges+=1
def push_edge(self,e):
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_edge_without_doublons(self, e):
if e not in self.list_of_edges:
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_vertice(self,vertice):
self.list_of_vertices.append(vertice)
self.number_of_vertices += 1
def push_vertice_without_doublons(self, vertice):
bool,index = self.is_vertice_in_graph_based_on_xy_with_tolerance(vertice,10**(-8))
#bool,index = self.is_vertice_in_graph_based_on_xy(vertice)
if bool == False:
self.push_vertice(vertice)
else:
vertice.coordinates=self.list_of_vertices[index].coordinates
for edge in vertice.edges_list:
if edge not in self.list_of_vertices[index].edges_list:
self.list_of_vertices[index].push_edge(edge,True)
def is_vertice_in_graph_based_on_xy(self,vertice):
for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if v.coordinates[0] == vertice.coordinates[0] and v.coordinates[1] == vertice.coordinates[1]:
return True,i
return False,None
def is_vertice_in_graph_based_on_xy_with_tolerance(self, vertice, epsilon):
for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if ((v.coordinates[0] - vertice.coordinates[0])**2) + ((v.coordinates[1] - vertice.coordinates[1])**2) < epsilon:
return True, i
return False, None
def __getitem__(self, key):#implement instance[key]
if key >= 0 and key < self.number_of_vertices:
return self.list_of_vertices[key]
else :
raise IndexError
def laplace_matrix(self):
""" Returns the laplace matrix. """
n = self.number_of_vertices
laplace_matrix = np.zeros((n, n))
for i in range(n):
laplace_matrix[i][i] = 1
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
laplace_matrix[i][edge.linked[1].index] = 1
return laplace_matrix
def A_matrix(self,type_cost=Edge.given_cost):
""" Returns the laplace matrix. """
n = self.number_of_vertices
A_matrix = np.zeros((n, n))
for i in range(n):
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
cost = type_cost(edge)
A_matrix[i][edge.linked[1].index] = cost
A_matrix[edge.linked[1].index][i] = cost
return A_matrix
def pairs_of_vertices(self):
"""Returns the pairs of connected vertices.
Beware ! There might be non-connected vertices in the graph. """
pairs_of_vertices = []
for vertice in self.list_of_vertices:
for edge in vertice.edges_list:
if non_oriented:
if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:
pairs_of_vertices.append((vertice, edge.linked[1]))
if not non_oriented:
if (vertice, edge.linked[1]) not in pairs_of_vertices:
pairs_of_vertices.append((vertice, edge.linked[1]))
return pairs_of_vertices
def number_of_edges(self):
a=self.pairs_of_vertices()
assert self.number_of_edges==len(a), "problem in Graph.pairs_of_vertices"
return self.number_of_edges
def search_index_by_coordinates(self,coord):
"""search the index of vertice at coordinates: """
for i in range(len(self.list_of_vertices)):
if self[i].coordinates[0]==coord[0] and self[i].coordinates[1]==coord[1]:
return i
def set_right_edges(self):
"""verify that the graph is coherent """
for v in self:
for e in v.edges_list:
e.linked[0]=v
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
for e in self.list_of_edges:
e.linked[0]=self[self.search_index_by_coordinates(e.linked[0].coordinates)]
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
def plot(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
x = e.linked[0].coordinates[0]
y = e.linked[0].coordinates[1]
dx = e.linked[1].coordinates[0] - x
dy = e.linked[1].coordinates[1] - y
plt.plot([x,x+dx], [y,y+dy], color=c)
# plt.arrow(x,y,dx,dy)
plt.axis = 'off'
plt.show()
def plot_dev(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
for i in range(len(self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable])-1):
x = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][0]
y = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][1]
dx = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][0]-x
dy = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][1]-y
plt.plot([x,x+dx], [y,y+dy], color=c)
plt.axis = 'off'
plt.show() | self.number_of_vertices = len(list_of_vertices)
self.connection_table_edge_and_diplayable_edge=[]
self.list_of_edges=[]
self.number_of_disp_edges=0 | random_line_split |
class_vertice_graph.py | """ The goal of this file is to have all the information on a graph. """
import sys, os, inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0, parentdir)
import numpy as np
import matplotlib.pyplot as plt
import copy
import exceptions
inf = np.inf
#Change this bool according to the situation
non_oriented = False
class Vertice:
"""" All the information of one vertice are contained here. """
def __init__(self, index, coordinates):
""" Entry : index of the vertice in list_of_vertices
and the coordinates of the vertice. """
self.index = index
self.coordinates = np.array([coordinates[0],coordinates[1]])
self._edges_list = [] # no neighbour by default
self.priority = inf # priority by default
self.visited = False # vertice is by default not visited
self.cost_dijkstra = inf # cost is by default inf
self.antecedent = -inf # antecedent not defined before using Dijkstra
#implemente apres passage par panda
self.index_edges_list = []#seulement implemente apres passage par panda
#database
self.id = None #identifiant idfm de la gare
self.gare_name = None #nom de la gare
self.color = None #couleur de la gare
self.is_a_station= True # boolean True, si le noeud est veritablement une gare. False sinon
def get_lines_connected(self):
list_of_line = []
for edge in self._edges_list:
if edge.id not in list_of_line:
list_of_line.append(edge.id)
return list_of_line
@property
def edges_list(self):
""" Returns the list of neighbour. """
return self._edges_list
# We suppose that the index and the coordinates never change.
# The other properties can.
@edges_list.setter
def edges_list(self, edges_list):
""" An element of edges_list is an edge """
for e in edges_list:
exceptions.check_pertinent_edge(self, e)
self._edges_list = edges_list
def neighbours_list(self, list_tuple, id=0):
self._edges_list.clear()
"""interface with old constructor , tuple=(neighbour_vertice,cost) is an element of list_tuple """
for tuple in list_tuple:
E = Edge(self, tuple[0], id, tuple[1])
self._edges_list.append(E)
def number_of_neighbours(self):
return len(self._edges_list)
def is_linked(self, other):
"""returns True if there is an edge between self and other"""
for edge in self._edges_list:
if other.index == edge.linked[1].index:
return True
return False
def push_edge(self, edge, coords_verif=False):
if coords_verif:
exceptions.check_pertinent_edge_coords_verif(self, edge)
else:
exceptions.check_pertinent_edge(self, edge)
self._edges_list.append(edge)
"""
def cost_between(self, other):
for edge in self._edges_list:
[vertice, vertice_voisin] = edge.linked
if vertice_voisin == other:
return edge.given_cost"""
def __repr__(self):
return f"Vertice {str(self.index)}"
def __lt__(self, other):
return self.priority < other.priority
class Edge:
def __init__(self, vertice1, vertice2, id, given_cost=0):
self.linked = [vertice1,vertice2]
self.id = id #identifiant de la liaison. ici id=nom de la ligne a laqualle appartient la liaison
self._given_cost = given_cost #cout de deplacement de la liason donne par l'utilisateur ou la base de donnee
#data_base
self.color=None #couleur de la liason
self.connection_with_displayable=None #indice de la liason developpee( trace reel) dans la table de connection connection_table_edge_and_diplayable_edge de la classe graph
self.index=None
def set_given_cost(self,cost):
self._given_cost=cost
#ne pas mettre @property ici, on veut une methode pas un attribut
def euclidian_cost(self):
return np.sqrt(self.square_euclidian_cost())
def square_euclidian_cost(self):
return np.dot(np.transpose(self.linked[0].coordinates-self.linked[1].coordinates),(self.linked[0].coordinates-self.linked[1].coordinates))
def customized_cost1(self):
V_metro = 25.1 / 3.6 #vitesse moyenne en km/h /3.6 -> vitesse moyenne en m/s
V_train = 49.6 / 3.6
V_tram = 18 / 3.6
V_pieton = 4 / 3.6
if self.id in ["A","B","C","D","E","H","I","J","K","L","M","N","P","R","U","TER","GL"]:
return self._given_cost/V_train
if self.id in [str(i) for i in range(1,15)]+["ORL","CDG","3b","7b"]:
return self._given_cost/V_metro
if self.id in ["T"+str(i) for i in range(1,12)]+["T3A","T3B","FUN"]:
return self._given_cost/V_tram
if self.id in ["RER Walk"]:
return self._given_cost/V_pieton
raise ValueError(" Dans customized_cost1 " +self.id+" non pris en compte dans le calcul de distance")
def __eq__(self,other):
"""2 edges are equal iff same cordinates and same id """
boul0 = self.linked[0].coordinates[0]==other.linked[0].coordinates[0] and self.linked[0].coordinates[1]==other.linked[0].coordinates[1]
boul1 = self.linked[1].coordinates[0]==other.linked[1].coordinates[0] and self.linked[1].coordinates[1]==other.linked[1].coordinates[1]
boulid = self.id==other.id
return boul0 and boul1 and boulid
def __ne__(self,other):
"""2 edges are not equal iff they are not equal :) """
return (self==other)==False
#ne pas mettre @property ici, on veut une methode pas un attribut
def given_cost(self):
return self._given_cost
def __repr__(self):
return f"Edge [{str(self.linked[0].index)}, {str(self.linked[1].index)}] !oriented!"
class Graph:
""" All the information of a graph are contained here. """
def __init__(self,list_of_vertices):
""" Entry : the list of vertices. """
self.list_of_vertices = list_of_vertices
self.number_of_vertices = len(list_of_vertices)
self.connection_table_edge_and_diplayable_edge=[]
self.list_of_edges=[]
self.number_of_disp_edges=0
self.number_of_edges=0
def push_diplayable_edge(self,bidim_array):
self.connection_table_edge_and_diplayable_edge.append(copy.deepcopy(bidim_array))
self.number_of_disp_edges+=1
def push_edge(self,e):
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_edge_without_doublons(self, e):
if e not in self.list_of_edges:
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_vertice(self,vertice):
self.list_of_vertices.append(vertice)
self.number_of_vertices += 1
def push_vertice_without_doublons(self, vertice):
bool,index = self.is_vertice_in_graph_based_on_xy_with_tolerance(vertice,10**(-8))
#bool,index = self.is_vertice_in_graph_based_on_xy(vertice)
if bool == False:
self.push_vertice(vertice)
else:
vertice.coordinates=self.list_of_vertices[index].coordinates
for edge in vertice.edges_list:
if edge not in self.list_of_vertices[index].edges_list:
self.list_of_vertices[index].push_edge(edge,True)
def is_vertice_in_graph_based_on_xy(self,vertice):
for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if v.coordinates[0] == vertice.coordinates[0] and v.coordinates[1] == vertice.coordinates[1]:
return True,i
return False,None
def is_vertice_in_graph_based_on_xy_with_tolerance(self, vertice, epsilon):
for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if ((v.coordinates[0] - vertice.coordinates[0])**2) + ((v.coordinates[1] - vertice.coordinates[1])**2) < epsilon:
return True, i
return False, None
def __getitem__(self, key):#implement instance[key]
if key >= 0 and key < self.number_of_vertices:
return self.list_of_vertices[key]
else :
raise IndexError
def laplace_matrix(self):
""" Returns the laplace matrix. """
n = self.number_of_vertices
laplace_matrix = np.zeros((n, n))
for i in range(n):
laplace_matrix[i][i] = 1
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
laplace_matrix[i][edge.linked[1].index] = 1
return laplace_matrix
def A_matrix(self,type_cost=Edge.given_cost):
""" Returns the laplace matrix. """
n = self.number_of_vertices
A_matrix = np.zeros((n, n))
for i in range(n):
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
cost = type_cost(edge)
A_matrix[i][edge.linked[1].index] = cost
A_matrix[edge.linked[1].index][i] = cost
return A_matrix
def pairs_of_vertices(self):
"""Returns the pairs of connected vertices.
Beware ! There might be non-connected vertices in the graph. """
pairs_of_vertices = []
for vertice in self.list_of_vertices:
for edge in vertice.edges_list:
if non_oriented:
if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:
|
if not non_oriented:
if (vertice, edge.linked[1]) not in pairs_of_vertices:
pairs_of_vertices.append((vertice, edge.linked[1]))
return pairs_of_vertices
def number_of_edges(self):
a=self.pairs_of_vertices()
assert self.number_of_edges==len(a), "problem in Graph.pairs_of_vertices"
return self.number_of_edges
def search_index_by_coordinates(self,coord):
"""search the index of vertice at coordinates: """
for i in range(len(self.list_of_vertices)):
if self[i].coordinates[0]==coord[0] and self[i].coordinates[1]==coord[1]:
return i
def set_right_edges(self):
"""verify that the graph is coherent """
for v in self:
for e in v.edges_list:
e.linked[0]=v
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
for e in self.list_of_edges:
e.linked[0]=self[self.search_index_by_coordinates(e.linked[0].coordinates)]
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
def plot(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
x = e.linked[0].coordinates[0]
y = e.linked[0].coordinates[1]
dx = e.linked[1].coordinates[0] - x
dy = e.linked[1].coordinates[1] - y
plt.plot([x,x+dx], [y,y+dy], color=c)
# plt.arrow(x,y,dx,dy)
plt.axis = 'off'
plt.show()
def plot_dev(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
for i in range(len(self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable])-1):
x = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][0]
y = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][1]
dx = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][0]-x
dy = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][1]-y
plt.plot([x,x+dx], [y,y+dy], color=c)
plt.axis = 'off'
plt.show()
| pairs_of_vertices.append((vertice, edge.linked[1])) | conditional_block |
class_vertice_graph.py | """ The goal of this file is to have all the information on a graph. """
import sys, os, inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0, parentdir)
import numpy as np
import matplotlib.pyplot as plt
import copy
import exceptions
inf = np.inf
#Change this bool according to the situation
non_oriented = False
class Vertice:
"""" All the information of one vertice are contained here. """
def __init__(self, index, coordinates):
""" Entry : index of the vertice in list_of_vertices
and the coordinates of the vertice. """
self.index = index
self.coordinates = np.array([coordinates[0],coordinates[1]])
self._edges_list = [] # no neighbour by default
self.priority = inf # priority by default
self.visited = False # vertice is by default not visited
self.cost_dijkstra = inf # cost is by default inf
self.antecedent = -inf # antecedent not defined before using Dijkstra
#implemente apres passage par panda
self.index_edges_list = []#seulement implemente apres passage par panda
#database
self.id = None #identifiant idfm de la gare
self.gare_name = None #nom de la gare
self.color = None #couleur de la gare
self.is_a_station= True # boolean True, si le noeud est veritablement une gare. False sinon
def get_lines_connected(self):
list_of_line = []
for edge in self._edges_list:
if edge.id not in list_of_line:
list_of_line.append(edge.id)
return list_of_line
@property
def edges_list(self):
""" Returns the list of neighbour. """
return self._edges_list
# We suppose that the index and the coordinates never change.
# The other properties can.
@edges_list.setter
def edges_list(self, edges_list):
""" An element of edges_list is an edge """
for e in edges_list:
exceptions.check_pertinent_edge(self, e)
self._edges_list = edges_list
def neighbours_list(self, list_tuple, id=0):
self._edges_list.clear()
"""interface with old constructor , tuple=(neighbour_vertice,cost) is an element of list_tuple """
for tuple in list_tuple:
E = Edge(self, tuple[0], id, tuple[1])
self._edges_list.append(E)
def number_of_neighbours(self):
return len(self._edges_list)
def is_linked(self, other):
"""returns True if there is an edge between self and other"""
for edge in self._edges_list:
if other.index == edge.linked[1].index:
return True
return False
def push_edge(self, edge, coords_verif=False):
if coords_verif:
exceptions.check_pertinent_edge_coords_verif(self, edge)
else:
exceptions.check_pertinent_edge(self, edge)
self._edges_list.append(edge)
"""
def cost_between(self, other):
for edge in self._edges_list:
[vertice, vertice_voisin] = edge.linked
if vertice_voisin == other:
return edge.given_cost"""
def __repr__(self):
return f"Vertice {str(self.index)}"
def __lt__(self, other):
return self.priority < other.priority
class Edge:
def __init__(self, vertice1, vertice2, id, given_cost=0):
self.linked = [vertice1,vertice2]
self.id = id #identifiant de la liaison. ici id=nom de la ligne a laqualle appartient la liaison
self._given_cost = given_cost #cout de deplacement de la liason donne par l'utilisateur ou la base de donnee
#data_base
self.color=None #couleur de la liason
self.connection_with_displayable=None #indice de la liason developpee( trace reel) dans la table de connection connection_table_edge_and_diplayable_edge de la classe graph
self.index=None
def set_given_cost(self,cost):
self._given_cost=cost
#ne pas mettre @property ici, on veut une methode pas un attribut
def euclidian_cost(self):
return np.sqrt(self.square_euclidian_cost())
def square_euclidian_cost(self):
return np.dot(np.transpose(self.linked[0].coordinates-self.linked[1].coordinates),(self.linked[0].coordinates-self.linked[1].coordinates))
def customized_cost1(self):
V_metro = 25.1 / 3.6 #vitesse moyenne en km/h /3.6 -> vitesse moyenne en m/s
V_train = 49.6 / 3.6
V_tram = 18 / 3.6
V_pieton = 4 / 3.6
if self.id in ["A","B","C","D","E","H","I","J","K","L","M","N","P","R","U","TER","GL"]:
return self._given_cost/V_train
if self.id in [str(i) for i in range(1,15)]+["ORL","CDG","3b","7b"]:
return self._given_cost/V_metro
if self.id in ["T"+str(i) for i in range(1,12)]+["T3A","T3B","FUN"]:
return self._given_cost/V_tram
if self.id in ["RER Walk"]:
return self._given_cost/V_pieton
raise ValueError(" Dans customized_cost1 " +self.id+" non pris en compte dans le calcul de distance")
def __eq__(self,other):
"""2 edges are equal iff same cordinates and same id """
boul0 = self.linked[0].coordinates[0]==other.linked[0].coordinates[0] and self.linked[0].coordinates[1]==other.linked[0].coordinates[1]
boul1 = self.linked[1].coordinates[0]==other.linked[1].coordinates[0] and self.linked[1].coordinates[1]==other.linked[1].coordinates[1]
boulid = self.id==other.id
return boul0 and boul1 and boulid
def __ne__(self,other):
"""2 edges are not equal iff they are not equal :) """
return (self==other)==False
#ne pas mettre @property ici, on veut une methode pas un attribut
def given_cost(self):
return self._given_cost
def __repr__(self):
return f"Edge [{str(self.linked[0].index)}, {str(self.linked[1].index)}] !oriented!"
class Graph:
""" All the information of a graph are contained here. """
def __init__(self,list_of_vertices):
""" Entry : the list of vertices. """
self.list_of_vertices = list_of_vertices
self.number_of_vertices = len(list_of_vertices)
self.connection_table_edge_and_diplayable_edge=[]
self.list_of_edges=[]
self.number_of_disp_edges=0
self.number_of_edges=0
def push_diplayable_edge(self,bidim_array):
self.connection_table_edge_and_diplayable_edge.append(copy.deepcopy(bidim_array))
self.number_of_disp_edges+=1
def push_edge(self,e):
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_edge_without_doublons(self, e):
if e not in self.list_of_edges:
self.number_of_edges+=1
self.list_of_edges.append(e)
def push_vertice(self,vertice):
self.list_of_vertices.append(vertice)
self.number_of_vertices += 1
def push_vertice_without_doublons(self, vertice):
bool,index = self.is_vertice_in_graph_based_on_xy_with_tolerance(vertice,10**(-8))
#bool,index = self.is_vertice_in_graph_based_on_xy(vertice)
if bool == False:
self.push_vertice(vertice)
else:
vertice.coordinates=self.list_of_vertices[index].coordinates
for edge in vertice.edges_list:
if edge not in self.list_of_vertices[index].edges_list:
self.list_of_vertices[index].push_edge(edge,True)
def is_vertice_in_graph_based_on_xy(self,vertice):
|
def is_vertice_in_graph_based_on_xy_with_tolerance(self, vertice, epsilon):
for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if ((v.coordinates[0] - vertice.coordinates[0])**2) + ((v.coordinates[1] - vertice.coordinates[1])**2) < epsilon:
return True, i
return False, None
def __getitem__(self, key):#implement instance[key]
if key >= 0 and key < self.number_of_vertices:
return self.list_of_vertices[key]
else :
raise IndexError
def laplace_matrix(self):
""" Returns the laplace matrix. """
n = self.number_of_vertices
laplace_matrix = np.zeros((n, n))
for i in range(n):
laplace_matrix[i][i] = 1
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
laplace_matrix[i][edge.linked[1].index] = 1
return laplace_matrix
def A_matrix(self,type_cost=Edge.given_cost):
""" Returns the laplace matrix. """
n = self.number_of_vertices
A_matrix = np.zeros((n, n))
for i in range(n):
vertice = self.list_of_vertices[i]
for edge in vertice.edges_list:
cost = type_cost(edge)
A_matrix[i][edge.linked[1].index] = cost
A_matrix[edge.linked[1].index][i] = cost
return A_matrix
def pairs_of_vertices(self):
"""Returns the pairs of connected vertices.
Beware ! There might be non-connected vertices in the graph. """
pairs_of_vertices = []
for vertice in self.list_of_vertices:
for edge in vertice.edges_list:
if non_oriented:
if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:
pairs_of_vertices.append((vertice, edge.linked[1]))
if not non_oriented:
if (vertice, edge.linked[1]) not in pairs_of_vertices:
pairs_of_vertices.append((vertice, edge.linked[1]))
return pairs_of_vertices
def number_of_edges(self):
a=self.pairs_of_vertices()
assert self.number_of_edges==len(a), "problem in Graph.pairs_of_vertices"
return self.number_of_edges
def search_index_by_coordinates(self,coord):
"""search the index of vertice at coordinates: """
for i in range(len(self.list_of_vertices)):
if self[i].coordinates[0]==coord[0] and self[i].coordinates[1]==coord[1]:
return i
def set_right_edges(self):
"""verify that the graph is coherent """
for v in self:
for e in v.edges_list:
e.linked[0]=v
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
for e in self.list_of_edges:
e.linked[0]=self[self.search_index_by_coordinates(e.linked[0].coordinates)]
e.linked[1]=self[self.search_index_by_coordinates(e.linked[1].coordinates)]
def plot(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
x = e.linked[0].coordinates[0]
y = e.linked[0].coordinates[1]
dx = e.linked[1].coordinates[0] - x
dy = e.linked[1].coordinates[1] - y
plt.plot([x,x+dx], [y,y+dy], color=c)
# plt.arrow(x,y,dx,dy)
plt.axis = 'off'
plt.show()
def plot_dev(self):
plt.clf()
for v in self._list_of_vertices:
c = f"#{v.color}"
plt.scatter(v.coordinates[0], v.coordinates[1], color=c)
for e in v.edges_list:
c = f"#{e.color}"
for i in range(len(self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable])-1):
x = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][0]
y = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i][1]
dx = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][0]-x
dy = self.connection_table_edge_and_diplayable_edge[e.connection_with_displayable][i+1][1]-y
plt.plot([x,x+dx], [y,y+dy], color=c)
plt.axis = 'off'
plt.show()
| for i in range(self.number_of_vertices):
v = self.list_of_vertices[i]
if v.coordinates[0] == vertice.coordinates[0] and v.coordinates[1] == vertice.coordinates[1]:
return True,i
return False,None | identifier_body |
build.rs | #[cfg(not(feature = "binary"))]
fn main() {}
#[cfg(feature = "binary")]
fn main() {
binary::main();
}
#[cfg(feature = "binary")]
mod binary {
use quote::quote;
use std::convert::TryInto;
pub fn main() {
use llvm_tools_build as llvm_tools;
use std::{
env,
fs::{self, File},
io::Write,
path::{Path, PathBuf},
process::{self, Command},
};
use toml::Value;
let target = env::var("TARGET").expect("TARGET not set");
let (firmware, expected_target) = if cfg!(feature = "uefi_bin") {
("UEFI", "x86_64-unknown-uefi")
} else if cfg!(feature = "bios_bin") {
("BIOS", "x86_64-bootloader")
} else {
panic!(
"Either the `uefi_bin` or `bios_bin` feature must be enabled when \
the `binary` feature is enabled"
);
};
if Path::new(&target)
.file_stem()
.expect("target has no file stem")
!= expected_target
|
let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set"));
let kernel = PathBuf::from(match env::var("KERNEL") {
Ok(kernel) => kernel,
Err(_) => {
eprintln!(
"The KERNEL environment variable must be set for building the bootloader.\n\n\
Please use the `cargo builder` command for building."
);
process::exit(1);
}
});
let kernel_file_name = kernel
.file_name()
.expect("KERNEL has no valid file name")
.to_str()
.expect("kernel file name not valid utf8");
// check that the kernel file exists
assert!(
kernel.exists(),
"KERNEL does not exist: {}",
kernel.display()
);
// get access to llvm tools shipped in the llvm-tools-preview rustup component
let llvm_tools = match llvm_tools::LlvmTools::new() {
Ok(tools) => tools,
Err(llvm_tools::Error::NotFound) => {
eprintln!("Error: llvm-tools not found");
eprintln!("Maybe the rustup component `llvm-tools-preview` is missing?");
eprintln!(" Install it through: `rustup component add llvm-tools-preview`");
process::exit(1);
}
Err(err) => {
eprintln!("Failed to retrieve llvm-tools component: {:?}", err);
process::exit(1);
}
};
// check that kernel executable has code in it
let llvm_size = llvm_tools
.tool(&llvm_tools::exe("llvm-size"))
.expect("llvm-size not found in llvm-tools");
let mut cmd = Command::new(llvm_size);
cmd.arg(&kernel);
let output = cmd.output().expect("failed to run llvm-size");
let output_str = String::from_utf8_lossy(&output.stdout);
let second_line_opt = output_str.lines().skip(1).next();
let second_line = second_line_opt.expect(&format!(
"unexpected llvm-size line output:\n{}",
output_str
));
let text_size_opt = second_line.split_ascii_whitespace().next();
let text_size =
text_size_opt.expect(&format!("unexpected llvm-size output:\n{}", output_str));
if text_size == "0" {
panic!("Kernel executable has an empty text section. Perhaps the entry point was set incorrectly?\n\n\
Kernel executable at `{}`\n", kernel.display());
}
// strip debug symbols from kernel for faster loading
let stripped_kernel_file_name = format!("kernel_stripped-{}", kernel_file_name);
let stripped_kernel = out_dir.join(&stripped_kernel_file_name);
let objcopy = llvm_tools
.tool(&llvm_tools::exe("llvm-objcopy"))
.expect("llvm-objcopy not found in llvm-tools");
let mut cmd = Command::new(&objcopy);
cmd.arg("--strip-debug");
cmd.arg(&kernel);
cmd.arg(&stripped_kernel);
let exit_status = cmd
.status()
.expect("failed to run objcopy to strip debug symbols");
if !exit_status.success() {
eprintln!("Error: Stripping debug symbols failed");
process::exit(1);
}
if cfg!(feature = "uefi_bin") {
// write file for including kernel in binary
let file_path = out_dir.join("kernel_info.rs");
let mut file = File::create(file_path).expect("failed to create kernel_info.rs");
let kernel_size = fs::metadata(&stripped_kernel)
.expect("Failed to read file metadata of stripped kernel")
.len();
file.write_all(
format!(
"const KERNEL_SIZE: usize = {}; const KERNEL_BYTES: [u8; KERNEL_SIZE] = *include_bytes!(r\"{}\");",
kernel_size,
stripped_kernel.display(),
)
.as_bytes(),
)
.expect("write to kernel_info.rs failed");
}
if cfg!(feature = "bios_bin") {
// wrap the kernel executable as binary in a new ELF file
let stripped_kernel_file_name_replaced = stripped_kernel_file_name
.replace('-', "_")
.replace('.', "_");
let kernel_bin = out_dir.join(format!("kernel_bin-{}.o", kernel_file_name));
let kernel_archive = out_dir.join(format!("libkernel_bin-{}.a", kernel_file_name));
let mut cmd = Command::new(&objcopy);
cmd.arg("-I").arg("binary");
cmd.arg("-O").arg("elf64-x86-64");
cmd.arg("--binary-architecture=i386:x86-64");
cmd.arg("--rename-section").arg(".data=.kernel");
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_start=_kernel_start_addr",
stripped_kernel_file_name_replaced
));
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_end=_kernel_end_addr",
stripped_kernel_file_name_replaced
));
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_size=_kernel_size",
stripped_kernel_file_name_replaced
));
cmd.current_dir(&out_dir);
cmd.arg(&stripped_kernel_file_name);
cmd.arg(&kernel_bin);
let exit_status = cmd.status().expect("failed to run objcopy");
if !exit_status.success() {
eprintln!("Error: Running objcopy failed");
process::exit(1);
}
// create an archive for linking
let ar = llvm_tools
.tool(&llvm_tools::exe("llvm-ar"))
.unwrap_or_else(|| {
eprintln!("Failed to retrieve llvm-ar component");
eprint!("This component is available since nightly-2019-03-29,");
eprintln!("so try updating your toolchain if you're using an older nightly");
process::exit(1);
});
let mut cmd = Command::new(ar);
cmd.arg("crs");
cmd.arg(&kernel_archive);
cmd.arg(&kernel_bin);
let exit_status = cmd.status().expect("failed to run ar");
if !exit_status.success() {
eprintln!("Error: Running ar failed");
process::exit(1);
}
// pass link arguments to rustc
println!("cargo:rustc-link-search=native={}", out_dir.display());
println!(
"cargo:rustc-link-lib=static=kernel_bin-{}",
kernel_file_name
);
}
// Parse configuration from the kernel's Cargo.toml
let config = match env::var("KERNEL_MANIFEST") {
Err(env::VarError::NotPresent) => {
panic!("The KERNEL_MANIFEST environment variable must be set for building the bootloader.\n\n\
Please use `cargo builder` for building.");
}
Err(env::VarError::NotUnicode(_)) => {
panic!("The KERNEL_MANIFEST environment variable contains invalid unicode")
}
Ok(path)
if Path::new(&path).file_name().and_then(|s| s.to_str()) != Some("Cargo.toml") =>
{
let err = format!(
"The given `--kernel-manifest` path `{}` does not \
point to a `Cargo.toml`",
path,
);
quote! { compile_error!(#err) }
}
Ok(path) if !Path::new(&path).exists() => {
let err = format!(
"The given `--kernel-manifest` path `{}` does not exist.",
path
);
quote! {
compile_error!(#err)
}
}
Ok(path) => {
println!("cargo:rerun-if-changed={}", path);
let contents = fs::read_to_string(&path).expect(&format!(
"failed to read kernel manifest file (path: {})",
path
));
let manifest = contents
.parse::<Value>()
.expect("failed to parse kernel's Cargo.toml");
if manifest
.get("dependencies")
.and_then(|d| d.get("bootloader"))
.is_some()
{
// it seems to be the correct Cargo.toml
let config_table = manifest
.get("package")
.and_then(|table| table.get("metadata"))
.and_then(|table| table.get("bootloader"))
.cloned()
.unwrap_or_else(|| toml::Value::Table(toml::map::Map::new()));
config_table
.try_into::<ParsedConfig>()
.map(|c| quote! { #c })
.unwrap_or_else(|err| {
let err = format!(
"failed to parse bootloader config in {}:\n\n{}",
path,
err.to_string()
);
quote! {
compile_error!(#err)
}
})
} else {
let err = format!(
"no bootloader dependency in {}\n\n The \
`--kernel-manifest` path should point to the `Cargo.toml` \
of the kernel.",
path
);
quote! {
compile_error!(#err)
}
}
}
};
// Write config to file
let file_path = out_dir.join("bootloader_config.rs");
let mut file = File::create(file_path).expect("failed to create bootloader_config.rs");
file.write_all(
quote::quote! {
mod parsed_config {
use crate::config::Config;
pub const CONFIG: Config = #config;
}
}
.to_string()
.as_bytes(),
)
.expect("write to bootloader_config.rs failed");
println!("cargo:rerun-if-env-changed=KERNEL");
println!("cargo:rerun-if-env-changed=KERNEL_MANIFEST");
println!("cargo:rerun-if-changed={}", kernel.display());
println!("cargo:rerun-if-changed=build.rs");
}
fn val_true() -> bool {
true
}
/// Must be always identical with the struct in `src/config.rs`
///
/// This copy is needed because we can't derive Deserialize in the `src/config.rs`
/// module itself, since cargo currently unifies dependencies (the `toml` crate enables
/// serde's standard feature). Also, it allows to separate the parsing special cases
/// such as `AlignedAddress` more cleanly.
#[derive(Debug, serde::Deserialize)]
#[serde(rename_all = "kebab-case", deny_unknown_fields)]
struct ParsedConfig {
#[serde(default)]
pub map_physical_memory: bool,
#[serde(default)]
pub map_page_table_recursively: bool,
#[serde(default = "val_true")]
pub map_framebuffer: bool,
pub kernel_stack_size: Option<AlignedAddress>,
pub physical_memory_offset: Option<AlignedAddress>,
pub recursive_index: Option<u16>,
pub kernel_stack_address: Option<AlignedAddress>,
pub boot_info_address: Option<AlignedAddress>,
pub framebuffer_address: Option<AlignedAddress>,
}
/// Convert to tokens suitable for initializing the `Config` struct.
impl quote::ToTokens for ParsedConfig {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
fn optional(value: Option<impl quote::ToTokens>) -> proc_macro2::TokenStream {
value.map(|v| quote!(Some(#v))).unwrap_or(quote!(None))
}
let map_physical_memory = self.map_physical_memory;
let map_page_table_recursively = self.map_page_table_recursively;
let map_framebuffer = self.map_framebuffer;
let kernel_stack_size = optional(self.kernel_stack_size);
let physical_memory_offset = optional(self.physical_memory_offset);
let recursive_index = optional(self.recursive_index);
let kernel_stack_address = optional(self.kernel_stack_address);
let boot_info_address = optional(self.boot_info_address);
let framebuffer_address = optional(self.framebuffer_address);
tokens.extend(quote! { Config {
map_physical_memory: #map_physical_memory,
map_page_table_recursively: #map_page_table_recursively,
map_framebuffer: #map_framebuffer,
kernel_stack_size: #kernel_stack_size,
physical_memory_offset: #physical_memory_offset,
recursive_index: #recursive_index,
kernel_stack_address: #kernel_stack_address,
boot_info_address: #boot_info_address,
framebuffer_address: #framebuffer_address,
}});
}
}
#[derive(Debug, Clone, Copy)]
struct AlignedAddress(u64);
impl quote::ToTokens for AlignedAddress {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
self.0.to_tokens(tokens);
}
}
impl<'de> serde::Deserialize<'de> for AlignedAddress {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_str(AlignedAddressVisitor)
}
}
/// Helper struct for implementing the `optional_version_deserialize` function.
struct AlignedAddressVisitor;
impl serde::de::Visitor<'_> for AlignedAddressVisitor {
type Value = AlignedAddress;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(
formatter,
"a page-aligned memory address, either as integer or as decimal or hexadecimal \
string (e.g. \"0xffff0000\"); large addresses must be given as string because \
TOML does not support unsigned 64-bit integers"
)
}
fn visit_u64<E>(self, num: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if num % 0x1000 == 0 {
Ok(AlignedAddress(num))
} else {
Err(serde::de::Error::custom(format!(
"address {:#x} is not page aligned",
num
)))
}
}
fn visit_i64<E>(self, num: i64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
let unsigned: u64 = num
.try_into()
.map_err(|_| serde::de::Error::custom(format!("address {} is negative", num)))?;
self.visit_u64(unsigned)
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
// ignore any `_` (used for digit grouping)
let value = &value.replace('_', "");
let num = if value.starts_with("0x") {
u64::from_str_radix(&value[2..], 16)
} else {
u64::from_str_radix(&value, 10)
}
.map_err(|_err| {
serde::de::Error::custom(format!(
"string \"{}\" is not a valid memory address",
value
))
})?;
self.visit_u64(num)
}
}
}
| {
panic!(
"The {} bootloader must be compiled for the `{}` target.",
firmware, expected_target,
);
} | conditional_block |
build.rs | #[cfg(not(feature = "binary"))]
fn main() {}
#[cfg(feature = "binary")]
fn main() {
binary::main();
}
#[cfg(feature = "binary")]
mod binary {
use quote::quote;
use std::convert::TryInto;
pub fn main() {
use llvm_tools_build as llvm_tools;
use std::{
env,
fs::{self, File},
io::Write,
path::{Path, PathBuf},
process::{self, Command},
};
use toml::Value;
let target = env::var("TARGET").expect("TARGET not set");
let (firmware, expected_target) = if cfg!(feature = "uefi_bin") {
("UEFI", "x86_64-unknown-uefi")
} else if cfg!(feature = "bios_bin") {
("BIOS", "x86_64-bootloader")
} else {
panic!(
"Either the `uefi_bin` or `bios_bin` feature must be enabled when \
the `binary` feature is enabled"
);
};
if Path::new(&target)
.file_stem()
.expect("target has no file stem")
!= expected_target
{
panic!(
"The {} bootloader must be compiled for the `{}` target.",
firmware, expected_target,
);
}
let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set"));
let kernel = PathBuf::from(match env::var("KERNEL") {
Ok(kernel) => kernel,
Err(_) => {
eprintln!(
"The KERNEL environment variable must be set for building the bootloader.\n\n\
Please use the `cargo builder` command for building."
);
process::exit(1);
}
});
let kernel_file_name = kernel
.file_name()
.expect("KERNEL has no valid file name")
.to_str()
.expect("kernel file name not valid utf8");
// check that the kernel file exists
assert!(
kernel.exists(),
"KERNEL does not exist: {}",
kernel.display()
);
// get access to llvm tools shipped in the llvm-tools-preview rustup component
let llvm_tools = match llvm_tools::LlvmTools::new() {
Ok(tools) => tools,
Err(llvm_tools::Error::NotFound) => {
eprintln!("Error: llvm-tools not found");
eprintln!("Maybe the rustup component `llvm-tools-preview` is missing?");
eprintln!(" Install it through: `rustup component add llvm-tools-preview`");
process::exit(1);
}
Err(err) => {
eprintln!("Failed to retrieve llvm-tools component: {:?}", err);
process::exit(1);
}
};
// check that kernel executable has code in it
let llvm_size = llvm_tools
.tool(&llvm_tools::exe("llvm-size"))
.expect("llvm-size not found in llvm-tools");
let mut cmd = Command::new(llvm_size);
cmd.arg(&kernel);
let output = cmd.output().expect("failed to run llvm-size");
let output_str = String::from_utf8_lossy(&output.stdout);
let second_line_opt = output_str.lines().skip(1).next();
let second_line = second_line_opt.expect(&format!(
"unexpected llvm-size line output:\n{}",
output_str
));
let text_size_opt = second_line.split_ascii_whitespace().next();
let text_size =
text_size_opt.expect(&format!("unexpected llvm-size output:\n{}", output_str));
if text_size == "0" {
panic!("Kernel executable has an empty text section. Perhaps the entry point was set incorrectly?\n\n\
Kernel executable at `{}`\n", kernel.display());
}
// strip debug symbols from kernel for faster loading
let stripped_kernel_file_name = format!("kernel_stripped-{}", kernel_file_name);
let stripped_kernel = out_dir.join(&stripped_kernel_file_name);
let objcopy = llvm_tools
.tool(&llvm_tools::exe("llvm-objcopy"))
.expect("llvm-objcopy not found in llvm-tools");
let mut cmd = Command::new(&objcopy);
cmd.arg("--strip-debug");
cmd.arg(&kernel);
cmd.arg(&stripped_kernel);
let exit_status = cmd
.status()
.expect("failed to run objcopy to strip debug symbols");
if !exit_status.success() {
eprintln!("Error: Stripping debug symbols failed");
process::exit(1);
}
if cfg!(feature = "uefi_bin") {
// write file for including kernel in binary
let file_path = out_dir.join("kernel_info.rs");
let mut file = File::create(file_path).expect("failed to create kernel_info.rs");
let kernel_size = fs::metadata(&stripped_kernel)
.expect("Failed to read file metadata of stripped kernel")
.len();
file.write_all(
format!(
"const KERNEL_SIZE: usize = {}; const KERNEL_BYTES: [u8; KERNEL_SIZE] = *include_bytes!(r\"{}\");",
kernel_size,
stripped_kernel.display(),
)
.as_bytes(),
)
.expect("write to kernel_info.rs failed");
}
if cfg!(feature = "bios_bin") {
// wrap the kernel executable as binary in a new ELF file
let stripped_kernel_file_name_replaced = stripped_kernel_file_name
.replace('-', "_")
.replace('.', "_");
let kernel_bin = out_dir.join(format!("kernel_bin-{}.o", kernel_file_name));
let kernel_archive = out_dir.join(format!("libkernel_bin-{}.a", kernel_file_name));
let mut cmd = Command::new(&objcopy);
cmd.arg("-I").arg("binary");
cmd.arg("-O").arg("elf64-x86-64");
cmd.arg("--binary-architecture=i386:x86-64");
cmd.arg("--rename-section").arg(".data=.kernel");
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_start=_kernel_start_addr",
stripped_kernel_file_name_replaced
));
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_end=_kernel_end_addr",
stripped_kernel_file_name_replaced
));
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_size=_kernel_size",
stripped_kernel_file_name_replaced
));
cmd.current_dir(&out_dir);
cmd.arg(&stripped_kernel_file_name);
cmd.arg(&kernel_bin);
let exit_status = cmd.status().expect("failed to run objcopy");
if !exit_status.success() {
eprintln!("Error: Running objcopy failed");
process::exit(1);
}
// create an archive for linking
let ar = llvm_tools
.tool(&llvm_tools::exe("llvm-ar"))
.unwrap_or_else(|| {
eprintln!("Failed to retrieve llvm-ar component");
eprint!("This component is available since nightly-2019-03-29,");
eprintln!("so try updating your toolchain if you're using an older nightly");
process::exit(1);
});
let mut cmd = Command::new(ar);
cmd.arg("crs");
cmd.arg(&kernel_archive);
cmd.arg(&kernel_bin);
let exit_status = cmd.status().expect("failed to run ar");
if !exit_status.success() {
eprintln!("Error: Running ar failed");
process::exit(1);
}
// pass link arguments to rustc
println!("cargo:rustc-link-search=native={}", out_dir.display());
println!(
"cargo:rustc-link-lib=static=kernel_bin-{}",
kernel_file_name
);
}
// Parse configuration from the kernel's Cargo.toml
let config = match env::var("KERNEL_MANIFEST") {
Err(env::VarError::NotPresent) => {
panic!("The KERNEL_MANIFEST environment variable must be set for building the bootloader.\n\n\
Please use `cargo builder` for building.");
}
Err(env::VarError::NotUnicode(_)) => {
panic!("The KERNEL_MANIFEST environment variable contains invalid unicode")
}
Ok(path)
if Path::new(&path).file_name().and_then(|s| s.to_str()) != Some("Cargo.toml") =>
{
let err = format!(
"The given `--kernel-manifest` path `{}` does not \
point to a `Cargo.toml`",
path,
);
quote! { compile_error!(#err) }
}
Ok(path) if !Path::new(&path).exists() => {
let err = format!(
"The given `--kernel-manifest` path `{}` does not exist.",
path
);
quote! {
compile_error!(#err)
}
}
Ok(path) => {
println!("cargo:rerun-if-changed={}", path);
let contents = fs::read_to_string(&path).expect(&format!(
"failed to read kernel manifest file (path: {})",
path
));
let manifest = contents
.parse::<Value>()
.expect("failed to parse kernel's Cargo.toml");
if manifest
.get("dependencies")
.and_then(|d| d.get("bootloader"))
.is_some()
{
// it seems to be the correct Cargo.toml
let config_table = manifest
.get("package")
.and_then(|table| table.get("metadata"))
.and_then(|table| table.get("bootloader"))
.cloned()
.unwrap_or_else(|| toml::Value::Table(toml::map::Map::new()));
config_table
.try_into::<ParsedConfig>()
.map(|c| quote! { #c })
.unwrap_or_else(|err| {
let err = format!(
"failed to parse bootloader config in {}:\n\n{}",
path,
err.to_string()
);
quote! {
compile_error!(#err)
}
})
} else {
let err = format!(
"no bootloader dependency in {}\n\n The \
`--kernel-manifest` path should point to the `Cargo.toml` \
of the kernel.",
path
);
quote! {
compile_error!(#err)
}
}
}
};
// Write config to file
let file_path = out_dir.join("bootloader_config.rs");
let mut file = File::create(file_path).expect("failed to create bootloader_config.rs");
file.write_all(
quote::quote! {
mod parsed_config {
use crate::config::Config;
pub const CONFIG: Config = #config;
}
}
.to_string()
.as_bytes(),
)
.expect("write to bootloader_config.rs failed");
println!("cargo:rerun-if-env-changed=KERNEL");
println!("cargo:rerun-if-env-changed=KERNEL_MANIFEST");
println!("cargo:rerun-if-changed={}", kernel.display());
println!("cargo:rerun-if-changed=build.rs");
}
fn val_true() -> bool {
true
}
/// Must be always identical with the struct in `src/config.rs`
///
/// This copy is needed because we can't derive Deserialize in the `src/config.rs`
/// module itself, since cargo currently unifies dependencies (the `toml` crate enables
/// serde's standard feature). Also, it allows to separate the parsing special cases
/// such as `AlignedAddress` more cleanly.
#[derive(Debug, serde::Deserialize)]
#[serde(rename_all = "kebab-case", deny_unknown_fields)]
struct ParsedConfig {
#[serde(default)]
pub map_physical_memory: bool,
#[serde(default)]
pub map_page_table_recursively: bool,
#[serde(default = "val_true")]
pub map_framebuffer: bool,
pub kernel_stack_size: Option<AlignedAddress>,
pub physical_memory_offset: Option<AlignedAddress>,
pub recursive_index: Option<u16>,
pub kernel_stack_address: Option<AlignedAddress>,
pub boot_info_address: Option<AlignedAddress>,
pub framebuffer_address: Option<AlignedAddress>,
}
/// Convert to tokens suitable for initializing the `Config` struct.
impl quote::ToTokens for ParsedConfig {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
fn optional(value: Option<impl quote::ToTokens>) -> proc_macro2::TokenStream {
value.map(|v| quote!(Some(#v))).unwrap_or(quote!(None))
}
let map_physical_memory = self.map_physical_memory;
let map_page_table_recursively = self.map_page_table_recursively;
let map_framebuffer = self.map_framebuffer;
let kernel_stack_size = optional(self.kernel_stack_size);
let physical_memory_offset = optional(self.physical_memory_offset);
let recursive_index = optional(self.recursive_index);
let kernel_stack_address = optional(self.kernel_stack_address);
let boot_info_address = optional(self.boot_info_address);
let framebuffer_address = optional(self.framebuffer_address);
tokens.extend(quote! { Config {
map_physical_memory: #map_physical_memory,
map_page_table_recursively: #map_page_table_recursively,
map_framebuffer: #map_framebuffer,
kernel_stack_size: #kernel_stack_size,
physical_memory_offset: #physical_memory_offset,
recursive_index: #recursive_index,
kernel_stack_address: #kernel_stack_address,
boot_info_address: #boot_info_address,
framebuffer_address: #framebuffer_address,
}});
}
}
#[derive(Debug, Clone, Copy)]
struct AlignedAddress(u64);
impl quote::ToTokens for AlignedAddress {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
self.0.to_tokens(tokens);
}
}
impl<'de> serde::Deserialize<'de> for AlignedAddress {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_str(AlignedAddressVisitor)
}
}
/// Helper struct for implementing the `optional_version_deserialize` function.
struct | ;
impl serde::de::Visitor<'_> for AlignedAddressVisitor {
type Value = AlignedAddress;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(
formatter,
"a page-aligned memory address, either as integer or as decimal or hexadecimal \
string (e.g. \"0xffff0000\"); large addresses must be given as string because \
TOML does not support unsigned 64-bit integers"
)
}
fn visit_u64<E>(self, num: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if num % 0x1000 == 0 {
Ok(AlignedAddress(num))
} else {
Err(serde::de::Error::custom(format!(
"address {:#x} is not page aligned",
num
)))
}
}
fn visit_i64<E>(self, num: i64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
let unsigned: u64 = num
.try_into()
.map_err(|_| serde::de::Error::custom(format!("address {} is negative", num)))?;
self.visit_u64(unsigned)
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
// ignore any `_` (used for digit grouping)
let value = &value.replace('_', "");
let num = if value.starts_with("0x") {
u64::from_str_radix(&value[2..], 16)
} else {
u64::from_str_radix(&value, 10)
}
.map_err(|_err| {
serde::de::Error::custom(format!(
"string \"{}\" is not a valid memory address",
value
))
})?;
self.visit_u64(num)
}
}
}
| AlignedAddressVisitor | identifier_name |
build.rs | #[cfg(not(feature = "binary"))]
fn main() {}
#[cfg(feature = "binary")]
fn main() {
binary::main();
}
#[cfg(feature = "binary")]
mod binary {
use quote::quote;
use std::convert::TryInto;
pub fn main() {
use llvm_tools_build as llvm_tools;
use std::{
env,
fs::{self, File},
io::Write,
path::{Path, PathBuf},
process::{self, Command},
};
use toml::Value;
let target = env::var("TARGET").expect("TARGET not set");
let (firmware, expected_target) = if cfg!(feature = "uefi_bin") {
("UEFI", "x86_64-unknown-uefi")
} else if cfg!(feature = "bios_bin") {
("BIOS", "x86_64-bootloader")
} else {
panic!(
"Either the `uefi_bin` or `bios_bin` feature must be enabled when \
the `binary` feature is enabled"
);
};
if Path::new(&target)
.file_stem()
.expect("target has no file stem")
!= expected_target
{
panic!(
"The {} bootloader must be compiled for the `{}` target.",
firmware, expected_target,
);
}
let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR not set"));
let kernel = PathBuf::from(match env::var("KERNEL") {
Ok(kernel) => kernel,
Err(_) => {
eprintln!(
"The KERNEL environment variable must be set for building the bootloader.\n\n\
Please use the `cargo builder` command for building."
);
process::exit(1);
}
});
let kernel_file_name = kernel
.file_name()
.expect("KERNEL has no valid file name")
.to_str()
.expect("kernel file name not valid utf8");
// check that the kernel file exists
assert!(
kernel.exists(),
"KERNEL does not exist: {}",
kernel.display()
);
// get access to llvm tools shipped in the llvm-tools-preview rustup component
let llvm_tools = match llvm_tools::LlvmTools::new() {
Ok(tools) => tools,
Err(llvm_tools::Error::NotFound) => {
eprintln!("Error: llvm-tools not found");
eprintln!("Maybe the rustup component `llvm-tools-preview` is missing?");
eprintln!(" Install it through: `rustup component add llvm-tools-preview`");
process::exit(1);
}
Err(err) => {
eprintln!("Failed to retrieve llvm-tools component: {:?}", err);
process::exit(1);
}
};
// check that kernel executable has code in it
let llvm_size = llvm_tools
.tool(&llvm_tools::exe("llvm-size"))
.expect("llvm-size not found in llvm-tools");
let mut cmd = Command::new(llvm_size);
cmd.arg(&kernel);
let output = cmd.output().expect("failed to run llvm-size");
let output_str = String::from_utf8_lossy(&output.stdout);
let second_line_opt = output_str.lines().skip(1).next();
let second_line = second_line_opt.expect(&format!(
"unexpected llvm-size line output:\n{}",
output_str
));
let text_size_opt = second_line.split_ascii_whitespace().next();
let text_size =
text_size_opt.expect(&format!("unexpected llvm-size output:\n{}", output_str));
if text_size == "0" {
panic!("Kernel executable has an empty text section. Perhaps the entry point was set incorrectly?\n\n\
Kernel executable at `{}`\n", kernel.display());
}
// strip debug symbols from kernel for faster loading
let stripped_kernel_file_name = format!("kernel_stripped-{}", kernel_file_name);
let stripped_kernel = out_dir.join(&stripped_kernel_file_name);
let objcopy = llvm_tools
.tool(&llvm_tools::exe("llvm-objcopy"))
.expect("llvm-objcopy not found in llvm-tools");
let mut cmd = Command::new(&objcopy);
cmd.arg("--strip-debug");
cmd.arg(&kernel);
cmd.arg(&stripped_kernel);
let exit_status = cmd
.status()
.expect("failed to run objcopy to strip debug symbols");
if !exit_status.success() {
eprintln!("Error: Stripping debug symbols failed");
process::exit(1);
}
if cfg!(feature = "uefi_bin") {
// write file for including kernel in binary
let file_path = out_dir.join("kernel_info.rs");
let mut file = File::create(file_path).expect("failed to create kernel_info.rs");
let kernel_size = fs::metadata(&stripped_kernel)
.expect("Failed to read file metadata of stripped kernel")
.len();
file.write_all(
format!(
"const KERNEL_SIZE: usize = {}; const KERNEL_BYTES: [u8; KERNEL_SIZE] = *include_bytes!(r\"{}\");",
kernel_size,
stripped_kernel.display(),
)
.as_bytes(),
)
.expect("write to kernel_info.rs failed");
}
if cfg!(feature = "bios_bin") {
// wrap the kernel executable as binary in a new ELF file
let stripped_kernel_file_name_replaced = stripped_kernel_file_name
.replace('-', "_")
.replace('.', "_");
let kernel_bin = out_dir.join(format!("kernel_bin-{}.o", kernel_file_name));
let kernel_archive = out_dir.join(format!("libkernel_bin-{}.a", kernel_file_name));
let mut cmd = Command::new(&objcopy);
cmd.arg("-I").arg("binary");
cmd.arg("-O").arg("elf64-x86-64");
cmd.arg("--binary-architecture=i386:x86-64");
cmd.arg("--rename-section").arg(".data=.kernel");
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_start=_kernel_start_addr",
stripped_kernel_file_name_replaced
));
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_end=_kernel_end_addr",
stripped_kernel_file_name_replaced
));
cmd.arg("--redefine-sym").arg(format!(
"_binary_{}_size=_kernel_size",
stripped_kernel_file_name_replaced
));
cmd.current_dir(&out_dir);
cmd.arg(&stripped_kernel_file_name);
cmd.arg(&kernel_bin);
let exit_status = cmd.status().expect("failed to run objcopy");
if !exit_status.success() {
eprintln!("Error: Running objcopy failed");
process::exit(1);
}
// create an archive for linking
let ar = llvm_tools
.tool(&llvm_tools::exe("llvm-ar"))
.unwrap_or_else(|| {
eprintln!("Failed to retrieve llvm-ar component");
eprint!("This component is available since nightly-2019-03-29,");
eprintln!("so try updating your toolchain if you're using an older nightly");
process::exit(1);
});
let mut cmd = Command::new(ar);
cmd.arg("crs");
cmd.arg(&kernel_archive);
cmd.arg(&kernel_bin);
let exit_status = cmd.status().expect("failed to run ar");
if !exit_status.success() {
eprintln!("Error: Running ar failed");
process::exit(1);
}
// pass link arguments to rustc
println!("cargo:rustc-link-search=native={}", out_dir.display());
println!(
"cargo:rustc-link-lib=static=kernel_bin-{}", | // Parse configuration from the kernel's Cargo.toml
let config = match env::var("KERNEL_MANIFEST") {
Err(env::VarError::NotPresent) => {
panic!("The KERNEL_MANIFEST environment variable must be set for building the bootloader.\n\n\
Please use `cargo builder` for building.");
}
Err(env::VarError::NotUnicode(_)) => {
panic!("The KERNEL_MANIFEST environment variable contains invalid unicode")
}
Ok(path)
if Path::new(&path).file_name().and_then(|s| s.to_str()) != Some("Cargo.toml") =>
{
let err = format!(
"The given `--kernel-manifest` path `{}` does not \
point to a `Cargo.toml`",
path,
);
quote! { compile_error!(#err) }
}
Ok(path) if !Path::new(&path).exists() => {
let err = format!(
"The given `--kernel-manifest` path `{}` does not exist.",
path
);
quote! {
compile_error!(#err)
}
}
Ok(path) => {
println!("cargo:rerun-if-changed={}", path);
let contents = fs::read_to_string(&path).expect(&format!(
"failed to read kernel manifest file (path: {})",
path
));
let manifest = contents
.parse::<Value>()
.expect("failed to parse kernel's Cargo.toml");
if manifest
.get("dependencies")
.and_then(|d| d.get("bootloader"))
.is_some()
{
// it seems to be the correct Cargo.toml
let config_table = manifest
.get("package")
.and_then(|table| table.get("metadata"))
.and_then(|table| table.get("bootloader"))
.cloned()
.unwrap_or_else(|| toml::Value::Table(toml::map::Map::new()));
config_table
.try_into::<ParsedConfig>()
.map(|c| quote! { #c })
.unwrap_or_else(|err| {
let err = format!(
"failed to parse bootloader config in {}:\n\n{}",
path,
err.to_string()
);
quote! {
compile_error!(#err)
}
})
} else {
let err = format!(
"no bootloader dependency in {}\n\n The \
`--kernel-manifest` path should point to the `Cargo.toml` \
of the kernel.",
path
);
quote! {
compile_error!(#err)
}
}
}
};
// Write config to file
let file_path = out_dir.join("bootloader_config.rs");
let mut file = File::create(file_path).expect("failed to create bootloader_config.rs");
file.write_all(
quote::quote! {
mod parsed_config {
use crate::config::Config;
pub const CONFIG: Config = #config;
}
}
.to_string()
.as_bytes(),
)
.expect("write to bootloader_config.rs failed");
println!("cargo:rerun-if-env-changed=KERNEL");
println!("cargo:rerun-if-env-changed=KERNEL_MANIFEST");
println!("cargo:rerun-if-changed={}", kernel.display());
println!("cargo:rerun-if-changed=build.rs");
}
fn val_true() -> bool {
true
}
/// Must be always identical with the struct in `src/config.rs`
///
/// This copy is needed because we can't derive Deserialize in the `src/config.rs`
/// module itself, since cargo currently unifies dependencies (the `toml` crate enables
/// serde's standard feature). Also, it allows to separate the parsing special cases
/// such as `AlignedAddress` more cleanly.
#[derive(Debug, serde::Deserialize)]
#[serde(rename_all = "kebab-case", deny_unknown_fields)]
struct ParsedConfig {
#[serde(default)]
pub map_physical_memory: bool,
#[serde(default)]
pub map_page_table_recursively: bool,
#[serde(default = "val_true")]
pub map_framebuffer: bool,
pub kernel_stack_size: Option<AlignedAddress>,
pub physical_memory_offset: Option<AlignedAddress>,
pub recursive_index: Option<u16>,
pub kernel_stack_address: Option<AlignedAddress>,
pub boot_info_address: Option<AlignedAddress>,
pub framebuffer_address: Option<AlignedAddress>,
}
/// Convert to tokens suitable for initializing the `Config` struct.
impl quote::ToTokens for ParsedConfig {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
fn optional(value: Option<impl quote::ToTokens>) -> proc_macro2::TokenStream {
value.map(|v| quote!(Some(#v))).unwrap_or(quote!(None))
}
let map_physical_memory = self.map_physical_memory;
let map_page_table_recursively = self.map_page_table_recursively;
let map_framebuffer = self.map_framebuffer;
let kernel_stack_size = optional(self.kernel_stack_size);
let physical_memory_offset = optional(self.physical_memory_offset);
let recursive_index = optional(self.recursive_index);
let kernel_stack_address = optional(self.kernel_stack_address);
let boot_info_address = optional(self.boot_info_address);
let framebuffer_address = optional(self.framebuffer_address);
tokens.extend(quote! { Config {
map_physical_memory: #map_physical_memory,
map_page_table_recursively: #map_page_table_recursively,
map_framebuffer: #map_framebuffer,
kernel_stack_size: #kernel_stack_size,
physical_memory_offset: #physical_memory_offset,
recursive_index: #recursive_index,
kernel_stack_address: #kernel_stack_address,
boot_info_address: #boot_info_address,
framebuffer_address: #framebuffer_address,
}});
}
}
#[derive(Debug, Clone, Copy)]
struct AlignedAddress(u64);
impl quote::ToTokens for AlignedAddress {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
self.0.to_tokens(tokens);
}
}
impl<'de> serde::Deserialize<'de> for AlignedAddress {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_str(AlignedAddressVisitor)
}
}
/// Helper struct for implementing the `optional_version_deserialize` function.
struct AlignedAddressVisitor;
impl serde::de::Visitor<'_> for AlignedAddressVisitor {
type Value = AlignedAddress;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(
formatter,
"a page-aligned memory address, either as integer or as decimal or hexadecimal \
string (e.g. \"0xffff0000\"); large addresses must be given as string because \
TOML does not support unsigned 64-bit integers"
)
}
fn visit_u64<E>(self, num: u64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
if num % 0x1000 == 0 {
Ok(AlignedAddress(num))
} else {
Err(serde::de::Error::custom(format!(
"address {:#x} is not page aligned",
num
)))
}
}
fn visit_i64<E>(self, num: i64) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
let unsigned: u64 = num
.try_into()
.map_err(|_| serde::de::Error::custom(format!("address {} is negative", num)))?;
self.visit_u64(unsigned)
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
// ignore any `_` (used for digit grouping)
let value = &value.replace('_', "");
let num = if value.starts_with("0x") {
u64::from_str_radix(&value[2..], 16)
} else {
u64::from_str_radix(&value, 10)
}
.map_err(|_err| {
serde::de::Error::custom(format!(
"string \"{}\" is not a valid memory address",
value
))
})?;
self.visit_u64(num)
}
}
} | kernel_file_name
);
}
| random_line_split |
state.rs | use std::collections::HashMap;
use num_traits::{AsPrimitive, Float};
use sdl2::{
keyboard::Keycode,
pixels::Color,
rect::{Point, Rect},
render::Canvas,
video::Window,
};
use crate::{
ext::ColorExt, key_state_handler::KeyStateHandler, map::Map, math::vector::Vec2D,
WINDOW_HEIGHT, WINDOW_WIDTH,
};
pub fn remap<
T: 'static + Float + Copy,
ON: AsPrimitive<T> + Copy,
OX: AsPrimitive<T> + Copy,
NN: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_min: ON,
old_max: OX,
new_min: NN,
new_max: NX,
) -> T {
new_min.as_()
+ (new_max.as_() - new_min.as_())
* ((value - old_min.as_()) / (old_max.as_() - old_min.as_()))
}
pub fn remap_minz<
T: 'static + Float + Copy + AsPrimitive<T>,
OX: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_max: OX,
new_max: NX,
) -> T {
remap(value, T::zero(), old_max, T::zero(), new_max)
}
const MOUSE_SENSITIVITY: f64 = 0.01;
const MOVE_SPEED: f64 = 2.5;
const PLAYER_WALL_PADDING: f64 = 10.;
const WALL_ACTUAL_HEIGHT: f64 = 48.;
pub struct State {
pub(crate) position: Vec2D,
pub(crate) angle: f64,
pub(crate) fov: f64,
pub(crate) wall_colors: Vec<Color>,
pub(crate) map: Map,
pub(crate) keys: KeyStateHandler,
pub(crate) columns: Vec<(usize, u32)>,
pub(crate) resolution: usize,
pub(crate) projection_factor: f64,
pub(crate) radian_per_column: f64,
pub(crate) column_width: u32,
}
impl State {
pub fn new() -> Self {
let wall_colors = vec![
Color::RGB(128, 255, 0),
Color::RGB(0, 128, 255),
Color::RGB(255, 0, 128),
Color::RGB(0, 255, 0),
Color::RGB(0, 0, 255),
Color::WHITE,
];
// let map = Map::default();
let map = Map::load("./assets/maps/many_walls.json").unwrap();
let (w, h) = map.dims;
// let movement_vector = Line::new(origin, origin + geo::Point::new(delta_x, delta_y));
let position = Vec2D::new(w as f64 / 2., 50. + h as f64 / 2.);
let fov = 60.;
let projection_plane_distance =
((WINDOW_WIDTH / 2) as f64 / (fov.to_radians() / 2.).tan()) as f64;
let resolution = WINDOW_WIDTH as usize;
Self {
position,
angle: std::f64::consts::PI,
fov,
wall_colors,
map,
keys: KeyStateHandler::new(),
columns: Vec::with_capacity(resolution),
resolution,
projection_factor: projection_plane_distance * WALL_ACTUAL_HEIGHT,
radian_per_column: fov.to_radians() / resolution as f64,
column_width: WINDOW_WIDTH / resolution as u32,
}
}
fn get_color(&self, index: usize) -> Color |
pub fn mouse_motion(&mut self, dx: i32) {
self.angle += MOUSE_SENSITIVITY * dx as f64;
}
fn calculate_collisions(&mut self) {
let mut current_angle = self.angle - (self.fov.to_radians() / 2.);
let end_angle = current_angle + (self.radian_per_column * self.resolution as f64);
self.columns.clear();
for _ in 0..self.resolution {
let mut ray = Vec2D::from_angle(current_angle);
ray.translate(&self.position);
let mut max_height = f64::NEG_INFINITY;
let mut wall_color_index = 0;
for wall in self.map.walls.iter() {
if let Some(intersection_vector) = ray.intersects(wall) {
let raw_distance = ray.dist(&intersection_vector);
let delta = current_angle - self.angle;
let corrected_distance = raw_distance * (delta.cos() as f64);
let projected_height = self.projection_factor / corrected_distance;
if projected_height > max_height {
max_height = projected_height;
wall_color_index = wall.color_index;
}
}
}
if max_height.is_infinite() {
self.columns.push((0, 0));
} else {
self.columns
.push((wall_color_index, max_height.round() as u32));
}
current_angle += self.radian_per_column;
}
}
fn update_camera(&mut self) {
let mut delta = Vec2D::Origin;
let par = Vec2D::from_angle(self.angle as f64);
let perp = Vec2D::from_angle(self.angle + (90f64).to_radians());
if self.keys.is_pressed(Keycode::W) {
delta += par;
}
if self.keys.is_pressed(Keycode::S) {
delta += -par;
}
if self.keys.is_pressed(Keycode::A) {
delta += -perp;
}
if self.keys.is_pressed(Keycode::D) {
delta += perp;
}
// Normalize delta so that the player doesn't move faster moving in a diagonal direction
if !delta.is_origin() {
delta = delta.normalize() * MOVE_SPEED;
}
self.position.add_x_y_raw(delta.x_y());
self.position.clamp(self.map.dims, PLAYER_WALL_PADDING);
}
pub fn update(&mut self) {
self.update_camera();
self.calculate_collisions();
}
pub fn draw_minimap(
&self,
canvas: &mut Canvas<Window>,
dims: (f64, f64),
) -> Result<(), String> {
let minimap_offset = (dims.0.max(dims.1) / 4.);
let minimap_base = Vec2D::new(minimap_offset, minimap_offset);
// Background
canvas.set_draw_color(Color::BLACK);
canvas.fill_rect(Rect::new(
minimap_offset as i32,
minimap_offset as i32,
dims.0 as u32,
dims.1 as u32,
))?;
canvas.set_draw_color(Color::WHITE);
// Player position
let position_mapped = self.position.remap(self.map.dims, dims) + minimap_base;
canvas.fill_rect(Rect::from_center(position_mapped, 8, 8))?;
// Player lines
let ray_scale = dims.0.max(dims.1) / 2.;
let half_fov = self.fov.to_radians() / 2.;
let forward_end = position_mapped + (Vec2D::from_angle(self.angle) * ray_scale);
let left_end = position_mapped + (Vec2D::from_angle(self.angle - half_fov) * ray_scale);
let right_end = position_mapped + (Vec2D::from_angle(self.angle + half_fov) * ray_scale);
canvas.draw_lines(&[
position_mapped.into(),
forward_end.into(),
position_mapped.into(),
left_end.into(),
position_mapped.into(),
right_end.into(),
] as &[Point])?;
// TODO: FOV lines
// Walls
for wall in self.map.walls.iter() {
canvas.set_draw_color(self.get_color(wall.color_index));
let start = wall.a.remap(self.map.dims, dims) + minimap_base;
let end = wall.b.remap(self.map.dims, dims) + minimap_base;
canvas.draw_line(start, end)?;
}
// let mut current_angle = self.angle + (self.fov.to_radians() / 2.);
// for _ in 0..self.resolution {
// let mut ray = self.position;
// ray.set_angle(current_angle);
// ray += self.position;
// let mut max_height = f64::NEG_INFINITY;
// let mut collisions: Vec<(bool, Vec2D)> = vec![];
// let mut collision = Vec2D::Origin;
// for wall in self.map.walls.iter() {
// if let Some(intersection_vector) = ray.intersects(wall) {
// let raw_distance = ray.dist(&intersection_vector);
// let delta = current_angle - self.angle;
// let corrected_distance = raw_distance * (delta.cos() as f64);
// let projected_height = self.projection_factor / corrected_distance;
// if projected_height > max_height {
// max_height = projected_height;
// collisions = collisions.into_iter().fold(vec![], |mut acc, cur| {
// acc.push((false, cur.1));
// acc
// });
// collisions.push((true, collision));
// collision = intersection_vector;
// } else {
// collisions.push((false, intersection_vector));
// }
// }
// }
// if !max_height.is_infinite() {
// canvas.set_draw_color(Color::RED);
// canvas.draw_rects(
// collisions
// .into_iter()
// .map(|(_, v)| {
// Rect::from_center(
// Point::new(
// remap(v.x(), 0., self.map.dims.0, 0., dims.0).floor() as i32,
// remap(v.y(), 0., self.map.dims.1, 0., dims.1).floor() as i32,
// ) + minimap_base,
// 2,
// 2,
// )
// })
// .collect::<Vec<Rect>>()
// .as_slice(),
// );
// }
// current_angle -= self.radian_per_column;
// }
Ok(())
}
fn render_frame(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
let column_width_signed = self.column_width as i32;
// TODO: Draw background
let mut current_index = usize::MAX;
let mut current_color = Color::BLACK;
for (idx, (color_index, height)) in self.columns.iter().copied().enumerate() {
if color_index != current_index {
current_color = self.get_color(color_index);
current_index = color_index;
}
let dim_amt = remap(height as f64, 0, WINDOW_HEIGHT, 255, 0).floor() as u8;
canvas.set_draw_color(current_color.dim(dim_amt));
canvas.fill_rect(Rect::from_center(
Point::new(
idx as i32 * column_width_signed + (column_width_signed / 2),
WINDOW_HEIGHT as i32 / 2,
),
self.column_width,
height,
))?;
}
Ok(())
}
pub fn draw(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
self.render_frame(canvas)?;
self.draw_minimap(canvas, (WINDOW_WIDTH as f64 / 5., WINDOW_WIDTH as f64 / 5.))?;
Ok(())
}
}
| {
self.wall_colors.get(index).copied().unwrap_or(Color::WHITE)
} | identifier_body |
state.rs | use std::collections::HashMap;
use num_traits::{AsPrimitive, Float};
use sdl2::{
keyboard::Keycode,
pixels::Color,
rect::{Point, Rect},
render::Canvas,
video::Window,
};
use crate::{
ext::ColorExt, key_state_handler::KeyStateHandler, map::Map, math::vector::Vec2D,
WINDOW_HEIGHT, WINDOW_WIDTH,
};
pub fn remap<
T: 'static + Float + Copy,
ON: AsPrimitive<T> + Copy,
OX: AsPrimitive<T> + Copy,
NN: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_min: ON,
old_max: OX,
new_min: NN,
new_max: NX,
) -> T {
new_min.as_()
+ (new_max.as_() - new_min.as_())
* ((value - old_min.as_()) / (old_max.as_() - old_min.as_()))
}
pub fn remap_minz<
T: 'static + Float + Copy + AsPrimitive<T>,
OX: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_max: OX,
new_max: NX,
) -> T {
remap(value, T::zero(), old_max, T::zero(), new_max)
}
const MOUSE_SENSITIVITY: f64 = 0.01;
const MOVE_SPEED: f64 = 2.5;
const PLAYER_WALL_PADDING: f64 = 10.;
const WALL_ACTUAL_HEIGHT: f64 = 48.;
pub struct State {
pub(crate) position: Vec2D,
pub(crate) angle: f64,
pub(crate) fov: f64,
pub(crate) wall_colors: Vec<Color>,
pub(crate) map: Map,
pub(crate) keys: KeyStateHandler,
pub(crate) columns: Vec<(usize, u32)>,
pub(crate) resolution: usize,
pub(crate) projection_factor: f64,
pub(crate) radian_per_column: f64,
pub(crate) column_width: u32,
}
impl State {
pub fn new() -> Self {
let wall_colors = vec![
Color::RGB(128, 255, 0),
Color::RGB(0, 128, 255),
Color::RGB(255, 0, 128),
Color::RGB(0, 255, 0),
Color::RGB(0, 0, 255),
Color::WHITE,
];
// let map = Map::default();
let map = Map::load("./assets/maps/many_walls.json").unwrap();
let (w, h) = map.dims;
// let movement_vector = Line::new(origin, origin + geo::Point::new(delta_x, delta_y));
let position = Vec2D::new(w as f64 / 2., 50. + h as f64 / 2.);
let fov = 60.;
let projection_plane_distance =
((WINDOW_WIDTH / 2) as f64 / (fov.to_radians() / 2.).tan()) as f64;
let resolution = WINDOW_WIDTH as usize;
Self {
position,
angle: std::f64::consts::PI,
fov,
wall_colors,
map,
keys: KeyStateHandler::new(),
columns: Vec::with_capacity(resolution),
resolution,
projection_factor: projection_plane_distance * WALL_ACTUAL_HEIGHT,
radian_per_column: fov.to_radians() / resolution as f64,
column_width: WINDOW_WIDTH / resolution as u32,
}
}
fn get_color(&self, index: usize) -> Color {
self.wall_colors.get(index).copied().unwrap_or(Color::WHITE)
}
pub fn mouse_motion(&mut self, dx: i32) {
self.angle += MOUSE_SENSITIVITY * dx as f64;
}
fn calculate_collisions(&mut self) {
let mut current_angle = self.angle - (self.fov.to_radians() / 2.);
let end_angle = current_angle + (self.radian_per_column * self.resolution as f64);
self.columns.clear();
for _ in 0..self.resolution {
let mut ray = Vec2D::from_angle(current_angle);
ray.translate(&self.position);
let mut max_height = f64::NEG_INFINITY;
let mut wall_color_index = 0;
for wall in self.map.walls.iter() {
if let Some(intersection_vector) = ray.intersects(wall) {
let raw_distance = ray.dist(&intersection_vector);
let delta = current_angle - self.angle;
let corrected_distance = raw_distance * (delta.cos() as f64);
let projected_height = self.projection_factor / corrected_distance;
if projected_height > max_height {
max_height = projected_height;
wall_color_index = wall.color_index;
}
}
}
if max_height.is_infinite() {
self.columns.push((0, 0));
} else {
self.columns
.push((wall_color_index, max_height.round() as u32));
}
current_angle += self.radian_per_column;
}
}
fn update_camera(&mut self) {
let mut delta = Vec2D::Origin;
let par = Vec2D::from_angle(self.angle as f64);
let perp = Vec2D::from_angle(self.angle + (90f64).to_radians());
if self.keys.is_pressed(Keycode::W) {
delta += par;
}
if self.keys.is_pressed(Keycode::S) {
delta += -par;
}
if self.keys.is_pressed(Keycode::A) {
delta += -perp;
}
if self.keys.is_pressed(Keycode::D) {
delta += perp;
}
// Normalize delta so that the player doesn't move faster moving in a diagonal direction
if !delta.is_origin() {
delta = delta.normalize() * MOVE_SPEED;
} | pub fn update(&mut self) {
self.update_camera();
self.calculate_collisions();
}
pub fn draw_minimap(
&self,
canvas: &mut Canvas<Window>,
dims: (f64, f64),
) -> Result<(), String> {
let minimap_offset = (dims.0.max(dims.1) / 4.);
let minimap_base = Vec2D::new(minimap_offset, minimap_offset);
// Background
canvas.set_draw_color(Color::BLACK);
canvas.fill_rect(Rect::new(
minimap_offset as i32,
minimap_offset as i32,
dims.0 as u32,
dims.1 as u32,
))?;
canvas.set_draw_color(Color::WHITE);
// Player position
let position_mapped = self.position.remap(self.map.dims, dims) + minimap_base;
canvas.fill_rect(Rect::from_center(position_mapped, 8, 8))?;
// Player lines
let ray_scale = dims.0.max(dims.1) / 2.;
let half_fov = self.fov.to_radians() / 2.;
let forward_end = position_mapped + (Vec2D::from_angle(self.angle) * ray_scale);
let left_end = position_mapped + (Vec2D::from_angle(self.angle - half_fov) * ray_scale);
let right_end = position_mapped + (Vec2D::from_angle(self.angle + half_fov) * ray_scale);
canvas.draw_lines(&[
position_mapped.into(),
forward_end.into(),
position_mapped.into(),
left_end.into(),
position_mapped.into(),
right_end.into(),
] as &[Point])?;
// TODO: FOV lines
// Walls
for wall in self.map.walls.iter() {
canvas.set_draw_color(self.get_color(wall.color_index));
let start = wall.a.remap(self.map.dims, dims) + minimap_base;
let end = wall.b.remap(self.map.dims, dims) + minimap_base;
canvas.draw_line(start, end)?;
}
// let mut current_angle = self.angle + (self.fov.to_radians() / 2.);
// for _ in 0..self.resolution {
// let mut ray = self.position;
// ray.set_angle(current_angle);
// ray += self.position;
// let mut max_height = f64::NEG_INFINITY;
// let mut collisions: Vec<(bool, Vec2D)> = vec![];
// let mut collision = Vec2D::Origin;
// for wall in self.map.walls.iter() {
// if let Some(intersection_vector) = ray.intersects(wall) {
// let raw_distance = ray.dist(&intersection_vector);
// let delta = current_angle - self.angle;
// let corrected_distance = raw_distance * (delta.cos() as f64);
// let projected_height = self.projection_factor / corrected_distance;
// if projected_height > max_height {
// max_height = projected_height;
// collisions = collisions.into_iter().fold(vec![], |mut acc, cur| {
// acc.push((false, cur.1));
// acc
// });
// collisions.push((true, collision));
// collision = intersection_vector;
// } else {
// collisions.push((false, intersection_vector));
// }
// }
// }
// if !max_height.is_infinite() {
// canvas.set_draw_color(Color::RED);
// canvas.draw_rects(
// collisions
// .into_iter()
// .map(|(_, v)| {
// Rect::from_center(
// Point::new(
// remap(v.x(), 0., self.map.dims.0, 0., dims.0).floor() as i32,
// remap(v.y(), 0., self.map.dims.1, 0., dims.1).floor() as i32,
// ) + minimap_base,
// 2,
// 2,
// )
// })
// .collect::<Vec<Rect>>()
// .as_slice(),
// );
// }
// current_angle -= self.radian_per_column;
// }
Ok(())
}
fn render_frame(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
let column_width_signed = self.column_width as i32;
// TODO: Draw background
let mut current_index = usize::MAX;
let mut current_color = Color::BLACK;
for (idx, (color_index, height)) in self.columns.iter().copied().enumerate() {
if color_index != current_index {
current_color = self.get_color(color_index);
current_index = color_index;
}
let dim_amt = remap(height as f64, 0, WINDOW_HEIGHT, 255, 0).floor() as u8;
canvas.set_draw_color(current_color.dim(dim_amt));
canvas.fill_rect(Rect::from_center(
Point::new(
idx as i32 * column_width_signed + (column_width_signed / 2),
WINDOW_HEIGHT as i32 / 2,
),
self.column_width,
height,
))?;
}
Ok(())
}
pub fn draw(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
self.render_frame(canvas)?;
self.draw_minimap(canvas, (WINDOW_WIDTH as f64 / 5., WINDOW_WIDTH as f64 / 5.))?;
Ok(())
}
} |
self.position.add_x_y_raw(delta.x_y());
self.position.clamp(self.map.dims, PLAYER_WALL_PADDING);
}
| random_line_split |
state.rs | use std::collections::HashMap;
use num_traits::{AsPrimitive, Float};
use sdl2::{
keyboard::Keycode,
pixels::Color,
rect::{Point, Rect},
render::Canvas,
video::Window,
};
use crate::{
ext::ColorExt, key_state_handler::KeyStateHandler, map::Map, math::vector::Vec2D,
WINDOW_HEIGHT, WINDOW_WIDTH,
};
pub fn remap<
T: 'static + Float + Copy,
ON: AsPrimitive<T> + Copy,
OX: AsPrimitive<T> + Copy,
NN: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_min: ON,
old_max: OX,
new_min: NN,
new_max: NX,
) -> T {
new_min.as_()
+ (new_max.as_() - new_min.as_())
* ((value - old_min.as_()) / (old_max.as_() - old_min.as_()))
}
pub fn remap_minz<
T: 'static + Float + Copy + AsPrimitive<T>,
OX: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_max: OX,
new_max: NX,
) -> T {
remap(value, T::zero(), old_max, T::zero(), new_max)
}
const MOUSE_SENSITIVITY: f64 = 0.01;
const MOVE_SPEED: f64 = 2.5;
const PLAYER_WALL_PADDING: f64 = 10.;
const WALL_ACTUAL_HEIGHT: f64 = 48.;
pub struct State {
pub(crate) position: Vec2D,
pub(crate) angle: f64,
pub(crate) fov: f64,
pub(crate) wall_colors: Vec<Color>,
pub(crate) map: Map,
pub(crate) keys: KeyStateHandler,
pub(crate) columns: Vec<(usize, u32)>,
pub(crate) resolution: usize,
pub(crate) projection_factor: f64,
pub(crate) radian_per_column: f64,
pub(crate) column_width: u32,
}
impl State {
pub fn new() -> Self {
let wall_colors = vec![
Color::RGB(128, 255, 0),
Color::RGB(0, 128, 255),
Color::RGB(255, 0, 128),
Color::RGB(0, 255, 0),
Color::RGB(0, 0, 255),
Color::WHITE,
];
// let map = Map::default();
let map = Map::load("./assets/maps/many_walls.json").unwrap();
let (w, h) = map.dims;
// let movement_vector = Line::new(origin, origin + geo::Point::new(delta_x, delta_y));
let position = Vec2D::new(w as f64 / 2., 50. + h as f64 / 2.);
let fov = 60.;
let projection_plane_distance =
((WINDOW_WIDTH / 2) as f64 / (fov.to_radians() / 2.).tan()) as f64;
let resolution = WINDOW_WIDTH as usize;
Self {
position,
angle: std::f64::consts::PI,
fov,
wall_colors,
map,
keys: KeyStateHandler::new(),
columns: Vec::with_capacity(resolution),
resolution,
projection_factor: projection_plane_distance * WALL_ACTUAL_HEIGHT,
radian_per_column: fov.to_radians() / resolution as f64,
column_width: WINDOW_WIDTH / resolution as u32,
}
}
fn get_color(&self, index: usize) -> Color {
self.wall_colors.get(index).copied().unwrap_or(Color::WHITE)
}
pub fn mouse_motion(&mut self, dx: i32) {
self.angle += MOUSE_SENSITIVITY * dx as f64;
}
fn calculate_collisions(&mut self) {
let mut current_angle = self.angle - (self.fov.to_radians() / 2.);
let end_angle = current_angle + (self.radian_per_column * self.resolution as f64);
self.columns.clear();
for _ in 0..self.resolution {
let mut ray = Vec2D::from_angle(current_angle);
ray.translate(&self.position);
let mut max_height = f64::NEG_INFINITY;
let mut wall_color_index = 0;
for wall in self.map.walls.iter() {
if let Some(intersection_vector) = ray.intersects(wall) |
}
if max_height.is_infinite() {
self.columns.push((0, 0));
} else {
self.columns
.push((wall_color_index, max_height.round() as u32));
}
current_angle += self.radian_per_column;
}
}
fn update_camera(&mut self) {
let mut delta = Vec2D::Origin;
let par = Vec2D::from_angle(self.angle as f64);
let perp = Vec2D::from_angle(self.angle + (90f64).to_radians());
if self.keys.is_pressed(Keycode::W) {
delta += par;
}
if self.keys.is_pressed(Keycode::S) {
delta += -par;
}
if self.keys.is_pressed(Keycode::A) {
delta += -perp;
}
if self.keys.is_pressed(Keycode::D) {
delta += perp;
}
// Normalize delta so that the player doesn't move faster moving in a diagonal direction
if !delta.is_origin() {
delta = delta.normalize() * MOVE_SPEED;
}
self.position.add_x_y_raw(delta.x_y());
self.position.clamp(self.map.dims, PLAYER_WALL_PADDING);
}
pub fn update(&mut self) {
self.update_camera();
self.calculate_collisions();
}
pub fn draw_minimap(
&self,
canvas: &mut Canvas<Window>,
dims: (f64, f64),
) -> Result<(), String> {
let minimap_offset = (dims.0.max(dims.1) / 4.);
let minimap_base = Vec2D::new(minimap_offset, minimap_offset);
// Background
canvas.set_draw_color(Color::BLACK);
canvas.fill_rect(Rect::new(
minimap_offset as i32,
minimap_offset as i32,
dims.0 as u32,
dims.1 as u32,
))?;
canvas.set_draw_color(Color::WHITE);
// Player position
let position_mapped = self.position.remap(self.map.dims, dims) + minimap_base;
canvas.fill_rect(Rect::from_center(position_mapped, 8, 8))?;
// Player lines
let ray_scale = dims.0.max(dims.1) / 2.;
let half_fov = self.fov.to_radians() / 2.;
let forward_end = position_mapped + (Vec2D::from_angle(self.angle) * ray_scale);
let left_end = position_mapped + (Vec2D::from_angle(self.angle - half_fov) * ray_scale);
let right_end = position_mapped + (Vec2D::from_angle(self.angle + half_fov) * ray_scale);
canvas.draw_lines(&[
position_mapped.into(),
forward_end.into(),
position_mapped.into(),
left_end.into(),
position_mapped.into(),
right_end.into(),
] as &[Point])?;
// TODO: FOV lines
// Walls
for wall in self.map.walls.iter() {
canvas.set_draw_color(self.get_color(wall.color_index));
let start = wall.a.remap(self.map.dims, dims) + minimap_base;
let end = wall.b.remap(self.map.dims, dims) + minimap_base;
canvas.draw_line(start, end)?;
}
// let mut current_angle = self.angle + (self.fov.to_radians() / 2.);
// for _ in 0..self.resolution {
// let mut ray = self.position;
// ray.set_angle(current_angle);
// ray += self.position;
// let mut max_height = f64::NEG_INFINITY;
// let mut collisions: Vec<(bool, Vec2D)> = vec![];
// let mut collision = Vec2D::Origin;
// for wall in self.map.walls.iter() {
// if let Some(intersection_vector) = ray.intersects(wall) {
// let raw_distance = ray.dist(&intersection_vector);
// let delta = current_angle - self.angle;
// let corrected_distance = raw_distance * (delta.cos() as f64);
// let projected_height = self.projection_factor / corrected_distance;
// if projected_height > max_height {
// max_height = projected_height;
// collisions = collisions.into_iter().fold(vec![], |mut acc, cur| {
// acc.push((false, cur.1));
// acc
// });
// collisions.push((true, collision));
// collision = intersection_vector;
// } else {
// collisions.push((false, intersection_vector));
// }
// }
// }
// if !max_height.is_infinite() {
// canvas.set_draw_color(Color::RED);
// canvas.draw_rects(
// collisions
// .into_iter()
// .map(|(_, v)| {
// Rect::from_center(
// Point::new(
// remap(v.x(), 0., self.map.dims.0, 0., dims.0).floor() as i32,
// remap(v.y(), 0., self.map.dims.1, 0., dims.1).floor() as i32,
// ) + minimap_base,
// 2,
// 2,
// )
// })
// .collect::<Vec<Rect>>()
// .as_slice(),
// );
// }
// current_angle -= self.radian_per_column;
// }
Ok(())
}
fn render_frame(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
let column_width_signed = self.column_width as i32;
// TODO: Draw background
let mut current_index = usize::MAX;
let mut current_color = Color::BLACK;
for (idx, (color_index, height)) in self.columns.iter().copied().enumerate() {
if color_index != current_index {
current_color = self.get_color(color_index);
current_index = color_index;
}
let dim_amt = remap(height as f64, 0, WINDOW_HEIGHT, 255, 0).floor() as u8;
canvas.set_draw_color(current_color.dim(dim_amt));
canvas.fill_rect(Rect::from_center(
Point::new(
idx as i32 * column_width_signed + (column_width_signed / 2),
WINDOW_HEIGHT as i32 / 2,
),
self.column_width,
height,
))?;
}
Ok(())
}
pub fn draw(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
self.render_frame(canvas)?;
self.draw_minimap(canvas, (WINDOW_WIDTH as f64 / 5., WINDOW_WIDTH as f64 / 5.))?;
Ok(())
}
}
| {
let raw_distance = ray.dist(&intersection_vector);
let delta = current_angle - self.angle;
let corrected_distance = raw_distance * (delta.cos() as f64);
let projected_height = self.projection_factor / corrected_distance;
if projected_height > max_height {
max_height = projected_height;
wall_color_index = wall.color_index;
}
} | conditional_block |
state.rs | use std::collections::HashMap;
use num_traits::{AsPrimitive, Float};
use sdl2::{
keyboard::Keycode,
pixels::Color,
rect::{Point, Rect},
render::Canvas,
video::Window,
};
use crate::{
ext::ColorExt, key_state_handler::KeyStateHandler, map::Map, math::vector::Vec2D,
WINDOW_HEIGHT, WINDOW_WIDTH,
};
pub fn remap<
T: 'static + Float + Copy,
ON: AsPrimitive<T> + Copy,
OX: AsPrimitive<T> + Copy,
NN: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_min: ON,
old_max: OX,
new_min: NN,
new_max: NX,
) -> T {
new_min.as_()
+ (new_max.as_() - new_min.as_())
* ((value - old_min.as_()) / (old_max.as_() - old_min.as_()))
}
pub fn remap_minz<
T: 'static + Float + Copy + AsPrimitive<T>,
OX: AsPrimitive<T> + Copy,
NX: AsPrimitive<T> + Copy,
>(
value: T,
old_max: OX,
new_max: NX,
) -> T {
remap(value, T::zero(), old_max, T::zero(), new_max)
}
const MOUSE_SENSITIVITY: f64 = 0.01;
const MOVE_SPEED: f64 = 2.5;
const PLAYER_WALL_PADDING: f64 = 10.;
const WALL_ACTUAL_HEIGHT: f64 = 48.;
pub struct State {
pub(crate) position: Vec2D,
pub(crate) angle: f64,
pub(crate) fov: f64,
pub(crate) wall_colors: Vec<Color>,
pub(crate) map: Map,
pub(crate) keys: KeyStateHandler,
pub(crate) columns: Vec<(usize, u32)>,
pub(crate) resolution: usize,
pub(crate) projection_factor: f64,
pub(crate) radian_per_column: f64,
pub(crate) column_width: u32,
}
impl State {
pub fn new() -> Self {
let wall_colors = vec![
Color::RGB(128, 255, 0),
Color::RGB(0, 128, 255),
Color::RGB(255, 0, 128),
Color::RGB(0, 255, 0),
Color::RGB(0, 0, 255),
Color::WHITE,
];
// let map = Map::default();
let map = Map::load("./assets/maps/many_walls.json").unwrap();
let (w, h) = map.dims;
// let movement_vector = Line::new(origin, origin + geo::Point::new(delta_x, delta_y));
let position = Vec2D::new(w as f64 / 2., 50. + h as f64 / 2.);
let fov = 60.;
let projection_plane_distance =
((WINDOW_WIDTH / 2) as f64 / (fov.to_radians() / 2.).tan()) as f64;
let resolution = WINDOW_WIDTH as usize;
Self {
position,
angle: std::f64::consts::PI,
fov,
wall_colors,
map,
keys: KeyStateHandler::new(),
columns: Vec::with_capacity(resolution),
resolution,
projection_factor: projection_plane_distance * WALL_ACTUAL_HEIGHT,
radian_per_column: fov.to_radians() / resolution as f64,
column_width: WINDOW_WIDTH / resolution as u32,
}
}
fn get_color(&self, index: usize) -> Color {
self.wall_colors.get(index).copied().unwrap_or(Color::WHITE)
}
pub fn mouse_motion(&mut self, dx: i32) {
self.angle += MOUSE_SENSITIVITY * dx as f64;
}
fn calculate_collisions(&mut self) {
let mut current_angle = self.angle - (self.fov.to_radians() / 2.);
let end_angle = current_angle + (self.radian_per_column * self.resolution as f64);
self.columns.clear();
for _ in 0..self.resolution {
let mut ray = Vec2D::from_angle(current_angle);
ray.translate(&self.position);
let mut max_height = f64::NEG_INFINITY;
let mut wall_color_index = 0;
for wall in self.map.walls.iter() {
if let Some(intersection_vector) = ray.intersects(wall) {
let raw_distance = ray.dist(&intersection_vector);
let delta = current_angle - self.angle;
let corrected_distance = raw_distance * (delta.cos() as f64);
let projected_height = self.projection_factor / corrected_distance;
if projected_height > max_height {
max_height = projected_height;
wall_color_index = wall.color_index;
}
}
}
if max_height.is_infinite() {
self.columns.push((0, 0));
} else {
self.columns
.push((wall_color_index, max_height.round() as u32));
}
current_angle += self.radian_per_column;
}
}
fn update_camera(&mut self) {
let mut delta = Vec2D::Origin;
let par = Vec2D::from_angle(self.angle as f64);
let perp = Vec2D::from_angle(self.angle + (90f64).to_radians());
if self.keys.is_pressed(Keycode::W) {
delta += par;
}
if self.keys.is_pressed(Keycode::S) {
delta += -par;
}
if self.keys.is_pressed(Keycode::A) {
delta += -perp;
}
if self.keys.is_pressed(Keycode::D) {
delta += perp;
}
// Normalize delta so that the player doesn't move faster moving in a diagonal direction
if !delta.is_origin() {
delta = delta.normalize() * MOVE_SPEED;
}
self.position.add_x_y_raw(delta.x_y());
self.position.clamp(self.map.dims, PLAYER_WALL_PADDING);
}
pub fn update(&mut self) {
self.update_camera();
self.calculate_collisions();
}
pub fn draw_minimap(
&self,
canvas: &mut Canvas<Window>,
dims: (f64, f64),
) -> Result<(), String> {
let minimap_offset = (dims.0.max(dims.1) / 4.);
let minimap_base = Vec2D::new(minimap_offset, minimap_offset);
// Background
canvas.set_draw_color(Color::BLACK);
canvas.fill_rect(Rect::new(
minimap_offset as i32,
minimap_offset as i32,
dims.0 as u32,
dims.1 as u32,
))?;
canvas.set_draw_color(Color::WHITE);
// Player position
let position_mapped = self.position.remap(self.map.dims, dims) + minimap_base;
canvas.fill_rect(Rect::from_center(position_mapped, 8, 8))?;
// Player lines
let ray_scale = dims.0.max(dims.1) / 2.;
let half_fov = self.fov.to_radians() / 2.;
let forward_end = position_mapped + (Vec2D::from_angle(self.angle) * ray_scale);
let left_end = position_mapped + (Vec2D::from_angle(self.angle - half_fov) * ray_scale);
let right_end = position_mapped + (Vec2D::from_angle(self.angle + half_fov) * ray_scale);
canvas.draw_lines(&[
position_mapped.into(),
forward_end.into(),
position_mapped.into(),
left_end.into(),
position_mapped.into(),
right_end.into(),
] as &[Point])?;
// TODO: FOV lines
// Walls
for wall in self.map.walls.iter() {
canvas.set_draw_color(self.get_color(wall.color_index));
let start = wall.a.remap(self.map.dims, dims) + minimap_base;
let end = wall.b.remap(self.map.dims, dims) + minimap_base;
canvas.draw_line(start, end)?;
}
// let mut current_angle = self.angle + (self.fov.to_radians() / 2.);
// for _ in 0..self.resolution {
// let mut ray = self.position;
// ray.set_angle(current_angle);
// ray += self.position;
// let mut max_height = f64::NEG_INFINITY;
// let mut collisions: Vec<(bool, Vec2D)> = vec![];
// let mut collision = Vec2D::Origin;
// for wall in self.map.walls.iter() {
// if let Some(intersection_vector) = ray.intersects(wall) {
// let raw_distance = ray.dist(&intersection_vector);
// let delta = current_angle - self.angle;
// let corrected_distance = raw_distance * (delta.cos() as f64);
// let projected_height = self.projection_factor / corrected_distance;
// if projected_height > max_height {
// max_height = projected_height;
// collisions = collisions.into_iter().fold(vec![], |mut acc, cur| {
// acc.push((false, cur.1));
// acc
// });
// collisions.push((true, collision));
// collision = intersection_vector;
// } else {
// collisions.push((false, intersection_vector));
// }
// }
// }
// if !max_height.is_infinite() {
// canvas.set_draw_color(Color::RED);
// canvas.draw_rects(
// collisions
// .into_iter()
// .map(|(_, v)| {
// Rect::from_center(
// Point::new(
// remap(v.x(), 0., self.map.dims.0, 0., dims.0).floor() as i32,
// remap(v.y(), 0., self.map.dims.1, 0., dims.1).floor() as i32,
// ) + minimap_base,
// 2,
// 2,
// )
// })
// .collect::<Vec<Rect>>()
// .as_slice(),
// );
// }
// current_angle -= self.radian_per_column;
// }
Ok(())
}
fn render_frame(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
let column_width_signed = self.column_width as i32;
// TODO: Draw background
let mut current_index = usize::MAX;
let mut current_color = Color::BLACK;
for (idx, (color_index, height)) in self.columns.iter().copied().enumerate() {
if color_index != current_index {
current_color = self.get_color(color_index);
current_index = color_index;
}
let dim_amt = remap(height as f64, 0, WINDOW_HEIGHT, 255, 0).floor() as u8;
canvas.set_draw_color(current_color.dim(dim_amt));
canvas.fill_rect(Rect::from_center(
Point::new(
idx as i32 * column_width_signed + (column_width_signed / 2),
WINDOW_HEIGHT as i32 / 2,
),
self.column_width,
height,
))?;
}
Ok(())
}
pub fn | (&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
self.render_frame(canvas)?;
self.draw_minimap(canvas, (WINDOW_WIDTH as f64 / 5., WINDOW_WIDTH as f64 / 5.))?;
Ok(())
}
}
| draw | identifier_name |
opdb.rs | /*
@author: xiao cai niao
@datetime: 2019/11/6
*/
use actix_web::{web};
use crate::webroute::route::{HostInfo, PostUserInfo, EditInfo, EditMainTain};
use crate::storage::rocks::{DbInfo, KeyValue, CfNameTypeCode, PrefixTypeCode};
use crate::ha::procotol::{DownNodeCheck, RecoveryInfo, ReplicationState, MysqlMonitorStatus};
use std::error::Error;
use crate::ha::nodes_manager::{SlaveInfo};
use serde::{Serialize, Deserialize};
use crate::rand_string;
use crate::ha::procotol::MysqlState;
use crate::ha::sys_manager::MonitorSetting;
use crate::webroute::new_route::ResponseMonitorStatic;
use std::str::from_utf8;
///
/// mysql node info， insert to rocksdb
///
///
pub fn insert_mysql_host_info(data: web::Data<DbInfo>, info: &web::Json<HostInfo>) -> Result<(), Box<dyn Error>> {
let check_unique = data.get(&info.host, &CfNameTypeCode::HaNodesInfo.get());
match check_unique {
Ok(v) => {
if v.value.len() > 0 {
let a = format!("this key: ({}) already exists in the database",&info.host);
return Err(a.into());
}
}
_ => {}
}
let v = HostInfoValue::new(info)?;
v.save(&data)?;
//初始化节点监控配置
let monitor_info = MonitorSetting::new(&info.host);
monitor_info.save(&data)?;
Ok(())
}
#[derive(Serialize, Deserialize, Debug)]
pub struct HaChangeLog {
pub key: String, //格式 host_timestamp host为宕机节点
pub cluster_name: String,
pub old_master_info: DownNodeCheck, //宕机节点信息
pub new_master_binlog_info: SlaveInfo, //如果宕机节点在切换之前未进行binlog追加将保存新master读取到的binlog信息，在宕机节点恢复时会进行判断回滚
pub recovery_info: RecoveryInfo, //宕机恢复同步所需的新master信息
pub recovery_status: bool, //是否已恢复
pub switch_status: bool, //切换状态
}
impl HaChangeLog {
pub fn new() -> HaChangeLog {
HaChangeLog{
key: "".to_string(),
cluster_name: "".to_string(),
old_master_info: DownNodeCheck { host: "".to_string(), dbport: 0 },
new_master_binlog_info: SlaveInfo {
host: "".to_string(),
dbport: 0,
slave_info: ReplicationState {
log_name: "".to_string(),
read_log_pos: 0,
exec_log_pos: 0
},
new_master: false
},
recovery_info: RecoveryInfo {
binlog: "".to_string(),
position: 0,
gtid: "".to_string(),
masterhost: "".to_string(),
masterport: 0,
read_binlog: "".to_string(),
read_position: 0
},
recovery_status: false,
switch_status: false
}
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let key = format!("{}_{}",self.key.clone(), crate::timestamp());
let value = serde_json::to_string(self)?;
let row = KeyValue{key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
pub fn update(&mut self, db: &web::Data<DbInfo>, row_key: String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(self)?;
let row = KeyValue{key: row_key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
}
///
///
///
/// 用户信息结构
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct UserInfo {
pub user_name: String,
pub password: String,
pub hook_id: String,
pub create_time: i64,
pub update_time: i64
}
impl UserInfo {
pub fn new(info: &PostUserInfo) -> UserInfo {
let create_time = crate::timestamp();
let update_time = crate::timestamp();
UserInfo{
user_name: info.user_name.clone(),
password: info.password.clone(),
hook_id: rand_string(),
create_time,
update_time
}
}
}
///
///
///
/// 节点基础信息, host做为key
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct HostInfoValue {
pub host: String, //127.0.0.1:3306
pub dbport: usize, //default 3306
pub rtype: String, //db、route
pub cluster_name: String, //集群名称,route类型默认default
pub online: bool, //db是否在线， true、false
pub insert_time: i64,
pub update_time: i64,
pub maintain: bool, //是否处于维护模式，true、false
}
impl HostInfoValue {
pub fn new(info: &HostInfo) -> Result<HostInfoValue, Box<dyn Error>> {
let h = HostInfoValue{
host: info.host.clone(),
rtype: info.rtype.clone(),
dbport: info.dbport.clone(),
cluster_name: info.cluster_name.clone(),
online: false,
insert_time: crate::timestamp(),
update_time: crate::timestamp(),
maintain: false
};
Ok(h)
}
///
/// 写入db
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let row = KeyValue{key: self.host.clone(), value};
db.put(&row, &CfNameTypeCode::HaNodesInfo.get())?;
Ok(())
}
///
/// 编辑节点信息
pub fn edit(&mut self, info: &web::Json<EditInfo>) {
self.host = info.host.clone();
self.dbport = info.dbport.clone();
self.cluster_name = info.cluster_name.clone();
self.update_time = crate::timestamp();
}
///
/// 设置节点维护模式状态
pub fn maintain(&mut self, info: &web::Json<EditMainTain>) {
if info.maintain == "true".to_string() {
self.maintain = false;
}else {
self.maintain = true;
}
self.update_time = crate::timestamp();
}
///
/// 获取当前节点在db中保存的状态信息
pub fn get_state(&self, db: &web::Data<DbInfo>) -> Result<MysqlState, Box<dyn Error>> {
let kv = db.get(&self.host, &CfNameTypeCode::NodesState.get())?;
if kv.value.len() > 0 {
let state: MysqlState = serde_json::from_str(&kv.value)?;
return Ok(state);
}else {
//let err = format!("this host: {} no state data", &self.host);
//return Err(err.into());
let state = MysqlState::new();
return Ok(state);
}
}
pub fn get_role(&self, db: &web::Data<DbInfo>) -> Result<String, Box<dyn Error>> {
let state = self.get_state(db)?;
Ok(state.role)
}
}
///
///
///
///
/// 获取db中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct NodeClusterList{
pub cluster_name_list: Vec<String>
}
impl NodeClusterList{
pub fn new() -> NodeClusterList{
NodeClusterList { cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let value: HostInfoValue = serde_json::from_str(&row.value)?;
if self.is_exists(&value.cluster_name){continue;}
self.cluster_name_list.push(value.cluster_name.clone());
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name{
return true;
}
}
return false;
}
}
/// 获取route信息中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct RouteClusterList{
pub cluster_name_list: Vec<String>
}
impl RouteClusterList{
pub fn new() -> RouteClusterList {
RouteClusterList{ cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let route_all = db.get_route_all()?;
for route in &route_all {
if !self.is_exists(&route.value.cluster_name){
self.cluster_name_list.push(route.value.cluster_name.clone());
}
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name {
return true;
}
}
return false;
}
}
///
///
///
///
/// node节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct NodeInfo{
pub cluster_name: String,
pub host: String,
pub dbport: usize,
pub online: bool, //是否在线， true、false
pub maintain: bool, //是否处于维护模式，true、false
pub role: String, //主从角色
pub master: String,
pub sql_thread: bool,
pub io_thread: bool,
pub seconds_behind: usize,
pub read_only: bool,
pub version: String,
pub executed_gtid_set: String,
pub innodb_flush_log_at_trx_commit: usize,
pub sync_binlog: usize,
pub server_id: usize,
pub event_scheduler: String,
pub sql_error: String
}
impl NodeInfo{
pub fn new(state: &MysqlState, node: &HostInfoValue) -> NodeInfo {
let mut ni = NodeInfo{
cluster_name: node.cluster_name.clone(),
host: node.host.clone(),
dbport: node.dbport.clone(),
online: node.online.clone(),
maintain: node.maintain.clone(),
role: state.role.clone(),
master: state.master.clone(),
sql_thread: state.sql_thread.clone(),
io_thread: state.io_thread.clone(),
seconds_behind: state.seconds_behind.clone(),
read_only: state.read_only.clone(),
version: state.version.clone(),
executed_gtid_set: state.executed_gtid_set.clone(),
innodb_flush_log_at_trx_commit: state.innodb_flush_log_at_trx_commit.clone(),
sync_binlog: state.sync_binlog.clone(),
server_id: state.server_id.clone(),
event_scheduler: state.event_scheduler.clone(),
sql_error: "".to_string()
};
if state.last_io_error.len() > 0{
ni.sql_error = state.last_io_error.clone();
}else if state.last_sql_error.len() > 0 {
ni.sql_error = state.last_sql_error.clone();
}
return ni;
}
}
///
///
///
///
/// 每个集群节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct ClusterNodeInfo{
pub cluster_name: String,
pub total: usize,
pub nodes_info: Vec<NodeInfo>
}
impl ClusterNodeInfo{
pub fn new(cluster_name: &String) -> ClusterNodeInfo{
ClusterNodeInfo{
cluster_name: cluster_name.clone(),
total: 0,
nodes_info: vec![]
}
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let node: HostInfoValue = serde_json::from_str(&row.value)?;
if &node.cluster_name == &self.cluster_name{
let state = node.get_state(db)?;
let node_info = NodeInfo::new(&state, &node);
self.total += 1;
self.nodes_info.push(node_info);
}
}
Ok(())
}
///
/// 统计所有节点监控信息， 用于首页展示
///
/// 倒叙迭代获取每个节点最后一条数据， 如果每个节点都已获取最后一条数据就退出迭代
pub fn static_monitor(&self, db: &web::Data<DbInfo>, rsm: &mut ResponseMonitorStatic) -> Result<(), Box<dyn Error>> {
let cf_name = CfNameTypeCode::SystemData.get();
let mut tmp: Vec<String> = vec![];
//首先检查是否开启监控
for node in &self.nodes_info{
if !self.check_monitor_setting(db, &node.host){
tmp.push(node.host.clone());
}
}
if let Some(cf) = db.db.cf_handle(&cf_name){
let mut iter = db.db.raw_iterator_cf(cf)?;
iter.seek_to_last();
iter.prev();
'all: while iter.valid() {
if tmp.len() == self.nodes_info.len(){
break 'all;
}
if let Some(s) = iter.key(){
let key: String = from_utf8(&s.to_vec())?.parse()?;
if key.starts_with(&PrefixTypeCode::NodeMonitorData.prefix()){
'b: for n in &self.nodes_info{
if key.contains(n.host.as_str()){
for t in &tmp{
if t == &n.host{
break 'b;
}
}
if let Some(v) = iter.value(){
let v: MysqlMonitorStatus = serde_json::from_slice(&v)?;
rsm.update(&v);
tmp.push(n.host.clone());
}
break 'b;
}
}
}
}
//
//
iter.prev();
}
}
Ok(())
}
fn check_monitor_setting(&self, db: &web::Data<DbInfo>, host: &String) -> bool{
let a = db.prefix_get(&PrefixTypeCode::NodeMonitorSeting, host);
match a {
Ok(v) => {
if v.value.len() > 0{
let value: MonitorSetting = serde_json::from_str(&v.value).unwrap();
return value.monitor.clone();
}
}
Err(e) => {
info!("{}", e.to_string());
}
}
return false;
}
}
///
///
impl MysqlState{
pub fn save(&self, db: &web::Data<DbInfo>, key: &String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let a = KeyValue{key: key.clone(), value };
db.put(&a, &CfNameTyp | pub cluster_name: String,
pub delay: usize
}
impl SlaveBehindSetting{
pub fn new(cluster_name: &String) -> SlaveBehindSetting {
SlaveBehindSetting{ cluster_name: cluster_name.clone(), delay: 100 }
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
db.prefix_put(&PrefixTypeCode::SlaveDelaySeting, &self.cluster_name, &self)?;
Ok(())
}
}
| eCode::NodesState.get())?;
Ok(())
}
}
///
///
/// slave behind 配置结构体
#[derive(Serialize, Deserialize, Debug)]
pub struct SlaveBehindSetting{
| conditional_block |
opdb.rs | /*
@author: xiao cai niao
@datetime: 2019/11/6
*/
use actix_web::{web};
use crate::webroute::route::{HostInfo, PostUserInfo, EditInfo, EditMainTain};
use crate::storage::rocks::{DbInfo, KeyValue, CfNameTypeCode, PrefixTypeCode};
use crate::ha::procotol::{DownNodeCheck, RecoveryInfo, ReplicationState, MysqlMonitorStatus};
use std::error::Error;
use crate::ha::nodes_manager::{SlaveInfo};
use serde::{Serialize, Deserialize};
use crate::rand_string;
use crate::ha::procotol::MysqlState;
use crate::ha::sys_manager::MonitorSetting;
use crate::webroute::new_route::ResponseMonitorStatic;
use std::str::from_utf8;
///
/// mysql node info， insert to rocksdb
///
///
pub fn in | ata: web::Data<DbInfo>, info: &web::Json<HostInfo>) -> Result<(), Box<dyn Error>> {
let check_unique = data.get(&info.host, &CfNameTypeCode::HaNodesInfo.get());
match check_unique {
Ok(v) => {
if v.value.len() > 0 {
let a = format!("this key: ({}) already exists in the database",&info.host);
return Err(a.into());
}
}
_ => {}
}
let v = HostInfoValue::new(info)?;
v.save(&data)?;
//初始化节点监控配置
let monitor_info = MonitorSetting::new(&info.host);
monitor_info.save(&data)?;
Ok(())
}
#[derive(Serialize, Deserialize, Debug)]
pub struct HaChangeLog {
pub key: String, //格式 host_timestamp host为宕机节点
pub cluster_name: String,
pub old_master_info: DownNodeCheck, //宕机节点信息
pub new_master_binlog_info: SlaveInfo, //如果宕机节点在切换之前未进行binlog追加将保存新master读取到的binlog信息，在宕机节点恢复时会进行判断回滚
pub recovery_info: RecoveryInfo, //宕机恢复同步所需的新master信息
pub recovery_status: bool, //是否已恢复
pub switch_status: bool, //切换状态
}
impl HaChangeLog {
pub fn new() -> HaChangeLog {
HaChangeLog{
key: "".to_string(),
cluster_name: "".to_string(),
old_master_info: DownNodeCheck { host: "".to_string(), dbport: 0 },
new_master_binlog_info: SlaveInfo {
host: "".to_string(),
dbport: 0,
slave_info: ReplicationState {
log_name: "".to_string(),
read_log_pos: 0,
exec_log_pos: 0
},
new_master: false
},
recovery_info: RecoveryInfo {
binlog: "".to_string(),
position: 0,
gtid: "".to_string(),
masterhost: "".to_string(),
masterport: 0,
read_binlog: "".to_string(),
read_position: 0
},
recovery_status: false,
switch_status: false
}
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let key = format!("{}_{}",self.key.clone(), crate::timestamp());
let value = serde_json::to_string(self)?;
let row = KeyValue{key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
pub fn update(&mut self, db: &web::Data<DbInfo>, row_key: String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(self)?;
let row = KeyValue{key: row_key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
}
///
///
///
/// 用户信息结构
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct UserInfo {
pub user_name: String,
pub password: String,
pub hook_id: String,
pub create_time: i64,
pub update_time: i64
}
impl UserInfo {
pub fn new(info: &PostUserInfo) -> UserInfo {
let create_time = crate::timestamp();
let update_time = crate::timestamp();
UserInfo{
user_name: info.user_name.clone(),
password: info.password.clone(),
hook_id: rand_string(),
create_time,
update_time
}
}
}
///
///
///
/// 节点基础信息, host做为key
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct HostInfoValue {
pub host: String, //127.0.0.1:3306
pub dbport: usize, //default 3306
pub rtype: String, //db、route
pub cluster_name: String, //集群名称,route类型默认default
pub online: bool, //db是否在线， true、false
pub insert_time: i64,
pub update_time: i64,
pub maintain: bool, //是否处于维护模式，true、false
}
impl HostInfoValue {
pub fn new(info: &HostInfo) -> Result<HostInfoValue, Box<dyn Error>> {
let h = HostInfoValue{
host: info.host.clone(),
rtype: info.rtype.clone(),
dbport: info.dbport.clone(),
cluster_name: info.cluster_name.clone(),
online: false,
insert_time: crate::timestamp(),
update_time: crate::timestamp(),
maintain: false
};
Ok(h)
}
///
/// 写入db
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let row = KeyValue{key: self.host.clone(), value};
db.put(&row, &CfNameTypeCode::HaNodesInfo.get())?;
Ok(())
}
///
/// 编辑节点信息
pub fn edit(&mut self, info: &web::Json<EditInfo>) {
self.host = info.host.clone();
self.dbport = info.dbport.clone();
self.cluster_name = info.cluster_name.clone();
self.update_time = crate::timestamp();
}
///
/// 设置节点维护模式状态
pub fn maintain(&mut self, info: &web::Json<EditMainTain>) {
if info.maintain == "true".to_string() {
self.maintain = false;
}else {
self.maintain = true;
}
self.update_time = crate::timestamp();
}
///
/// 获取当前节点在db中保存的状态信息
pub fn get_state(&self, db: &web::Data<DbInfo>) -> Result<MysqlState, Box<dyn Error>> {
let kv = db.get(&self.host, &CfNameTypeCode::NodesState.get())?;
if kv.value.len() > 0 {
let state: MysqlState = serde_json::from_str(&kv.value)?;
return Ok(state);
}else {
//let err = format!("this host: {} no state data", &self.host);
//return Err(err.into());
let state = MysqlState::new();
return Ok(state);
}
}
pub fn get_role(&self, db: &web::Data<DbInfo>) -> Result<String, Box<dyn Error>> {
let state = self.get_state(db)?;
Ok(state.role)
}
}
///
///
///
///
/// 获取db中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct NodeClusterList{
pub cluster_name_list: Vec<String>
}
impl NodeClusterList{
pub fn new() -> NodeClusterList{
NodeClusterList { cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let value: HostInfoValue = serde_json::from_str(&row.value)?;
if self.is_exists(&value.cluster_name){continue;}
self.cluster_name_list.push(value.cluster_name.clone());
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name{
return true;
}
}
return false;
}
}
/// 获取route信息中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct RouteClusterList{
pub cluster_name_list: Vec<String>
}
impl RouteClusterList{
pub fn new() -> RouteClusterList {
RouteClusterList{ cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let route_all = db.get_route_all()?;
for route in &route_all {
if !self.is_exists(&route.value.cluster_name){
self.cluster_name_list.push(route.value.cluster_name.clone());
}
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name {
return true;
}
}
return false;
}
}
///
///
///
///
/// node节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct NodeInfo{
pub cluster_name: String,
pub host: String,
pub dbport: usize,
pub online: bool, //是否在线， true、false
pub maintain: bool, //是否处于维护模式，true、false
pub role: String, //主从角色
pub master: String,
pub sql_thread: bool,
pub io_thread: bool,
pub seconds_behind: usize,
pub read_only: bool,
pub version: String,
pub executed_gtid_set: String,
pub innodb_flush_log_at_trx_commit: usize,
pub sync_binlog: usize,
pub server_id: usize,
pub event_scheduler: String,
pub sql_error: String
}
impl NodeInfo{
pub fn new(state: &MysqlState, node: &HostInfoValue) -> NodeInfo {
let mut ni = NodeInfo{
cluster_name: node.cluster_name.clone(),
host: node.host.clone(),
dbport: node.dbport.clone(),
online: node.online.clone(),
maintain: node.maintain.clone(),
role: state.role.clone(),
master: state.master.clone(),
sql_thread: state.sql_thread.clone(),
io_thread: state.io_thread.clone(),
seconds_behind: state.seconds_behind.clone(),
read_only: state.read_only.clone(),
version: state.version.clone(),
executed_gtid_set: state.executed_gtid_set.clone(),
innodb_flush_log_at_trx_commit: state.innodb_flush_log_at_trx_commit.clone(),
sync_binlog: state.sync_binlog.clone(),
server_id: state.server_id.clone(),
event_scheduler: state.event_scheduler.clone(),
sql_error: "".to_string()
};
if state.last_io_error.len() > 0{
ni.sql_error = state.last_io_error.clone();
}else if state.last_sql_error.len() > 0 {
ni.sql_error = state.last_sql_error.clone();
}
return ni;
}
}
///
///
///
///
/// 每个集群节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct ClusterNodeInfo{
pub cluster_name: String,
pub total: usize,
pub nodes_info: Vec<NodeInfo>
}
impl ClusterNodeInfo{
pub fn new(cluster_name: &String) -> ClusterNodeInfo{
ClusterNodeInfo{
cluster_name: cluster_name.clone(),
total: 0,
nodes_info: vec![]
}
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let node: HostInfoValue = serde_json::from_str(&row.value)?;
if &node.cluster_name == &self.cluster_name{
let state = node.get_state(db)?;
let node_info = NodeInfo::new(&state, &node);
self.total += 1;
self.nodes_info.push(node_info);
}
}
Ok(())
}
///
/// 统计所有节点监控信息， 用于首页展示
///
/// 倒叙迭代获取每个节点最后一条数据， 如果每个节点都已获取最后一条数据就退出迭代
pub fn static_monitor(&self, db: &web::Data<DbInfo>, rsm: &mut ResponseMonitorStatic) -> Result<(), Box<dyn Error>> {
let cf_name = CfNameTypeCode::SystemData.get();
let mut tmp: Vec<String> = vec![];
//首先检查是否开启监控
for node in &self.nodes_info{
if !self.check_monitor_setting(db, &node.host){
tmp.push(node.host.clone());
}
}
if let Some(cf) = db.db.cf_handle(&cf_name){
let mut iter = db.db.raw_iterator_cf(cf)?;
iter.seek_to_last();
iter.prev();
'all: while iter.valid() {
if tmp.len() == self.nodes_info.len(){
break 'all;
}
if let Some(s) = iter.key(){
let key: String = from_utf8(&s.to_vec())?.parse()?;
if key.starts_with(&PrefixTypeCode::NodeMonitorData.prefix()){
'b: for n in &self.nodes_info{
if key.contains(n.host.as_str()){
for t in &tmp{
if t == &n.host{
break 'b;
}
}
if let Some(v) = iter.value(){
let v: MysqlMonitorStatus = serde_json::from_slice(&v)?;
rsm.update(&v);
tmp.push(n.host.clone());
}
break 'b;
}
}
}
}
//
//
iter.prev();
}
}
Ok(())
}
fn check_monitor_setting(&self, db: &web::Data<DbInfo>, host: &String) -> bool{
let a = db.prefix_get(&PrefixTypeCode::NodeMonitorSeting, host);
match a {
Ok(v) => {
if v.value.len() > 0{
let value: MonitorSetting = serde_json::from_str(&v.value).unwrap();
return value.monitor.clone();
}
}
Err(e) => {
info!("{}", e.to_string());
}
}
return false;
}
}
///
///
impl MysqlState{
pub fn save(&self, db: &web::Data<DbInfo>, key: &String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let a = KeyValue{key: key.clone(), value };
db.put(&a, &CfNameTypeCode::NodesState.get())?;
Ok(())
}
}
///
///
/// slave behind 配置结构体
#[derive(Serialize, Deserialize, Debug)]
pub struct SlaveBehindSetting{
pub cluster_name: String,
pub delay: usize
}
impl SlaveBehindSetting{
pub fn new(cluster_name: &String) -> SlaveBehindSetting {
SlaveBehindSetting{ cluster_name: cluster_name.clone(), delay: 100 }
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
db.prefix_put(&PrefixTypeCode::SlaveDelaySeting, &self.cluster_name, &self)?;
Ok(())
}
}
| sert_mysql_host_info(d | identifier_name |
opdb.rs | /*
@author: xiao cai niao
@datetime: 2019/11/6
*/
use actix_web::{web};
use crate::webroute::route::{HostInfo, PostUserInfo, EditInfo, EditMainTain};
use crate::storage::rocks::{DbInfo, KeyValue, CfNameTypeCode, PrefixTypeCode};
use crate::ha::procotol::{DownNodeCheck, RecoveryInfo, ReplicationState, MysqlMonitorStatus};
use std::error::Error;
use crate::ha::nodes_manager::{SlaveInfo};
use serde::{Serialize, Deserialize};
use crate::rand_string;
use crate::ha::procotol::MysqlState;
use crate::ha::sys_manager::MonitorSetting;
use crate::webroute::new_route::ResponseMonitorStatic;
use std::str::from_utf8;
///
/// mysql node info， insert to rocksdb
///
///
pub fn insert_mysql_host_info(data: web::Data<DbInfo>, info: &web::Json<HostInfo>) -> Result<(), Box<dyn Error>> {
let check_unique = data.get(&info.host, &CfNameTypeCode::HaNodesInfo.get());
match check_unique {
Ok(v) => {
if v.value.len() > 0 {
let a = format!("this key: ({}) already exists in the database",&info.host);
return Err(a.into());
}
}
_ => {}
}
let v = HostInfoValue::new(info)?;
v.save(&data)?;
//初始化节点监控配置
let monitor_info = MonitorSetting::new(&info.host);
monitor_info.save(&data)?;
Ok(())
}
#[derive(Serialize, Deserialize, Debug)]
pub struct HaChangeLog {
pub key: String, //格式 host_timestamp host为宕机节点
pub cluster_name: String,
pub old_master_info: DownNodeCheck, //宕机节点信息
pub new_master_binlog_info: SlaveInfo, //如果宕机节点在切换之前未进行binlog追加将保存新master读取到的binlog信息，在宕机节点恢复时会进行判断回滚
pub recovery_info: RecoveryInfo, //宕机恢复同步所需的新master信息
pub recovery_status: bool, //是否已恢复
pub switch_status: bool, //切换状态
}
impl HaChangeLog {
pub fn new() -> HaChangeLog {
HaChangeLog{
key: "".to_string(),
cluster_name: "".to_string(),
old_master_info: DownNodeCheck { host: "".to_string(), dbport: 0 },
new_master_binlog_info: SlaveInfo {
host: "".to_string(),
dbport: 0,
slave_info: ReplicationState {
log_name: "".to_string(),
read_log_pos: 0,
exec_log_pos: 0
},
new_master: false
},
recovery_info: RecoveryInfo {
binlog: "".to_string(),
position: 0,
gtid: "".to_string(),
masterhost: "".to_string(),
masterport: 0,
read_binlog: "".to_string(),
read_position: 0
},
recovery_status: false,
switch_status: false
}
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let key = format!("{}_{}",self.key.clone(), crate::timestamp());
let value = serde_json::to_string(self)?;
let row = KeyValue{key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
pub fn update(&mut self, db: &web::Data<DbInfo>, row_key: String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(self)?;
let row = KeyValue{key: row_key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
}
///
///
///
/// 用户信息结构
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct UserInfo {
pub user_name: String,
pub password: String,
pub hook_id: String,
pub create_time: i64,
pub update_time: i64
}
impl UserInfo {
pub fn new(info: &PostUserInfo) -> UserInfo {
let create_time = crate::timestamp();
let update_time = crate::timestamp();
UserInfo{
user_name: info.user_name.clone(),
password: info.password.clone(),
hook_id: rand_string(),
create_time,
update_time
}
}
}
///
///
///
/// 节点基础信息, host做为key
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct HostInfoValue {
pub host: String, //127.0.0.1:3306
pub dbport: usize, //default 3306
pub rtype: String, //db、route
pub cluster_name: String, //集群名称,route类型默认default
pub online: bool, //db是否在线， true、false
pub insert_time: i64,
pub update_time: i64,
pub maintain: bool, //是否处于维护模式，true、false
}
impl HostInfoValue {
pub fn new(info: &HostInfo) -> Result<HostInfoValue, Box<dyn Error>> {
let h = HostInfoValue{
host: info.host.clone(),
rtype: info.rtype.clone(),
dbport: info.dbport.clone(),
cluster_name: info.cluster_name.clone(),
online: false,
insert_time: crate::timestamp(),
update_time: crate::timestamp(),
maintain: false
};
Ok(h)
}
///
/// 写入db
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let row = KeyValue{key: self.host.clone(), value};
db.put(&row, &CfNameTypeCode::HaNodesInfo.get())?;
Ok(())
}
///
/// 编辑节点信息
pub fn edit(&mut self, info: &web::Json<EditInfo>) {
self.host = info.host.clone();
self.dbport = info.dbport.clone();
self.cluster_name = info.cluster_name.clone();
self.update_time = crate::timestamp();
}
///
/// 设置节点维护模式状态
pub fn maintain(&mut self, info: &web::Json<EditMainTain>) { | }
self.update_time = crate::timestamp();
}
///
/// 获取当前节点在db中保存的状态信息
pub fn get_state(&self, db: &web::Data<DbInfo>) -> Result<MysqlState, Box<dyn Error>> {
let kv = db.get(&self.host, &CfNameTypeCode::NodesState.get())?;
if kv.value.len() > 0 {
let state: MysqlState = serde_json::from_str(&kv.value)?;
return Ok(state);
}else {
//let err = format!("this host: {} no state data", &self.host);
//return Err(err.into());
let state = MysqlState::new();
return Ok(state);
}
}
pub fn get_role(&self, db: &web::Data<DbInfo>) -> Result<String, Box<dyn Error>> {
let state = self.get_state(db)?;
Ok(state.role)
}
}
///
///
///
///
/// 获取db中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct NodeClusterList{
pub cluster_name_list: Vec<String>
}
impl NodeClusterList{
pub fn new() -> NodeClusterList{
NodeClusterList { cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let value: HostInfoValue = serde_json::from_str(&row.value)?;
if self.is_exists(&value.cluster_name){continue;}
self.cluster_name_list.push(value.cluster_name.clone());
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name{
return true;
}
}
return false;
}
}
/// 获取route信息中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct RouteClusterList{
pub cluster_name_list: Vec<String>
}
impl RouteClusterList{
pub fn new() -> RouteClusterList {
RouteClusterList{ cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let route_all = db.get_route_all()?;
for route in &route_all {
if !self.is_exists(&route.value.cluster_name){
self.cluster_name_list.push(route.value.cluster_name.clone());
}
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name {
return true;
}
}
return false;
}
}
///
///
///
///
/// node节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct NodeInfo{
pub cluster_name: String,
pub host: String,
pub dbport: usize,
pub online: bool, //是否在线， true、false
pub maintain: bool, //是否处于维护模式，true、false
pub role: String, //主从角色
pub master: String,
pub sql_thread: bool,
pub io_thread: bool,
pub seconds_behind: usize,
pub read_only: bool,
pub version: String,
pub executed_gtid_set: String,
pub innodb_flush_log_at_trx_commit: usize,
pub sync_binlog: usize,
pub server_id: usize,
pub event_scheduler: String,
pub sql_error: String
}
impl NodeInfo{
pub fn new(state: &MysqlState, node: &HostInfoValue) -> NodeInfo {
let mut ni = NodeInfo{
cluster_name: node.cluster_name.clone(),
host: node.host.clone(),
dbport: node.dbport.clone(),
online: node.online.clone(),
maintain: node.maintain.clone(),
role: state.role.clone(),
master: state.master.clone(),
sql_thread: state.sql_thread.clone(),
io_thread: state.io_thread.clone(),
seconds_behind: state.seconds_behind.clone(),
read_only: state.read_only.clone(),
version: state.version.clone(),
executed_gtid_set: state.executed_gtid_set.clone(),
innodb_flush_log_at_trx_commit: state.innodb_flush_log_at_trx_commit.clone(),
sync_binlog: state.sync_binlog.clone(),
server_id: state.server_id.clone(),
event_scheduler: state.event_scheduler.clone(),
sql_error: "".to_string()
};
if state.last_io_error.len() > 0{
ni.sql_error = state.last_io_error.clone();
}else if state.last_sql_error.len() > 0 {
ni.sql_error = state.last_sql_error.clone();
}
return ni;
}
}
///
///
///
///
/// 每个集群节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct ClusterNodeInfo{
pub cluster_name: String,
pub total: usize,
pub nodes_info: Vec<NodeInfo>
}
impl ClusterNodeInfo{
pub fn new(cluster_name: &String) -> ClusterNodeInfo{
ClusterNodeInfo{
cluster_name: cluster_name.clone(),
total: 0,
nodes_info: vec![]
}
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let node: HostInfoValue = serde_json::from_str(&row.value)?;
if &node.cluster_name == &self.cluster_name{
let state = node.get_state(db)?;
let node_info = NodeInfo::new(&state, &node);
self.total += 1;
self.nodes_info.push(node_info);
}
}
Ok(())
}
///
/// 统计所有节点监控信息， 用于首页展示
///
/// 倒叙迭代获取每个节点最后一条数据， 如果每个节点都已获取最后一条数据就退出迭代
pub fn static_monitor(&self, db: &web::Data<DbInfo>, rsm: &mut ResponseMonitorStatic) -> Result<(), Box<dyn Error>> {
let cf_name = CfNameTypeCode::SystemData.get();
let mut tmp: Vec<String> = vec![];
//首先检查是否开启监控
for node in &self.nodes_info{
if !self.check_monitor_setting(db, &node.host){
tmp.push(node.host.clone());
}
}
if let Some(cf) = db.db.cf_handle(&cf_name){
let mut iter = db.db.raw_iterator_cf(cf)?;
iter.seek_to_last();
iter.prev();
'all: while iter.valid() {
if tmp.len() == self.nodes_info.len(){
break 'all;
}
if let Some(s) = iter.key(){
let key: String = from_utf8(&s.to_vec())?.parse()?;
if key.starts_with(&PrefixTypeCode::NodeMonitorData.prefix()){
'b: for n in &self.nodes_info{
if key.contains(n.host.as_str()){
for t in &tmp{
if t == &n.host{
break 'b;
}
}
if let Some(v) = iter.value(){
let v: MysqlMonitorStatus = serde_json::from_slice(&v)?;
rsm.update(&v);
tmp.push(n.host.clone());
}
break 'b;
}
}
}
}
//
//
iter.prev();
}
}
Ok(())
}
fn check_monitor_setting(&self, db: &web::Data<DbInfo>, host: &String) -> bool{
let a = db.prefix_get(&PrefixTypeCode::NodeMonitorSeting, host);
match a {
Ok(v) => {
if v.value.len() > 0{
let value: MonitorSetting = serde_json::from_str(&v.value).unwrap();
return value.monitor.clone();
}
}
Err(e) => {
info!("{}", e.to_string());
}
}
return false;
}
}
///
///
impl MysqlState{
pub fn save(&self, db: &web::Data<DbInfo>, key: &String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let a = KeyValue{key: key.clone(), value };
db.put(&a, &CfNameTypeCode::NodesState.get())?;
Ok(())
}
}
///
///
/// slave behind 配置结构体
#[derive(Serialize, Deserialize, Debug)]
pub struct SlaveBehindSetting{
pub cluster_name: String,
pub delay: usize
}
impl SlaveBehindSetting{
pub fn new(cluster_name: &String) -> SlaveBehindSetting {
SlaveBehindSetting{ cluster_name: cluster_name.clone(), delay: 100 }
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
db.prefix_put(&PrefixTypeCode::SlaveDelaySeting, &self.cluster_name, &self)?;
Ok(())
}
} | if info.maintain == "true".to_string() {
self.maintain = false;
}else {
self.maintain = true; | random_line_split |
opdb.rs | /*
@author: xiao cai niao
@datetime: 2019/11/6
*/
use actix_web::{web};
use crate::webroute::route::{HostInfo, PostUserInfo, EditInfo, EditMainTain};
use crate::storage::rocks::{DbInfo, KeyValue, CfNameTypeCode, PrefixTypeCode};
use crate::ha::procotol::{DownNodeCheck, RecoveryInfo, ReplicationState, MysqlMonitorStatus};
use std::error::Error;
use crate::ha::nodes_manager::{SlaveInfo};
use serde::{Serialize, Deserialize};
use crate::rand_string;
use crate::ha::procotol::MysqlState;
use crate::ha::sys_manager::MonitorSetting;
use crate::webroute::new_route::ResponseMonitorStatic;
use std::str::from_utf8;
///
/// mysql node info， insert to rocksdb
///
///
pub fn insert_mysql_host_info(data: web::Data<DbInfo>, info: &web::Json<HostInfo>) -> Result<(), Box<dyn Error>> {
let check_unique = data.get(&info.host, &CfNameTypeCode::HaNodesInfo.get());
match check_unique {
Ok(v) => {
if v.value.len() > 0 {
let a = format!("this key: ({}) already exists in the database",&info.host);
return Err(a.into());
}
}
_ => {}
}
let v = HostInfoValue::new(info)?;
v.save(&data)?;
//初始化节点监控配置
let monitor_info = MonitorSetting::new(&info.host);
monitor_info.save(&data)?;
Ok(())
}
#[derive(Serialize, Deserialize, Debug)]
pub struct HaChangeLog {
pub key: String, //格式 host_timestamp host为宕机节点
pub cluster_name: String,
pub old_master_info: DownNodeCheck, //宕机节点信息
pub new_master_binlog_info: SlaveInfo, //如果宕机节点在切换之前未进行binlog追加将保存新master读取到的binlog信息，在宕机节点恢复时会进行判断回滚
pub recovery_info: RecoveryInfo, //宕机恢复同步所需的新master信息
pub recovery_status: bool, //是否已恢复
pub switch_status: bool, //切换状态
}
impl HaChangeLog {
pub fn new() -> HaChangeLog {
HaChangeLog{
key: "".to_string(),
cluster_name: "".to_string(),
old_master_info: DownNodeCheck { host: "".to_string(), dbport: 0 },
new_master_binlog_info: SlaveInfo {
host: "".to_string(),
dbport: 0,
slave_info: ReplicationState {
log_name: "".to_string(),
read_log_pos: 0,
exec_log_pos: 0
},
new_master: false
},
recovery_info: RecoveryInfo {
binlog: "".to_string(),
position: 0,
gtid: "".to_string(),
masterhost: "".to_string(),
masterport: 0,
read_binlog: "".to_string(),
read_position: 0
},
recovery_status: false,
switch_status: false
}
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let key = format!("{}_{}",self.key.clone(), crate::timestamp());
let value = serde_json::to_string(self)?;
let row = KeyValue{key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
pub fn update(&mut self, db: &web::Data<DbInfo>, row_key: String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(self)?;
let row = KeyValue{key: row_key, value};
db.put(&row, &CfNameTypeCode::HaChangeLog.get())?;
return Ok(());
}
}
///
///
///
/// 用户信息结构
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct UserInfo {
pub user_name: String,
pub password: String,
pub hook_id: String,
pub create_time: i64,
pub update_time: i64
}
impl UserInfo {
pub fn new(info: &PostUserInfo) -> UserInfo {
let create_time = crate::timestamp();
let update_time = crate::timestamp();
UserInfo{
user_name: info.user_name.clone(),
password: inf | ult 3306
pub rtype: String, //db、route
pub cluster_name: String, //集群名称,route类型默认default
pub online: bool, //db是否在线， true、false
pub insert_time: i64,
pub update_time: i64,
pub maintain: bool, //是否处于维护模式，true、false
}
impl HostInfoValue {
pub fn new(info: &HostInfo) -> Result<HostInfoValue, Box<dyn Error>> {
let h = HostInfoValue{
host: info.host.clone(),
rtype: info.rtype.clone(),
dbport: info.dbport.clone(),
cluster_name: info.cluster_name.clone(),
online: false,
insert_time: crate::timestamp(),
update_time: crate::timestamp(),
maintain: false
};
Ok(h)
}
///
/// 写入db
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let row = KeyValue{key: self.host.clone(), value};
db.put(&row, &CfNameTypeCode::HaNodesInfo.get())?;
Ok(())
}
///
/// 编辑节点信息
pub fn edit(&mut self, info: &web::Json<EditInfo>) {
self.host = info.host.clone();
self.dbport = info.dbport.clone();
self.cluster_name = info.cluster_name.clone();
self.update_time = crate::timestamp();
}
///
/// 设置节点维护模式状态
pub fn maintain(&mut self, info: &web::Json<EditMainTain>) {
if info.maintain == "true".to_string() {
self.maintain = false;
}else {
self.maintain = true;
}
self.update_time = crate::timestamp();
}
///
/// 获取当前节点在db中保存的状态信息
pub fn get_state(&self, db: &web::Data<DbInfo>) -> Result<MysqlState, Box<dyn Error>> {
let kv = db.get(&self.host, &CfNameTypeCode::NodesState.get())?;
if kv.value.len() > 0 {
let state: MysqlState = serde_json::from_str(&kv.value)?;
return Ok(state);
}else {
//let err = format!("this host: {} no state data", &self.host);
//return Err(err.into());
let state = MysqlState::new();
return Ok(state);
}
}
pub fn get_role(&self, db: &web::Data<DbInfo>) -> Result<String, Box<dyn Error>> {
let state = self.get_state(db)?;
Ok(state.role)
}
}
///
///
///
///
/// 获取db中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct NodeClusterList{
pub cluster_name_list: Vec<String>
}
impl NodeClusterList{
pub fn new() -> NodeClusterList{
NodeClusterList { cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>> {
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let value: HostInfoValue = serde_json::from_str(&row.value)?;
if self.is_exists(&value.cluster_name){continue;}
self.cluster_name_list.push(value.cluster_name.clone());
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name{
return true;
}
}
return false;
}
}
/// 获取route信息中现有的cluster列表
#[derive(Serialize, Deserialize, Debug)]
pub struct RouteClusterList{
pub cluster_name_list: Vec<String>
}
impl RouteClusterList{
pub fn new() -> RouteClusterList {
RouteClusterList{ cluster_name_list: vec![] }
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let route_all = db.get_route_all()?;
for route in &route_all {
if !self.is_exists(&route.value.cluster_name){
self.cluster_name_list.push(route.value.cluster_name.clone());
}
}
Ok(())
}
fn is_exists(&self, cluster_name: &String) -> bool {
for cl in &self.cluster_name_list {
if cl == cluster_name {
return true;
}
}
return false;
}
}
///
///
///
///
/// node节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct NodeInfo{
pub cluster_name: String,
pub host: String,
pub dbport: usize,
pub online: bool, //是否在线， true、false
pub maintain: bool, //是否处于维护模式，true、false
pub role: String, //主从角色
pub master: String,
pub sql_thread: bool,
pub io_thread: bool,
pub seconds_behind: usize,
pub read_only: bool,
pub version: String,
pub executed_gtid_set: String,
pub innodb_flush_log_at_trx_commit: usize,
pub sync_binlog: usize,
pub server_id: usize,
pub event_scheduler: String,
pub sql_error: String
}
impl NodeInfo{
pub fn new(state: &MysqlState, node: &HostInfoValue) -> NodeInfo {
let mut ni = NodeInfo{
cluster_name: node.cluster_name.clone(),
host: node.host.clone(),
dbport: node.dbport.clone(),
online: node.online.clone(),
maintain: node.maintain.clone(),
role: state.role.clone(),
master: state.master.clone(),
sql_thread: state.sql_thread.clone(),
io_thread: state.io_thread.clone(),
seconds_behind: state.seconds_behind.clone(),
read_only: state.read_only.clone(),
version: state.version.clone(),
executed_gtid_set: state.executed_gtid_set.clone(),
innodb_flush_log_at_trx_commit: state.innodb_flush_log_at_trx_commit.clone(),
sync_binlog: state.sync_binlog.clone(),
server_id: state.server_id.clone(),
event_scheduler: state.event_scheduler.clone(),
sql_error: "".to_string()
};
if state.last_io_error.len() > 0{
ni.sql_error = state.last_io_error.clone();
}else if state.last_sql_error.len() > 0 {
ni.sql_error = state.last_sql_error.clone();
}
return ni;
}
}
///
///
///
///
/// 每个集群节点信息
#[derive(Deserialize, Serialize, Debug)]
pub struct ClusterNodeInfo{
pub cluster_name: String,
pub total: usize,
pub nodes_info: Vec<NodeInfo>
}
impl ClusterNodeInfo{
pub fn new(cluster_name: &String) -> ClusterNodeInfo{
ClusterNodeInfo{
cluster_name: cluster_name.clone(),
total: 0,
nodes_info: vec![]
}
}
pub fn init(&mut self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
let result = db.iterator(&CfNameTypeCode::HaNodesInfo.get(), &String::from(""))?;
for row in &result{
let node: HostInfoValue = serde_json::from_str(&row.value)?;
if &node.cluster_name == &self.cluster_name{
let state = node.get_state(db)?;
let node_info = NodeInfo::new(&state, &node);
self.total += 1;
self.nodes_info.push(node_info);
}
}
Ok(())
}
///
/// 统计所有节点监控信息， 用于首页展示
///
/// 倒叙迭代获取每个节点最后一条数据， 如果每个节点都已获取最后一条数据就退出迭代
pub fn static_monitor(&self, db: &web::Data<DbInfo>, rsm: &mut ResponseMonitorStatic) -> Result<(), Box<dyn Error>> {
let cf_name = CfNameTypeCode::SystemData.get();
let mut tmp: Vec<String> = vec![];
//首先检查是否开启监控
for node in &self.nodes_info{
if !self.check_monitor_setting(db, &node.host){
tmp.push(node.host.clone());
}
}
if let Some(cf) = db.db.cf_handle(&cf_name){
let mut iter = db.db.raw_iterator_cf(cf)?;
iter.seek_to_last();
iter.prev();
'all: while iter.valid() {
if tmp.len() == self.nodes_info.len(){
break 'all;
}
if let Some(s) = iter.key(){
let key: String = from_utf8(&s.to_vec())?.parse()?;
if key.starts_with(&PrefixTypeCode::NodeMonitorData.prefix()){
'b: for n in &self.nodes_info{
if key.contains(n.host.as_str()){
for t in &tmp{
if t == &n.host{
break 'b;
}
}
if let Some(v) = iter.value(){
let v: MysqlMonitorStatus = serde_json::from_slice(&v)?;
rsm.update(&v);
tmp.push(n.host.clone());
}
break 'b;
}
}
}
}
//
//
iter.prev();
}
}
Ok(())
}
fn check_monitor_setting(&self, db: &web::Data<DbInfo>, host: &String) -> bool{
let a = db.prefix_get(&PrefixTypeCode::NodeMonitorSeting, host);
match a {
Ok(v) => {
if v.value.len() > 0{
let value: MonitorSetting = serde_json::from_str(&v.value).unwrap();
return value.monitor.clone();
}
}
Err(e) => {
info!("{}", e.to_string());
}
}
return false;
}
}
///
///
impl MysqlState{
pub fn save(&self, db: &web::Data<DbInfo>, key: &String) -> Result<(), Box<dyn Error>> {
let value = serde_json::to_string(&self)?;
let a = KeyValue{key: key.clone(), value };
db.put(&a, &CfNameTypeCode::NodesState.get())?;
Ok(())
}
}
///
///
/// slave behind 配置结构体
#[derive(Serialize, Deserialize, Debug)]
pub struct SlaveBehindSetting{
pub cluster_name: String,
pub delay: usize
}
impl SlaveBehindSetting{
pub fn new(cluster_name: &String) -> SlaveBehindSetting {
SlaveBehindSetting{ cluster_name: cluster_name.clone(), delay: 100 }
}
pub fn save(&self, db: &web::Data<DbInfo>) -> Result<(), Box<dyn Error>>{
db.prefix_put(&PrefixTypeCode::SlaveDelaySeting, &self.cluster_name, &self)?;
Ok(())
}
}
| o.password.clone(),
hook_id: rand_string(),
create_time,
update_time
}
}
}
///
///
///
/// 节点基础信息, host做为key
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct HostInfoValue {
pub host: String, //127.0.0.1:3306
pub dbport: usize, //defa | identifier_body |
server_impl.go | // Contains the implementation of a LSP server.
package lsp
import "errors"
import "strconv"
import "github.com/cmu440/lspnet"
import "container/list"
import "encoding/json"
import "fmt"
import "time"
type msgPackage struct {
msg *Message
addr *lspnet.UDPAddr
}
type abstractClient struct {
addr *lspnet.UDPAddr
nextSN int
nextDataRead int
// window size variable
// server send msg to client
nextSmallestAck int
mapAck map[int]bool
mapNeedAck map[int]*Message
// server receive msg from client
nextSmallestData int
mapReceived map[int]*Message
// variables of epoch
epochNum int
lostConn bool
// close
closeConn bool
}
type requestRead struct {
ask chan int
response chan *Message
}
type requestWrite struct {
ask chan []byte
connId chan int
response chan error
}
type requestClose struct {
ask chan int
//response chan int
getError chan error
}
type requestCloseConn struct {
ask chan int
getError chan error
}
type server struct {
nextConnectId int
clients map[int]*abstractClient
conn *lspnet.UDPConn
readFromClientChan chan *msgPackage
writeToClientChan chan *Message
readRequest *requestRead
writeRequest *requestWrite
readList *list.List
writeList *list.List
flag bool
// variables for window size
windowSize int
mapNeedSend *list.List
// variables for epoch
epochChan chan int
epochMillis int
epochLimit int
// close
deleteClient chan int
closeConnRequest *requestCloseConn
// close every thing
waitToWriteFinish bool
writeFinished chan int
waitToAckFinish bool
ackFinished chan int
closeRead chan int
closeEpoch chan int
closeEvent chan int
// close connection
closeConn chan int
}
// NewServer creates, initiates, and returns a new server. This function should
// NOT block. Instead, it should spawn one or more goroutines (to handle things
// like accepting incoming client connections, triggering epoch events at
// fixed intervals, synchronizing events using a for-select loop like you saw in
// project 0, etc.) and immediately return. It should return a non-nil error if
// there was an error resolving or listening on the specified port number.
func NewServer(port int, params *Params) (Server, error) {
s := &server{
nextConnectId: 1,
clients: make(map[int]*abstractClient),
readFromClientChan: make(chan *msgPackage),
writeToClientChan: make(chan *Message),
readRequest: &requestRead{
ask: make(chan int),
response: make(chan *Message),
},
writeRequest: &requestWrite{
ask: make(chan []byte),
connId: make(chan int),
response: make(chan error),
},
readList: list.New(),
writeList: list.New(),
flag: false,
// variables for window size
windowSize: params.WindowSize,
mapNeedSend: list.New(),
// variables for epoch
epochChan: make(chan int),
epochMillis: params.EpochMillis,
epochLimit: params.EpochLimit,
// close
deleteClient: make(chan int),
closeConnRequest: &requestCloseConn{
ask: make(chan int),
getError: make(chan error),
},
waitToWriteFinish: false,
writeFinished: make(chan int),
waitToAckFinish: false,
ackFinished: make(chan int),
closeRead: make(chan int, 1),
closeEpoch: make(chan int, 1),
closeEvent: make(chan int, 1),
// close conn
closeConn: make(chan int, 1),
}
// start server
addr, err := lspnet.ResolveUDPAddr("udp", "localhost:"+strconv.Itoa(port))
if err != nil {
return nil, err
}
conn, err := lspnet.ListenUDP("udp", addr)
if err != nil {
return nil, err
}
s.conn = conn
go s.readMessage()
go s.handleMessage()
go s.epochFire()
fmt.Println("new server")
return s, nil
}
func (s *server) epochFire() {
for {
select {
case <-s.closeEpoch:
return
default:
////fmt.Println("Server EpochFire!!!!!!!!!!!!!!!!!!!!!!!!!!")
<-time.After(time.Duration(s.epochMillis) * time.Millisecond)
s.epochChan <- 1
}
}
}
func (s *server) handleMessage() {
for {
select {
case <-s.writeFinished:
if s.writeList.Len() == 0 {
s.writeFinished <- 1
} else {
s.waitToWriteFinish = true
}
case <-s.ackFinished:
//fmt.Println("Server 192: receive ack finished")
s.checkAckFinished()
case msg := <-s.readFromClientChan:
////fmt.Println("Server 162: read from client: ", msg)
s.readFromClient(msg)
case msg := <-s.writeToClientChan:
////fmt.Println("Server 165: write to client: ", msg)
if s.clients[msg.ConnID] == nil {
continue
}
if msg.Type == MsgData {
s.clients[msg.ConnID].mapAck[msg.SeqNum] = false
s.clients[msg.ConnID].mapNeedAck[msg.SeqNum] = msg
// data type: need to consider order
if (msg.SeqNum - s.clients[msg.ConnID].nextSmallestAck) < s.windowSize {
s.writeToClient(msg)
} else {
s.writeList.PushBack(msg)
}
} else {
// ack/conn type: don't need to consider order
s.writeToClient(msg)
}
if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
case <-s.readRequest.ask:
s.handleReadRequest()
case payload := <-s.writeRequest.ask:
connId := <-s.writeRequest.connId
var response = s.handleWriteRequest(connId, payload)
s.writeRequest.response <- response
case <-s.epochChan:
s.addEpochNum()
s.handleEpochEvent()
case id := <-s.deleteClient:
delete(s.clients, id)
case id := <-s.closeConnRequest.ask:
if s.clients[id] == nil {
s.closeConnRequest.getError <- errors.New("No client")
}
s.sendDeadMsg(id)
s.closeConnRequest.getError <- nil
}
}
}
func (s *server) checkAckFinished() {
for _, c := range s.clients {
if len(c.mapAck) != 0 {
s.waitToAckFinish = true
//fmt.Println("Server: need to wait ack finish")
return
}
}
s.ackFinished <- 1
}
func (s *server) handleWriteRequest(connID int, payload []byte) error |
func (s *server) sendData(dataMsg *Message) {
s.writeToClientChan <- dataMsg
}
func (s *server) addEpochNum() {
for connId, c := range s.clients {
c.epochNum += 1
if c.epochNum >= s.epochLimit {
c.lostConn = true
s.sendDeadMsg(connId)
}
}
}
func (s *server) sendDeadMsg(connId int) {
dataMsg := NewData(connId, s.clients[connId].nextSN, nil, nil)
if s.flag {
s.readRequest.response <- dataMsg
s.flag = false
} else {
s.readList.PushBack(dataMsg)
}
}
func (s *server) readData(dataMsg *msgPackage) {
s.readFromClient(dataMsg)
}
func (s *server) handleEpochEvent() {
for connID, c := range s.clients {
/*
* if no data received from the client, then resend ack for connection requestRead
*/
if c.nextSmallestAck == 1 {
ack := NewAck(connID, 0)
go s.sendAck(ack)
}
/*
* sent but not acked, resend the data
*/
for key, received := range c.mapAck {
if !received {
msg := c.mapNeedAck[key]
fmt.Println("Server epoch: ", msg)
s.writeToClient(msg)
}
}
}
}
func (s *server) handleReadRequest() {
msg := s.getMessageFromReadList()
if msg != nil {
//////fmt.Println("101 no message")
/*elm := s.readList.Front()
msg := elm.Value.(*Message)*/
s.readRequest.response <- msg
} else {
s.flag = true
}
return
}
// find next msg that can be send
// return nil if no msg can be send
func (s *server) getMessageFromReadList() *Message {
for e := s.readList.Front(); e != nil; e = e.Next() {
msg := e.Value.(*Message)
if msg.SeqNum == s.clients[msg.ConnID].nextDataRead {
s.clients[msg.ConnID].nextDataRead += 1
s.readList.Remove(e)
return msg
}
}
return nil
}
func (s *server) writeToClient(msg *Message) error {
connId := msg.ConnID
addr := s.clients[connId].addr
mmsg, _ := json.Marshal(msg)
fmt.Println("364 Server write to client: ", msg)
_, err := s.conn.WriteToUDP(mmsg, addr)
if err != nil {
fmt.Println("364: ", err)
}
return err
}
func (s *server) readFromClient(msgPack *msgPackage) {
//////fmt.Println("129 read")
msg := msgPack.msg
addr := msgPack.addr
////fmt.Println("server read: ", msg)
if msg.Type == MsgConnect {
s.connectClient(msg, addr)
} else {
// set epoch number to 0
if s.clients[msg.ConnID] != nil {
s.clients[msg.ConnID].epochNum = 0
}
if msg.Type == MsgData {
if !s.waitToAckFinish {
//fmt.Println("Server read from client: ", msg)
s.receiveData(msg)
}
} else if msg.Type == MsgAck {
fmt.Println("389 Server: receive ack: ", msg)
s.receiveAck(msg)
}
if s.waitToAckFinish {
s.checkAckFinished()
}
}
return
}
func (s *server) alreadyHasClient(addr *lspnet.UDPAddr) bool {
////fmt.Println("server: in already has client")
for _, client := range s.clients {
if client.addr.String() == addr.String() {
return true
}
}
return false
}
func (s *server) receiveData(msg *Message) {
//fmt.Println("Server read: ", msg)
c := s.clients[msg.ConnID]
// check duplicated forst and within window size
/*if c.nextSmallestData+s.windowSize <= msg.SeqNum {
// check within window size, drop it if not
return
} else if c.mapReceived[msg.SeqNum] != nil {
// check duplicated outside of window size
return
}*/
//fmt.Println("pass window size")
// here is no duplicated
// decide should we push it to the readlist or chan
if s.flag && (s.clients[msg.ConnID].nextDataRead == msg.SeqNum) {
s.readRequest.response <- msg
c.nextDataRead += 1
s.flag = false
} else if msg.SeqNum >= c.nextDataRead {
s.readList.PushBack(msg)
}
// create ack message
connID := msg.ConnID
seqNum := msg.SeqNum
ack := NewAck(connID, seqNum)
// check the receive variables in client
// delete the message in mapreceived
if msg.SeqNum == c.nextSmallestData {
c.nextSmallestData += 1
for c.mapReceived[c.nextSmallestData] != nil {
delete(c.mapReceived, c.nextSmallestData)
c.nextSmallestData += 1
}
} else {
c.mapReceived[msg.SeqNum] = msg
}
go s.sendAck(ack)
return
}
func (s *server) sendAck(ack *Message) {
s.writeToClientChan <- ack
}
func (s *server) receiveAck(msg *Message) {
//fmt.Println("server: receiveAck")
c := s.clients[msg.ConnID]
if msg.SeqNum >= c.nextSmallestAck {
c.mapAck[msg.SeqNum] = true
}
if msg.SeqNum == c.nextSmallestAck {
// reset the next smallest ack numebr
value, exist := c.mapAck[c.nextSmallestAck]
for exist && value {
delete(c.mapAck, c.nextSmallestAck)
c.nextSmallestAck += 1
value, exist = c.mapAck[c.nextSmallestAck]
}
var l = *list.New()
for element := s.writeList.Front(); element != nil; element = element.Next() {
message := element.Value.(*Message)
if message.ConnID == msg.ConnID {
if (message.SeqNum - c.nextSmallestAck) < s.windowSize {
s.writeToClient(message)
l.PushBack(element)
}
}
}
////fmt.Println("loop finish go out of write")
for element := l.Front(); element != nil; element = element.Next() {
s.writeList.Remove(element)
}
////fmt.Println("go out of delte dfadfasdf")
if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
////fmt.Println("go asdfasdfe dfadfasdf")
}
return
}
func (s *server) connectClient(msg *Message, addr *lspnet.UDPAddr) {
////fmt.Println("Server: connect client ", msg)
// check duplication of connection
if s.alreadyHasClient(addr) {
////fmt.Println("already has client")
return
}
connID := s.nextConnectId
newClient := abstractClient{
addr: addr,
nextSN: 1,
nextDataRead: 1,
// server send msg to client
nextSmallestAck: 1,
mapAck: make(map[int]bool),
mapNeedAck: make(map[int]*Message),
// server receive msg from client
nextSmallestData: 1,
mapReceived: make(map[int]*Message),
// epoch
epochNum: 0,
lostConn: false,
// close
closeConn: false,
}
s.clients[connID] = &newClient
s.nextConnectId += 1
ack := NewAck(connID, 0)
////fmt.Println("Server: send ack to client")
go s.sendAck(ack)
return
}
func (s *server) readMessage() {
var b [1500]byte
//////fmt.Println("Read: read message")
for {
select {
case <-s.closeRead:
return
default:
var msg Message
// unmarshal
n, addr, err := s.conn.ReadFromUDP(b[0:])
err = json.Unmarshal(b[0:n], &msg)
if err == nil {
msgPck := &msgPackage{
msg: &msg,
addr: addr,
}
//fmt.Println("server read: ", &msg)
s.readFromClientChan <- msgPck
} else {
//fmt.Println(err)
return
}
}
}
}
func (s *server) Read() (int, []byte, error) {
s.readRequest.ask <- 1
msg := <-s.readRequest.response
////fmt.Println("Server called read: ", msg)
// check if the client still alive or not
if msg.Payload == nil {
////fmt.Println("client closed when read")
s.deleteClient <- msg.ConnID
//fmt.Println("read ")
return msg.ConnID, nil, errors.New("Client connection lost")
}
// TODO: client lost return connection id
return msg.ConnID, msg.Payload, nil
}
func (s *server) Write(connID int, payload []byte) error {
//fmt.Println("server called write")
/*client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
s.writeToClientChan <- dataMsg
client.nextSN += 1*/
//////fmt.Println(s.clients[connID])
if s.clients[connID] == nil {
return errors.New("Client connection lost")
}
s.writeRequest.ask <- payload
s.writeRequest.connId <- connID
response := <-s.writeRequest.response
return response
}
func (s *server) CloseConn(connID int) error {
//fmt.Println("server closeconn!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.closeConnRequest.ask <- connID
err := <-s.closeConnRequest.getError
//fmt.Println("server closed finish!!!!!!!!!!!!!!!!!!!!!!")
return err
}
func (s *server) Close() error {
return errors.New("text")
//fmt.Println("server: server close !!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.writeFinished <- 0
//fmt.Println("Server: finish wirte1")
<-s.writeFinished
//fmt.Println("Server: finish wirte")
/*s.ackFinished <- 0
<-s.ackFinished*/
//fmt.Println("Server: finish ack")
s.closeEpoch <- 1
s.closeRead <- 1
s.closeEvent <- 1
//fmt.Println("Server: close every thing")
err := s.conn.Close()
if err == nil {
return nil
} else {
return err
}
return errors.New("not yet implemented")
}
| {
//////fmt.Println(connID)
client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
go s.sendData(dataMsg)
client.nextSN += 1
return nil
} | identifier_body |
server_impl.go | // Contains the implementation of a LSP server.
package lsp
import "errors"
import "strconv"
import "github.com/cmu440/lspnet"
import "container/list"
import "encoding/json"
import "fmt"
import "time"
type msgPackage struct {
msg *Message
addr *lspnet.UDPAddr
}
type abstractClient struct {
addr *lspnet.UDPAddr
nextSN int
nextDataRead int
// window size variable
// server send msg to client
nextSmallestAck int
mapAck map[int]bool
mapNeedAck map[int]*Message
// server receive msg from client
nextSmallestData int
mapReceived map[int]*Message
// variables of epoch
epochNum int
lostConn bool
// close
closeConn bool
}
type requestRead struct {
ask chan int
response chan *Message
}
type requestWrite struct {
ask chan []byte
connId chan int
response chan error
}
type requestClose struct {
ask chan int
//response chan int
getError chan error
}
type requestCloseConn struct {
ask chan int
getError chan error
}
type server struct {
nextConnectId int
clients map[int]*abstractClient
conn *lspnet.UDPConn
readFromClientChan chan *msgPackage
writeToClientChan chan *Message
readRequest *requestRead
writeRequest *requestWrite
readList *list.List
writeList *list.List
flag bool
// variables for window size
windowSize int
mapNeedSend *list.List
// variables for epoch
epochChan chan int
epochMillis int
epochLimit int
// close
deleteClient chan int
closeConnRequest *requestCloseConn
// close every thing
waitToWriteFinish bool
writeFinished chan int
waitToAckFinish bool
ackFinished chan int
closeRead chan int
closeEpoch chan int
closeEvent chan int
// close connection
closeConn chan int
}
// NewServer creates, initiates, and returns a new server. This function should
// NOT block. Instead, it should spawn one or more goroutines (to handle things
// like accepting incoming client connections, triggering epoch events at
// fixed intervals, synchronizing events using a for-select loop like you saw in
// project 0, etc.) and immediately return. It should return a non-nil error if
// there was an error resolving or listening on the specified port number.
func NewServer(port int, params *Params) (Server, error) {
s := &server{
nextConnectId: 1,
clients: make(map[int]*abstractClient),
readFromClientChan: make(chan *msgPackage),
writeToClientChan: make(chan *Message),
readRequest: &requestRead{
ask: make(chan int),
response: make(chan *Message),
},
writeRequest: &requestWrite{
ask: make(chan []byte),
connId: make(chan int),
response: make(chan error),
},
readList: list.New(),
writeList: list.New(),
flag: false,
// variables for window size
windowSize: params.WindowSize,
mapNeedSend: list.New(),
// variables for epoch
epochChan: make(chan int),
epochMillis: params.EpochMillis,
epochLimit: params.EpochLimit,
// close
deleteClient: make(chan int),
closeConnRequest: &requestCloseConn{
ask: make(chan int),
getError: make(chan error),
},
waitToWriteFinish: false,
writeFinished: make(chan int),
waitToAckFinish: false,
ackFinished: make(chan int),
closeRead: make(chan int, 1),
closeEpoch: make(chan int, 1),
closeEvent: make(chan int, 1),
// close conn
closeConn: make(chan int, 1),
}
// start server
addr, err := lspnet.ResolveUDPAddr("udp", "localhost:"+strconv.Itoa(port))
if err != nil {
return nil, err
}
conn, err := lspnet.ListenUDP("udp", addr)
if err != nil {
return nil, err
}
s.conn = conn
go s.readMessage()
go s.handleMessage()
go s.epochFire()
fmt.Println("new server")
return s, nil
}
func (s *server) epochFire() {
for {
select {
case <-s.closeEpoch:
return
default:
////fmt.Println("Server EpochFire!!!!!!!!!!!!!!!!!!!!!!!!!!")
<-time.After(time.Duration(s.epochMillis) * time.Millisecond)
s.epochChan <- 1
}
}
}
func (s *server) handleMessage() {
for {
select {
case <-s.writeFinished:
if s.writeList.Len() == 0 {
s.writeFinished <- 1
} else {
s.waitToWriteFinish = true
}
case <-s.ackFinished:
//fmt.Println("Server 192: receive ack finished")
s.checkAckFinished()
case msg := <-s.readFromClientChan:
////fmt.Println("Server 162: read from client: ", msg)
s.readFromClient(msg)
case msg := <-s.writeToClientChan:
////fmt.Println("Server 165: write to client: ", msg)
if s.clients[msg.ConnID] == nil {
continue
}
if msg.Type == MsgData {
s.clients[msg.ConnID].mapAck[msg.SeqNum] = false
s.clients[msg.ConnID].mapNeedAck[msg.SeqNum] = msg
// data type: need to consider order
if (msg.SeqNum - s.clients[msg.ConnID].nextSmallestAck) < s.windowSize {
s.writeToClient(msg)
} else {
s.writeList.PushBack(msg)
}
} else {
// ack/conn type: don't need to consider order
s.writeToClient(msg)
}
if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
case <-s.readRequest.ask:
s.handleReadRequest()
case payload := <-s.writeRequest.ask:
connId := <-s.writeRequest.connId
var response = s.handleWriteRequest(connId, payload)
s.writeRequest.response <- response
case <-s.epochChan:
s.addEpochNum()
s.handleEpochEvent()
case id := <-s.deleteClient:
delete(s.clients, id)
case id := <-s.closeConnRequest.ask:
if s.clients[id] == nil {
s.closeConnRequest.getError <- errors.New("No client")
}
s.sendDeadMsg(id)
s.closeConnRequest.getError <- nil
}
}
}
func (s *server) checkAckFinished() {
for _, c := range s.clients {
if len(c.mapAck) != 0 {
s.waitToAckFinish = true
//fmt.Println("Server: need to wait ack finish")
return
}
}
s.ackFinished <- 1
}
func (s *server) handleWriteRequest(connID int, payload []byte) error {
//////fmt.Println(connID)
client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
go s.sendData(dataMsg)
client.nextSN += 1
return nil
}
func (s *server) sendData(dataMsg *Message) {
s.writeToClientChan <- dataMsg
}
func (s *server) addEpochNum() {
for connId, c := range s.clients {
c.epochNum += 1
if c.epochNum >= s.epochLimit {
c.lostConn = true
s.sendDeadMsg(connId)
}
}
}
func (s *server) sendDeadMsg(connId int) {
dataMsg := NewData(connId, s.clients[connId].nextSN, nil, nil)
if s.flag {
s.readRequest.response <- dataMsg
s.flag = false
} else {
s.readList.PushBack(dataMsg)
}
}
func (s *server) readData(dataMsg *msgPackage) {
s.readFromClient(dataMsg)
}
func (s *server) handleEpochEvent() {
for connID, c := range s.clients {
/*
* if no data received from the client, then resend ack for connection requestRead
*/
if c.nextSmallestAck == 1 {
ack := NewAck(connID, 0)
go s.sendAck(ack)
}
/*
* sent but not acked, resend the data
*/
for key, received := range c.mapAck {
if !received {
msg := c.mapNeedAck[key]
fmt.Println("Server epoch: ", msg)
s.writeToClient(msg)
}
}
}
}
func (s *server) handleReadRequest() {
msg := s.getMessageFromReadList()
if msg != nil {
//////fmt.Println("101 no message")
/*elm := s.readList.Front()
msg := elm.Value.(*Message)*/
s.readRequest.response <- msg
} else {
s.flag = true
}
return
}
// find next msg that can be send
// return nil if no msg can be send
func (s *server) getMessageFromReadList() *Message {
for e := s.readList.Front(); e != nil; e = e.Next() {
msg := e.Value.(*Message)
if msg.SeqNum == s.clients[msg.ConnID].nextDataRead {
s.clients[msg.ConnID].nextDataRead += 1
s.readList.Remove(e)
return msg
}
}
return nil
}
func (s *server) writeToClient(msg *Message) error {
connId := msg.ConnID
addr := s.clients[connId].addr
mmsg, _ := json.Marshal(msg)
fmt.Println("364 Server write to client: ", msg)
_, err := s.conn.WriteToUDP(mmsg, addr)
if err != nil {
fmt.Println("364: ", err)
}
return err
}
func (s *server) readFromClient(msgPack *msgPackage) {
//////fmt.Println("129 read")
msg := msgPack.msg
addr := msgPack.addr
////fmt.Println("server read: ", msg)
if msg.Type == MsgConnect {
s.connectClient(msg, addr)
} else {
// set epoch number to 0
if s.clients[msg.ConnID] != nil {
s.clients[msg.ConnID].epochNum = 0
}
if msg.Type == MsgData {
if !s.waitToAckFinish {
//fmt.Println("Server read from client: ", msg)
s.receiveData(msg)
}
} else if msg.Type == MsgAck {
fmt.Println("389 Server: receive ack: ", msg)
s.receiveAck(msg)
}
if s.waitToAckFinish {
s.checkAckFinished()
}
}
return
}
func (s *server) alreadyHasClient(addr *lspnet.UDPAddr) bool {
////fmt.Println("server: in already has client")
for _, client := range s.clients {
if client.addr.String() == addr.String() {
return true
}
}
return false
}
func (s *server) receiveData(msg *Message) {
//fmt.Println("Server read: ", msg)
c := s.clients[msg.ConnID]
// check duplicated forst and within window size
/*if c.nextSmallestData+s.windowSize <= msg.SeqNum {
// check within window size, drop it if not
return
} else if c.mapReceived[msg.SeqNum] != nil {
// check duplicated outside of window size
return
}*/
//fmt.Println("pass window size")
// here is no duplicated
// decide should we push it to the readlist or chan
if s.flag && (s.clients[msg.ConnID].nextDataRead == msg.SeqNum) {
s.readRequest.response <- msg
c.nextDataRead += 1
s.flag = false
} else if msg.SeqNum >= c.nextDataRead |
// create ack message
connID := msg.ConnID
seqNum := msg.SeqNum
ack := NewAck(connID, seqNum)
// check the receive variables in client
// delete the message in mapreceived
if msg.SeqNum == c.nextSmallestData {
c.nextSmallestData += 1
for c.mapReceived[c.nextSmallestData] != nil {
delete(c.mapReceived, c.nextSmallestData)
c.nextSmallestData += 1
}
} else {
c.mapReceived[msg.SeqNum] = msg
}
go s.sendAck(ack)
return
}
func (s *server) sendAck(ack *Message) {
s.writeToClientChan <- ack
}
func (s *server) receiveAck(msg *Message) {
//fmt.Println("server: receiveAck")
c := s.clients[msg.ConnID]
if msg.SeqNum >= c.nextSmallestAck {
c.mapAck[msg.SeqNum] = true
}
if msg.SeqNum == c.nextSmallestAck {
// reset the next smallest ack numebr
value, exist := c.mapAck[c.nextSmallestAck]
for exist && value {
delete(c.mapAck, c.nextSmallestAck)
c.nextSmallestAck += 1
value, exist = c.mapAck[c.nextSmallestAck]
}
var l = *list.New()
for element := s.writeList.Front(); element != nil; element = element.Next() {
message := element.Value.(*Message)
if message.ConnID == msg.ConnID {
if (message.SeqNum - c.nextSmallestAck) < s.windowSize {
s.writeToClient(message)
l.PushBack(element)
}
}
}
////fmt.Println("loop finish go out of write")
for element := l.Front(); element != nil; element = element.Next() {
s.writeList.Remove(element)
}
////fmt.Println("go out of delte dfadfasdf")
if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
////fmt.Println("go asdfasdfe dfadfasdf")
}
return
}
func (s *server) connectClient(msg *Message, addr *lspnet.UDPAddr) {
////fmt.Println("Server: connect client ", msg)
// check duplication of connection
if s.alreadyHasClient(addr) {
////fmt.Println("already has client")
return
}
connID := s.nextConnectId
newClient := abstractClient{
addr: addr,
nextSN: 1,
nextDataRead: 1,
// server send msg to client
nextSmallestAck: 1,
mapAck: make(map[int]bool),
mapNeedAck: make(map[int]*Message),
// server receive msg from client
nextSmallestData: 1,
mapReceived: make(map[int]*Message),
// epoch
epochNum: 0,
lostConn: false,
// close
closeConn: false,
}
s.clients[connID] = &newClient
s.nextConnectId += 1
ack := NewAck(connID, 0)
////fmt.Println("Server: send ack to client")
go s.sendAck(ack)
return
}
func (s *server) readMessage() {
var b [1500]byte
//////fmt.Println("Read: read message")
for {
select {
case <-s.closeRead:
return
default:
var msg Message
// unmarshal
n, addr, err := s.conn.ReadFromUDP(b[0:])
err = json.Unmarshal(b[0:n], &msg)
if err == nil {
msgPck := &msgPackage{
msg: &msg,
addr: addr,
}
//fmt.Println("server read: ", &msg)
s.readFromClientChan <- msgPck
} else {
//fmt.Println(err)
return
}
}
}
}
func (s *server) Read() (int, []byte, error) {
s.readRequest.ask <- 1
msg := <-s.readRequest.response
////fmt.Println("Server called read: ", msg)
// check if the client still alive or not
if msg.Payload == nil {
////fmt.Println("client closed when read")
s.deleteClient <- msg.ConnID
//fmt.Println("read ")
return msg.ConnID, nil, errors.New("Client connection lost")
}
// TODO: client lost return connection id
return msg.ConnID, msg.Payload, nil
}
func (s *server) Write(connID int, payload []byte) error {
//fmt.Println("server called write")
/*client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
s.writeToClientChan <- dataMsg
client.nextSN += 1*/
//////fmt.Println(s.clients[connID])
if s.clients[connID] == nil {
return errors.New("Client connection lost")
}
s.writeRequest.ask <- payload
s.writeRequest.connId <- connID
response := <-s.writeRequest.response
return response
}
func (s *server) CloseConn(connID int) error {
//fmt.Println("server closeconn!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.closeConnRequest.ask <- connID
err := <-s.closeConnRequest.getError
//fmt.Println("server closed finish!!!!!!!!!!!!!!!!!!!!!!")
return err
}
func (s *server) Close() error {
return errors.New("text")
//fmt.Println("server: server close !!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.writeFinished <- 0
//fmt.Println("Server: finish wirte1")
<-s.writeFinished
//fmt.Println("Server: finish wirte")
/*s.ackFinished <- 0
<-s.ackFinished*/
//fmt.Println("Server: finish ack")
s.closeEpoch <- 1
s.closeRead <- 1
s.closeEvent <- 1
//fmt.Println("Server: close every thing")
err := s.conn.Close()
if err == nil {
return nil
} else {
return err
}
return errors.New("not yet implemented")
}
| {
s.readList.PushBack(msg)
} | conditional_block |
server_impl.go | // Contains the implementation of a LSP server.
package lsp
import "errors"
import "strconv"
import "github.com/cmu440/lspnet"
import "container/list"
import "encoding/json"
import "fmt"
import "time"
type msgPackage struct {
msg *Message
addr *lspnet.UDPAddr
}
type abstractClient struct {
addr *lspnet.UDPAddr
nextSN int
nextDataRead int
// window size variable
// server send msg to client
nextSmallestAck int
mapAck map[int]bool
mapNeedAck map[int]*Message
// server receive msg from client
nextSmallestData int
mapReceived map[int]*Message
// variables of epoch
epochNum int
lostConn bool
// close
closeConn bool
}
type requestRead struct {
ask chan int
response chan *Message
}
type requestWrite struct {
ask chan []byte
connId chan int
response chan error
}
type requestClose struct {
ask chan int
//response chan int
getError chan error
}
type requestCloseConn struct {
ask chan int
getError chan error
}
type server struct {
nextConnectId int
clients map[int]*abstractClient
conn *lspnet.UDPConn
readFromClientChan chan *msgPackage
writeToClientChan chan *Message
readRequest *requestRead
writeRequest *requestWrite
readList *list.List
writeList *list.List
flag bool
// variables for window size
windowSize int
mapNeedSend *list.List
// variables for epoch
epochChan chan int
epochMillis int
epochLimit int
// close
deleteClient chan int
closeConnRequest *requestCloseConn
// close every thing
waitToWriteFinish bool
writeFinished chan int
waitToAckFinish bool
ackFinished chan int
closeRead chan int
closeEpoch chan int
closeEvent chan int
// close connection
closeConn chan int
}
// NewServer creates, initiates, and returns a new server. This function should
// NOT block. Instead, it should spawn one or more goroutines (to handle things
// like accepting incoming client connections, triggering epoch events at
// fixed intervals, synchronizing events using a for-select loop like you saw in
// project 0, etc.) and immediately return. It should return a non-nil error if
// there was an error resolving or listening on the specified port number.
func NewServer(port int, params *Params) (Server, error) {
s := &server{
nextConnectId: 1,
clients: make(map[int]*abstractClient),
readFromClientChan: make(chan *msgPackage),
writeToClientChan: make(chan *Message),
readRequest: &requestRead{
ask: make(chan int),
response: make(chan *Message),
},
writeRequest: &requestWrite{
ask: make(chan []byte),
connId: make(chan int),
response: make(chan error),
},
readList: list.New(),
writeList: list.New(),
flag: false,
// variables for window size
windowSize: params.WindowSize,
mapNeedSend: list.New(),
// variables for epoch
epochChan: make(chan int),
epochMillis: params.EpochMillis,
epochLimit: params.EpochLimit,
// close
deleteClient: make(chan int),
closeConnRequest: &requestCloseConn{
ask: make(chan int),
getError: make(chan error),
},
waitToWriteFinish: false,
writeFinished: make(chan int),
waitToAckFinish: false,
ackFinished: make(chan int),
closeRead: make(chan int, 1),
closeEpoch: make(chan int, 1),
closeEvent: make(chan int, 1),
// close conn
closeConn: make(chan int, 1),
}
// start server
addr, err := lspnet.ResolveUDPAddr("udp", "localhost:"+strconv.Itoa(port))
if err != nil {
return nil, err
}
conn, err := lspnet.ListenUDP("udp", addr)
if err != nil {
return nil, err
}
s.conn = conn
go s.readMessage()
go s.handleMessage()
go s.epochFire()
fmt.Println("new server")
return s, nil
}
func (s *server) epochFire() {
for {
select {
case <-s.closeEpoch:
return
default:
////fmt.Println("Server EpochFire!!!!!!!!!!!!!!!!!!!!!!!!!!")
<-time.After(time.Duration(s.epochMillis) * time.Millisecond)
s.epochChan <- 1
}
}
}
func (s *server) handleMessage() {
for {
select {
case <-s.writeFinished:
if s.writeList.Len() == 0 {
s.writeFinished <- 1
} else {
s.waitToWriteFinish = true
}
case <-s.ackFinished:
//fmt.Println("Server 192: receive ack finished")
s.checkAckFinished()
case msg := <-s.readFromClientChan:
////fmt.Println("Server 162: read from client: ", msg)
s.readFromClient(msg)
case msg := <-s.writeToClientChan:
////fmt.Println("Server 165: write to client: ", msg)
if s.clients[msg.ConnID] == nil {
continue
}
if msg.Type == MsgData {
s.clients[msg.ConnID].mapAck[msg.SeqNum] = false
s.clients[msg.ConnID].mapNeedAck[msg.SeqNum] = msg
// data type: need to consider order
if (msg.SeqNum - s.clients[msg.ConnID].nextSmallestAck) < s.windowSize {
s.writeToClient(msg)
} else {
s.writeList.PushBack(msg)
}
} else {
// ack/conn type: don't need to consider order
s.writeToClient(msg)
}
if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
case <-s.readRequest.ask:
s.handleReadRequest()
case payload := <-s.writeRequest.ask:
connId := <-s.writeRequest.connId
var response = s.handleWriteRequest(connId, payload)
s.writeRequest.response <- response
case <-s.epochChan:
s.addEpochNum()
s.handleEpochEvent()
case id := <-s.deleteClient:
delete(s.clients, id)
case id := <-s.closeConnRequest.ask:
if s.clients[id] == nil {
s.closeConnRequest.getError <- errors.New("No client")
}
s.sendDeadMsg(id)
s.closeConnRequest.getError <- nil
}
}
}
func (s *server) checkAckFinished() {
for _, c := range s.clients {
if len(c.mapAck) != 0 {
s.waitToAckFinish = true
//fmt.Println("Server: need to wait ack finish")
return
}
}
s.ackFinished <- 1
}
func (s *server) handleWriteRequest(connID int, payload []byte) error {
//////fmt.Println(connID)
client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
go s.sendData(dataMsg)
client.nextSN += 1
return nil
}
func (s *server) sendData(dataMsg *Message) {
s.writeToClientChan <- dataMsg
}
func (s *server) addEpochNum() {
for connId, c := range s.clients {
c.epochNum += 1
if c.epochNum >= s.epochLimit {
c.lostConn = true
s.sendDeadMsg(connId)
}
}
}
func (s *server) sendDeadMsg(connId int) {
dataMsg := NewData(connId, s.clients[connId].nextSN, nil, nil)
if s.flag {
s.readRequest.response <- dataMsg
s.flag = false
} else {
s.readList.PushBack(dataMsg)
}
}
func (s *server) readData(dataMsg *msgPackage) {
s.readFromClient(dataMsg)
}
func (s *server) handleEpochEvent() {
for connID, c := range s.clients {
/*
* if no data received from the client, then resend ack for connection requestRead
*/
if c.nextSmallestAck == 1 {
ack := NewAck(connID, 0)
go s.sendAck(ack)
}
/*
* sent but not acked, resend the data
*/
for key, received := range c.mapAck {
if !received {
msg := c.mapNeedAck[key]
fmt.Println("Server epoch: ", msg)
s.writeToClient(msg)
}
}
}
}
func (s *server) handleReadRequest() {
msg := s.getMessageFromReadList()
if msg != nil {
//////fmt.Println("101 no message")
/*elm := s.readList.Front()
msg := elm.Value.(*Message)*/
s.readRequest.response <- msg
} else {
s.flag = true
}
return
}
// find next msg that can be send
// return nil if no msg can be send
func (s *server) getMessageFromReadList() *Message {
for e := s.readList.Front(); e != nil; e = e.Next() {
msg := e.Value.(*Message)
if msg.SeqNum == s.clients[msg.ConnID].nextDataRead {
s.clients[msg.ConnID].nextDataRead += 1
s.readList.Remove(e)
return msg
}
}
return nil
}
func (s *server) writeToClient(msg *Message) error {
connId := msg.ConnID
addr := s.clients[connId].addr
mmsg, _ := json.Marshal(msg)
fmt.Println("364 Server write to client: ", msg)
_, err := s.conn.WriteToUDP(mmsg, addr)
if err != nil {
fmt.Println("364: ", err)
}
return err
}
func (s *server) readFromClient(msgPack *msgPackage) {
//////fmt.Println("129 read")
msg := msgPack.msg
addr := msgPack.addr
////fmt.Println("server read: ", msg)
if msg.Type == MsgConnect {
s.connectClient(msg, addr)
} else {
// set epoch number to 0
if s.clients[msg.ConnID] != nil {
s.clients[msg.ConnID].epochNum = 0
}
if msg.Type == MsgData {
if !s.waitToAckFinish {
//fmt.Println("Server read from client: ", msg)
s.receiveData(msg)
}
} else if msg.Type == MsgAck {
fmt.Println("389 Server: receive ack: ", msg)
s.receiveAck(msg)
}
if s.waitToAckFinish {
s.checkAckFinished()
}
}
return
}
func (s *server) alreadyHasClient(addr *lspnet.UDPAddr) bool {
////fmt.Println("server: in already has client")
for _, client := range s.clients {
if client.addr.String() == addr.String() {
return true
}
}
return false
}
func (s *server) receiveData(msg *Message) {
//fmt.Println("Server read: ", msg)
c := s.clients[msg.ConnID]
// check duplicated forst and within window size
/*if c.nextSmallestData+s.windowSize <= msg.SeqNum {
// check within window size, drop it if not
return
} else if c.mapReceived[msg.SeqNum] != nil {
// check duplicated outside of window size
return
}*/
//fmt.Println("pass window size")
// here is no duplicated
// decide should we push it to the readlist or chan
if s.flag && (s.clients[msg.ConnID].nextDataRead == msg.SeqNum) {
s.readRequest.response <- msg
c.nextDataRead += 1
s.flag = false
} else if msg.SeqNum >= c.nextDataRead {
s.readList.PushBack(msg)
}
// create ack message
connID := msg.ConnID
seqNum := msg.SeqNum
ack := NewAck(connID, seqNum)
// check the receive variables in client
// delete the message in mapreceived
if msg.SeqNum == c.nextSmallestData {
c.nextSmallestData += 1
for c.mapReceived[c.nextSmallestData] != nil {
delete(c.mapReceived, c.nextSmallestData)
c.nextSmallestData += 1
}
} else {
c.mapReceived[msg.SeqNum] = msg
}
go s.sendAck(ack)
return
}
func (s *server) sendAck(ack *Message) {
s.writeToClientChan <- ack
}
func (s *server) receiveAck(msg *Message) {
//fmt.Println("server: receiveAck")
c := s.clients[msg.ConnID]
if msg.SeqNum >= c.nextSmallestAck {
c.mapAck[msg.SeqNum] = true
}
if msg.SeqNum == c.nextSmallestAck {
// reset the next smallest ack numebr
value, exist := c.mapAck[c.nextSmallestAck]
for exist && value {
delete(c.mapAck, c.nextSmallestAck)
c.nextSmallestAck += 1
value, exist = c.mapAck[c.nextSmallestAck]
}
var l = *list.New()
for element := s.writeList.Front(); element != nil; element = element.Next() {
message := element.Value.(*Message)
if message.ConnID == msg.ConnID {
if (message.SeqNum - c.nextSmallestAck) < s.windowSize {
s.writeToClient(message)
l.PushBack(element)
}
}
}
////fmt.Println("loop finish go out of write")
for element := l.Front(); element != nil; element = element.Next() {
s.writeList.Remove(element)
}
////fmt.Println("go out of delte dfadfasdf")
if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
////fmt.Println("go asdfasdfe dfadfasdf")
}
return
}
func (s *server) connectClient(msg *Message, addr *lspnet.UDPAddr) {
////fmt.Println("Server: connect client ", msg)
// check duplication of connection
if s.alreadyHasClient(addr) {
////fmt.Println("already has client")
return
}
connID := s.nextConnectId
newClient := abstractClient{
addr: addr,
nextSN: 1,
nextDataRead: 1,
// server send msg to client
nextSmallestAck: 1,
mapAck: make(map[int]bool),
mapNeedAck: make(map[int]*Message),
// server receive msg from client
nextSmallestData: 1,
mapReceived: make(map[int]*Message),
// epoch
epochNum: 0,
lostConn: false,
// close
closeConn: false,
}
s.clients[connID] = &newClient
s.nextConnectId += 1
ack := NewAck(connID, 0)
////fmt.Println("Server: send ack to client")
go s.sendAck(ack)
return
}
func (s *server) readMessage() {
var b [1500]byte
//////fmt.Println("Read: read message")
for {
select {
case <-s.closeRead:
return
default:
var msg Message
// unmarshal
n, addr, err := s.conn.ReadFromUDP(b[0:])
err = json.Unmarshal(b[0:n], &msg)
if err == nil {
msgPck := &msgPackage{
msg: &msg,
addr: addr,
}
//fmt.Println("server read: ", &msg)
s.readFromClientChan <- msgPck
} else {
//fmt.Println(err)
return
}
}
}
}
func (s *server) Read() (int, []byte, error) {
s.readRequest.ask <- 1
msg := <-s.readRequest.response
////fmt.Println("Server called read: ", msg)
// check if the client still alive or not
if msg.Payload == nil {
////fmt.Println("client closed when read")
s.deleteClient <- msg.ConnID
//fmt.Println("read ")
return msg.ConnID, nil, errors.New("Client connection lost")
}
// TODO: client lost return connection id
return msg.ConnID, msg.Payload, nil
}
func (s *server) Write(connID int, payload []byte) error {
//fmt.Println("server called write")
/*client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
s.writeToClientChan <- dataMsg
client.nextSN += 1*/
//////fmt.Println(s.clients[connID])
if s.clients[connID] == nil {
return errors.New("Client connection lost")
}
s.writeRequest.ask <- payload
s.writeRequest.connId <- connID
response := <-s.writeRequest.response
return response
}
func (s *server) CloseConn(connID int) error {
//fmt.Println("server closeconn!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.closeConnRequest.ask <- connID
err := <-s.closeConnRequest.getError
//fmt.Println("server closed finish!!!!!!!!!!!!!!!!!!!!!!")
return err
}
func (s *server) | () error {
return errors.New("text")
//fmt.Println("server: server close !!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.writeFinished <- 0
//fmt.Println("Server: finish wirte1")
<-s.writeFinished
//fmt.Println("Server: finish wirte")
/*s.ackFinished <- 0
<-s.ackFinished*/
//fmt.Println("Server: finish ack")
s.closeEpoch <- 1
s.closeRead <- 1
s.closeEvent <- 1
//fmt.Println("Server: close every thing")
err := s.conn.Close()
if err == nil {
return nil
} else {
return err
}
return errors.New("not yet implemented")
}
| Close | identifier_name |
server_impl.go | // Contains the implementation of a LSP server.
package lsp
import "errors"
import "strconv"
import "github.com/cmu440/lspnet"
import "container/list"
import "encoding/json"
import "fmt"
import "time"
type msgPackage struct {
msg *Message
addr *lspnet.UDPAddr
}
type abstractClient struct {
addr *lspnet.UDPAddr
nextSN int
nextDataRead int
// window size variable
// server send msg to client
nextSmallestAck int
mapAck map[int]bool
mapNeedAck map[int]*Message
// server receive msg from client
nextSmallestData int
mapReceived map[int]*Message
// variables of epoch
epochNum int
lostConn bool
// close
closeConn bool
}
type requestRead struct {
ask chan int
response chan *Message
}
type requestWrite struct {
ask chan []byte
connId chan int
response chan error
}
type requestClose struct {
ask chan int
//response chan int
getError chan error
}
type requestCloseConn struct {
ask chan int
getError chan error
}
type server struct {
nextConnectId int
clients map[int]*abstractClient
conn *lspnet.UDPConn
readFromClientChan chan *msgPackage
writeToClientChan chan *Message
readRequest *requestRead
writeRequest *requestWrite
readList *list.List
writeList *list.List
flag bool
// variables for window size
windowSize int
mapNeedSend *list.List
// variables for epoch
epochChan chan int
epochMillis int
epochLimit int
// close
deleteClient chan int
closeConnRequest *requestCloseConn
// close every thing
waitToWriteFinish bool
writeFinished chan int
waitToAckFinish bool
ackFinished chan int
closeRead chan int
closeEpoch chan int
closeEvent chan int
// close connection
closeConn chan int
}
// NewServer creates, initiates, and returns a new server. This function should
// NOT block. Instead, it should spawn one or more goroutines (to handle things
// like accepting incoming client connections, triggering epoch events at
// fixed intervals, synchronizing events using a for-select loop like you saw in
// project 0, etc.) and immediately return. It should return a non-nil error if
// there was an error resolving or listening on the specified port number.
func NewServer(port int, params *Params) (Server, error) {
s := &server{
nextConnectId: 1,
clients: make(map[int]*abstractClient),
readFromClientChan: make(chan *msgPackage),
writeToClientChan: make(chan *Message),
readRequest: &requestRead{
ask: make(chan int),
response: make(chan *Message),
},
writeRequest: &requestWrite{
ask: make(chan []byte),
connId: make(chan int),
response: make(chan error),
},
readList: list.New(),
writeList: list.New(),
flag: false,
// variables for window size
windowSize: params.WindowSize,
mapNeedSend: list.New(),
// variables for epoch
epochChan: make(chan int),
epochMillis: params.EpochMillis,
epochLimit: params.EpochLimit,
// close
deleteClient: make(chan int),
closeConnRequest: &requestCloseConn{
ask: make(chan int),
getError: make(chan error),
},
waitToWriteFinish: false,
writeFinished: make(chan int),
waitToAckFinish: false,
ackFinished: make(chan int),
closeRead: make(chan int, 1),
closeEpoch: make(chan int, 1),
closeEvent: make(chan int, 1),
// close conn
closeConn: make(chan int, 1),
}
// start server
addr, err := lspnet.ResolveUDPAddr("udp", "localhost:"+strconv.Itoa(port))
if err != nil {
return nil, err
}
conn, err := lspnet.ListenUDP("udp", addr)
if err != nil {
return nil, err
}
s.conn = conn
go s.readMessage()
go s.handleMessage()
go s.epochFire()
fmt.Println("new server")
return s, nil
}
func (s *server) epochFire() {
for {
select {
case <-s.closeEpoch:
return
default:
////fmt.Println("Server EpochFire!!!!!!!!!!!!!!!!!!!!!!!!!!")
<-time.After(time.Duration(s.epochMillis) * time.Millisecond)
s.epochChan <- 1
}
}
}
func (s *server) handleMessage() {
for {
select {
case <-s.writeFinished:
if s.writeList.Len() == 0 {
s.writeFinished <- 1
} else {
s.waitToWriteFinish = true
}
case <-s.ackFinished:
//fmt.Println("Server 192: receive ack finished")
s.checkAckFinished()
case msg := <-s.readFromClientChan:
////fmt.Println("Server 162: read from client: ", msg)
s.readFromClient(msg)
case msg := <-s.writeToClientChan:
////fmt.Println("Server 165: write to client: ", msg)
if s.clients[msg.ConnID] == nil {
continue
}
if msg.Type == MsgData {
s.clients[msg.ConnID].mapAck[msg.SeqNum] = false
s.clients[msg.ConnID].mapNeedAck[msg.SeqNum] = msg
// data type: need to consider order
if (msg.SeqNum - s.clients[msg.ConnID].nextSmallestAck) < s.windowSize {
s.writeToClient(msg)
} else {
s.writeList.PushBack(msg)
}
} else { | if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
case <-s.readRequest.ask:
s.handleReadRequest()
case payload := <-s.writeRequest.ask:
connId := <-s.writeRequest.connId
var response = s.handleWriteRequest(connId, payload)
s.writeRequest.response <- response
case <-s.epochChan:
s.addEpochNum()
s.handleEpochEvent()
case id := <-s.deleteClient:
delete(s.clients, id)
case id := <-s.closeConnRequest.ask:
if s.clients[id] == nil {
s.closeConnRequest.getError <- errors.New("No client")
}
s.sendDeadMsg(id)
s.closeConnRequest.getError <- nil
}
}
}
func (s *server) checkAckFinished() {
for _, c := range s.clients {
if len(c.mapAck) != 0 {
s.waitToAckFinish = true
//fmt.Println("Server: need to wait ack finish")
return
}
}
s.ackFinished <- 1
}
func (s *server) handleWriteRequest(connID int, payload []byte) error {
//////fmt.Println(connID)
client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
go s.sendData(dataMsg)
client.nextSN += 1
return nil
}
func (s *server) sendData(dataMsg *Message) {
s.writeToClientChan <- dataMsg
}
func (s *server) addEpochNum() {
for connId, c := range s.clients {
c.epochNum += 1
if c.epochNum >= s.epochLimit {
c.lostConn = true
s.sendDeadMsg(connId)
}
}
}
func (s *server) sendDeadMsg(connId int) {
dataMsg := NewData(connId, s.clients[connId].nextSN, nil, nil)
if s.flag {
s.readRequest.response <- dataMsg
s.flag = false
} else {
s.readList.PushBack(dataMsg)
}
}
func (s *server) readData(dataMsg *msgPackage) {
s.readFromClient(dataMsg)
}
func (s *server) handleEpochEvent() {
for connID, c := range s.clients {
/*
* if no data received from the client, then resend ack for connection requestRead
*/
if c.nextSmallestAck == 1 {
ack := NewAck(connID, 0)
go s.sendAck(ack)
}
/*
* sent but not acked, resend the data
*/
for key, received := range c.mapAck {
if !received {
msg := c.mapNeedAck[key]
fmt.Println("Server epoch: ", msg)
s.writeToClient(msg)
}
}
}
}
func (s *server) handleReadRequest() {
msg := s.getMessageFromReadList()
if msg != nil {
//////fmt.Println("101 no message")
/*elm := s.readList.Front()
msg := elm.Value.(*Message)*/
s.readRequest.response <- msg
} else {
s.flag = true
}
return
}
// find next msg that can be send
// return nil if no msg can be send
func (s *server) getMessageFromReadList() *Message {
for e := s.readList.Front(); e != nil; e = e.Next() {
msg := e.Value.(*Message)
if msg.SeqNum == s.clients[msg.ConnID].nextDataRead {
s.clients[msg.ConnID].nextDataRead += 1
s.readList.Remove(e)
return msg
}
}
return nil
}
func (s *server) writeToClient(msg *Message) error {
connId := msg.ConnID
addr := s.clients[connId].addr
mmsg, _ := json.Marshal(msg)
fmt.Println("364 Server write to client: ", msg)
_, err := s.conn.WriteToUDP(mmsg, addr)
if err != nil {
fmt.Println("364: ", err)
}
return err
}
func (s *server) readFromClient(msgPack *msgPackage) {
//////fmt.Println("129 read")
msg := msgPack.msg
addr := msgPack.addr
////fmt.Println("server read: ", msg)
if msg.Type == MsgConnect {
s.connectClient(msg, addr)
} else {
// set epoch number to 0
if s.clients[msg.ConnID] != nil {
s.clients[msg.ConnID].epochNum = 0
}
if msg.Type == MsgData {
if !s.waitToAckFinish {
//fmt.Println("Server read from client: ", msg)
s.receiveData(msg)
}
} else if msg.Type == MsgAck {
fmt.Println("389 Server: receive ack: ", msg)
s.receiveAck(msg)
}
if s.waitToAckFinish {
s.checkAckFinished()
}
}
return
}
func (s *server) alreadyHasClient(addr *lspnet.UDPAddr) bool {
////fmt.Println("server: in already has client")
for _, client := range s.clients {
if client.addr.String() == addr.String() {
return true
}
}
return false
}
func (s *server) receiveData(msg *Message) {
//fmt.Println("Server read: ", msg)
c := s.clients[msg.ConnID]
// check duplicated forst and within window size
/*if c.nextSmallestData+s.windowSize <= msg.SeqNum {
// check within window size, drop it if not
return
} else if c.mapReceived[msg.SeqNum] != nil {
// check duplicated outside of window size
return
}*/
//fmt.Println("pass window size")
// here is no duplicated
// decide should we push it to the readlist or chan
if s.flag && (s.clients[msg.ConnID].nextDataRead == msg.SeqNum) {
s.readRequest.response <- msg
c.nextDataRead += 1
s.flag = false
} else if msg.SeqNum >= c.nextDataRead {
s.readList.PushBack(msg)
}
// create ack message
connID := msg.ConnID
seqNum := msg.SeqNum
ack := NewAck(connID, seqNum)
// check the receive variables in client
// delete the message in mapreceived
if msg.SeqNum == c.nextSmallestData {
c.nextSmallestData += 1
for c.mapReceived[c.nextSmallestData] != nil {
delete(c.mapReceived, c.nextSmallestData)
c.nextSmallestData += 1
}
} else {
c.mapReceived[msg.SeqNum] = msg
}
go s.sendAck(ack)
return
}
func (s *server) sendAck(ack *Message) {
s.writeToClientChan <- ack
}
func (s *server) receiveAck(msg *Message) {
//fmt.Println("server: receiveAck")
c := s.clients[msg.ConnID]
if msg.SeqNum >= c.nextSmallestAck {
c.mapAck[msg.SeqNum] = true
}
if msg.SeqNum == c.nextSmallestAck {
// reset the next smallest ack numebr
value, exist := c.mapAck[c.nextSmallestAck]
for exist && value {
delete(c.mapAck, c.nextSmallestAck)
c.nextSmallestAck += 1
value, exist = c.mapAck[c.nextSmallestAck]
}
var l = *list.New()
for element := s.writeList.Front(); element != nil; element = element.Next() {
message := element.Value.(*Message)
if message.ConnID == msg.ConnID {
if (message.SeqNum - c.nextSmallestAck) < s.windowSize {
s.writeToClient(message)
l.PushBack(element)
}
}
}
////fmt.Println("loop finish go out of write")
for element := l.Front(); element != nil; element = element.Next() {
s.writeList.Remove(element)
}
////fmt.Println("go out of delte dfadfasdf")
if s.waitToWriteFinish && s.writeList.Len() == 0 {
s.writeFinished <- 1
s.waitToWriteFinish = false
}
////fmt.Println("go asdfasdfe dfadfasdf")
}
return
}
func (s *server) connectClient(msg *Message, addr *lspnet.UDPAddr) {
////fmt.Println("Server: connect client ", msg)
// check duplication of connection
if s.alreadyHasClient(addr) {
////fmt.Println("already has client")
return
}
connID := s.nextConnectId
newClient := abstractClient{
addr: addr,
nextSN: 1,
nextDataRead: 1,
// server send msg to client
nextSmallestAck: 1,
mapAck: make(map[int]bool),
mapNeedAck: make(map[int]*Message),
// server receive msg from client
nextSmallestData: 1,
mapReceived: make(map[int]*Message),
// epoch
epochNum: 0,
lostConn: false,
// close
closeConn: false,
}
s.clients[connID] = &newClient
s.nextConnectId += 1
ack := NewAck(connID, 0)
////fmt.Println("Server: send ack to client")
go s.sendAck(ack)
return
}
func (s *server) readMessage() {
var b [1500]byte
//////fmt.Println("Read: read message")
for {
select {
case <-s.closeRead:
return
default:
var msg Message
// unmarshal
n, addr, err := s.conn.ReadFromUDP(b[0:])
err = json.Unmarshal(b[0:n], &msg)
if err == nil {
msgPck := &msgPackage{
msg: &msg,
addr: addr,
}
//fmt.Println("server read: ", &msg)
s.readFromClientChan <- msgPck
} else {
//fmt.Println(err)
return
}
}
}
}
func (s *server) Read() (int, []byte, error) {
s.readRequest.ask <- 1
msg := <-s.readRequest.response
////fmt.Println("Server called read: ", msg)
// check if the client still alive or not
if msg.Payload == nil {
////fmt.Println("client closed when read")
s.deleteClient <- msg.ConnID
//fmt.Println("read ")
return msg.ConnID, nil, errors.New("Client connection lost")
}
// TODO: client lost return connection id
return msg.ConnID, msg.Payload, nil
}
func (s *server) Write(connID int, payload []byte) error {
//fmt.Println("server called write")
/*client := s.clients[connID]
dataMsg := NewData(connID, client.nextSN, payload, payload)
////fmt.Println("Server: 197 write ", dataMsg)
s.writeToClientChan <- dataMsg
client.nextSN += 1*/
//////fmt.Println(s.clients[connID])
if s.clients[connID] == nil {
return errors.New("Client connection lost")
}
s.writeRequest.ask <- payload
s.writeRequest.connId <- connID
response := <-s.writeRequest.response
return response
}
func (s *server) CloseConn(connID int) error {
//fmt.Println("server closeconn!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.closeConnRequest.ask <- connID
err := <-s.closeConnRequest.getError
//fmt.Println("server closed finish!!!!!!!!!!!!!!!!!!!!!!")
return err
}
func (s *server) Close() error {
return errors.New("text")
//fmt.Println("server: server close !!!!!!!!!!!!!!!!!!!!!!!!!!!!")
s.writeFinished <- 0
//fmt.Println("Server: finish wirte1")
<-s.writeFinished
//fmt.Println("Server: finish wirte")
/*s.ackFinished <- 0
<-s.ackFinished*/
//fmt.Println("Server: finish ack")
s.closeEpoch <- 1
s.closeRead <- 1
s.closeEvent <- 1
//fmt.Println("Server: close every thing")
err := s.conn.Close()
if err == nil {
return nil
} else {
return err
}
return errors.New("not yet implemented")
} | // ack/conn type: don't need to consider order
s.writeToClient(msg)
}
| random_line_split |
simulation.py | """Assignment 1 - Simulation
=== CSC148 Fall 2017 ===
Diane Horton and David Liu
Department of Computer Science,
University of Toronto
=== Module Description ===
This file contains the Simulation class, which is the main class for your
bike-share simulation.
At the bottom of the file, there is a sample_simulation function that you
can use to try running the simulation at any time.
"""
import csv
from datetime import datetime, timedelta
import json
from typing import Dict, List, Tuple
from bikeshare import Ride, Station
from container import PriorityQueue
from visualizer import Visualizer
# Datetime format to parse the ride data
DATETIME_FORMAT = '%Y-%m-%d %H:%M'
#Function constants for reporting beggining and ending of rides
RIDE_BEGUN = True
RIDE_FINISHED = False
# Stock issues report
SUCCESSFUL_REPORT = 0
EMPTY_STATION_ISSUE = 1
FULL_STATION_ISSUE = 2
class Simulation:
"""Runs the core of the simulation through time.
=== Attributes ===
all_rides:
A list of all the rides in this simulation.
Note that not all rides might be used, depending on the timeframe
when the simulation is run.
all_stations:
A dictionary containing all the stations in this simulation.
visualizer:
A helper class for visualizing the simulation.
active_rides:
All rides that are active during simulation
"""
all_stations: Dict[str, Station]
all_rides: List[Ride]
visualizer: Visualizer
active_rides: List[Ride]
def __init__(self, station_file: str, ride_file: str) -> None:
"""Initialize this simulation with the given configuration settings.
"""
self.all_stations = create_stations(station_file)
self.all_rides = create_rides(ride_file, self.all_stations)
self.visualizer = Visualizer()
self.active_rides = []
def run(self, start: datetime, end: datetime) -> None:
"""Run the simulation from <start> to <end>.
"""
step = timedelta(minutes=1) # Each iteration spans one minute of time
current_time = start
while current_time <= end:
self._update_active_rides(current_time)
# Method that draws all stations and bikes on the map
self.visualizer.render_drawables(list(self.all_stations.values())\
+ self.active_rides, current_time)
current_time += step
# Leave this code at the very bottom of this method.
# It will keep the visualization window open until you close
# it by pressing the 'X'.
while True:
if self.visualizer.handle_window_events():
return # Stop the simulation
def _update_active_rides(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- Loop through `self.all_rides` and compare each Ride's start and
end times with <time>.
If <time> is between the ride's start and end times (inclusive),
then add the ride to self.active_rides if it isn't already in
that list.
Otherwise, remove the ride from self.active_rides if it is in
that list.
- This means that if a ride started before the simulation's time
period but ends during or after the simulation's time period,
it should still be added to self.active_rides.
"""
for ride in self.all_rides:
# Check whether the current time is between start and end
if time > ride.start_time and time < ride.end_time:
# Check whether it is already in the active rides list
if not ride in self.active_rides:
# Reports that this ride has just begun
# this method will also lead to an update on station's bike
# number.
if ride.report_status(RIDE_BEGUN, time) \
== SUCCESSFUL_REPORT:
# Adds to the active rides list if no anomaly was
# detected
self.active_rides.append(ride)
else:
if ride in self.active_rides:
# Reports that this ride has finished
# this method will also lead to an update on station's bike
# number
ride.report_status(RIDE_FINISHED, time)
# If a finished or not yet beginned ride is in this
# list, removes it.
self.active_rides.remove(ride)
def calculate_statistics(self) -> Dict[str, Tuple[str, float]]:
|
def _update_active_rides_fast(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- see Task 5 of the assignment handout
"""
pass
def create_stations(stations_file: str) -> Dict[str, 'Station']:
"""Return the stations described in the given JSON data file.
Each key in the returned dictionary is a station id,
and each value is the corresponding Station object.
Note that you need to call Station(...) to create these objects!
Precondition: stations_file matches the format specified in the
assignment handout.
This function should be called *before* _read_rides because the
rides CSV file refers to station ids.
"""
# Read in raw data using the json library.
with open(stations_file) as file:
raw_stations = json.load(file)
stations = {}
for s in raw_stations['stations']:
# Extract the relevant fields from the raw station JSON.
# s is a dictionary with the keys 'n', 's', 'la', 'lo', 'da', and 'ba'
# as described in the assignment handout.
# NOTE: all of the corresponding values are strings, and so you need
# to convert some of them to numbers explicitly using int() or float().
# Inputs for Station Class (with keys from dictionary) :
# -Lon/Lat (lo/la)
# -Capacity (da + ba)
# -Number of bikes (da)
# -Name (s)
station = Station((s['lo'], s['la']), s['da'] + s['ba'],\
s['da'], s['s'])
stations[s['n']] = station
return stations
def create_rides(rides_file: str,
stations: Dict[str, 'Station']) -> List['Ride']:
"""Return the rides described in the given CSV file.
Lookup the station ids contained in the rides file in <stations>
to access the corresponding Station objects.
Ignore any ride whose start or end station is not present in <stations>.
Precondition: rides_file matches the format specified in the
assignment handout.
"""
rides = []
with open(rides_file) as file:
for line in csv.reader(file):
# line is a list of strings, following the format described
# in the assignment handout.
#
# Convert between a string and a datetime object
# using the function datetime.strptime and the DATETIME_FORMAT
# constant we defined above. Example:
# >>> datetime.strptime('2017-06-01 8:00', DATETIME_FORMAT)
# datetime.datetime(2017, 6, 1, 8, 0)
# CSV Columns:
# -Start time [0]
# -Start station code [1]
# -End time [2]
# -End station code [3]
# -ignore the rest [4,5]
# Ride class inputs:
# -Start station (Station())
# -End station (Station())
# -Times (Tuple(start,end))
start_station_code = line[1]
end_station_code = line[3]
# First check whether the stations from the ride are present in the
# stations registry
if start_station_code and end_station_code in stations:
start_time = datetime.strptime(line[0], DATETIME_FORMAT)
end_time = datetime.strptime(line[2], DATETIME_FORMAT)
start_station = stations[start_station_code]
end_station = stations[end_station_code]
ride = Ride(start_station, end_station, (start_time, end_time))
rides.append(ride)
return rides
class Event:
"""An event in the bike share simulation.
Events are ordered by their timestamp.
"""
simulation: 'Simulation'
time: datetime
def __init__(self, simulation: 'Simulation', time: datetime) -> None:
"""Initialize a new event."""
self.simulation = simulation
self.time = time
def __lt__(self, other: 'Event') -> bool:
"""Return whether this event is less than <other>.
Events are ordered by their timestamp.
"""
return self.time < other.time
def process(self) -> List['Event']:
"""Process this event by updating the state of the simulation.
Return a list of new events spawned by this event.
"""
raise NotImplementedError
class RideStartEvent(Event):
"""An event corresponding to the start of a ride."""
pass
class RideEndEvent(Event):
"""An event corresponding to the start of a ride."""
pass
def sample_simulation() -> Dict[str, Tuple[str, float]]:
"""Run a sample simulation. For testing purposes only."""
sim = Simulation('stations.json', 'sample_rides.csv')
sim.run(datetime(2017, 6, 1, 8, 0, 0),
datetime(2017, 6, 1, 9, 0, 0))
return sim.calculate_statistics()
if __name__ == '__main__':
# Uncomment these lines when you want to check your work using python_ta!
# import python_ta
# python_ta.check_all(config={
# 'allowed-io': ['create_stations', 'create_rides'],
# 'allowed-import-modules': [
# 'doctest', 'python_ta', 'typing',
# 'csv', 'datetime', 'json',
# 'bikeshare', 'container', 'visualizer'
# ]
# })
print(sample_simulation())
| """Return a dictionary containing statistics for this simulation.
The returned dictionary has exactly four keys, corresponding
to the four statistics tracked for each station:
- 'max_start'
- 'max_end'
- 'max_time_low_availability'
- 'max_time_low_unoccupied'
The corresponding value of each key is a tuple of two elements,
where the first element is the name (NOT id) of the station that has
the maximum value of the quantity specified by that key,
and the second element is the value of that quantity.
For example, the value corresponding to key 'max_start' should be the
name of the station with the most number of rides started at that
station, and the number of rides that started at that station.
"""
tempDict = {
'max_start': ('', -1),
'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
}
return {
'max_start': ('', -1),
'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
} | identifier_body |
simulation.py | """Assignment 1 - Simulation
=== CSC148 Fall 2017 ===
Diane Horton and David Liu
Department of Computer Science,
University of Toronto
=== Module Description ===
This file contains the Simulation class, which is the main class for your
bike-share simulation.
At the bottom of the file, there is a sample_simulation function that you
can use to try running the simulation at any time.
"""
import csv
from datetime import datetime, timedelta
import json
from typing import Dict, List, Tuple
from bikeshare import Ride, Station
from container import PriorityQueue
from visualizer import Visualizer
# Datetime format to parse the ride data
DATETIME_FORMAT = '%Y-%m-%d %H:%M'
#Function constants for reporting beggining and ending of rides
RIDE_BEGUN = True
RIDE_FINISHED = False
# Stock issues report
SUCCESSFUL_REPORT = 0
EMPTY_STATION_ISSUE = 1
FULL_STATION_ISSUE = 2
class | :
"""Runs the core of the simulation through time.
=== Attributes ===
all_rides:
A list of all the rides in this simulation.
Note that not all rides might be used, depending on the timeframe
when the simulation is run.
all_stations:
A dictionary containing all the stations in this simulation.
visualizer:
A helper class for visualizing the simulation.
active_rides:
All rides that are active during simulation
"""
all_stations: Dict[str, Station]
all_rides: List[Ride]
visualizer: Visualizer
active_rides: List[Ride]
def __init__(self, station_file: str, ride_file: str) -> None:
"""Initialize this simulation with the given configuration settings.
"""
self.all_stations = create_stations(station_file)
self.all_rides = create_rides(ride_file, self.all_stations)
self.visualizer = Visualizer()
self.active_rides = []
def run(self, start: datetime, end: datetime) -> None:
"""Run the simulation from <start> to <end>.
"""
step = timedelta(minutes=1) # Each iteration spans one minute of time
current_time = start
while current_time <= end:
self._update_active_rides(current_time)
# Method that draws all stations and bikes on the map
self.visualizer.render_drawables(list(self.all_stations.values())\
+ self.active_rides, current_time)
current_time += step
# Leave this code at the very bottom of this method.
# It will keep the visualization window open until you close
# it by pressing the 'X'.
while True:
if self.visualizer.handle_window_events():
return # Stop the simulation
def _update_active_rides(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- Loop through `self.all_rides` and compare each Ride's start and
end times with <time>.
If <time> is between the ride's start and end times (inclusive),
then add the ride to self.active_rides if it isn't already in
that list.
Otherwise, remove the ride from self.active_rides if it is in
that list.
- This means that if a ride started before the simulation's time
period but ends during or after the simulation's time period,
it should still be added to self.active_rides.
"""
for ride in self.all_rides:
# Check whether the current time is between start and end
if time > ride.start_time and time < ride.end_time:
# Check whether it is already in the active rides list
if not ride in self.active_rides:
# Reports that this ride has just begun
# this method will also lead to an update on station's bike
# number.
if ride.report_status(RIDE_BEGUN, time) \
== SUCCESSFUL_REPORT:
# Adds to the active rides list if no anomaly was
# detected
self.active_rides.append(ride)
else:
if ride in self.active_rides:
# Reports that this ride has finished
# this method will also lead to an update on station's bike
# number
ride.report_status(RIDE_FINISHED, time)
# If a finished or not yet beginned ride is in this
# list, removes it.
self.active_rides.remove(ride)
def calculate_statistics(self) -> Dict[str, Tuple[str, float]]:
"""Return a dictionary containing statistics for this simulation.
The returned dictionary has exactly four keys, corresponding
to the four statistics tracked for each station:
- 'max_start'
- 'max_end'
- 'max_time_low_availability'
- 'max_time_low_unoccupied'
The corresponding value of each key is a tuple of two elements,
where the first element is the name (NOT id) of the station that has
the maximum value of the quantity specified by that key,
and the second element is the value of that quantity.
For example, the value corresponding to key 'max_start' should be the
name of the station with the most number of rides started at that
station, and the number of rides that started at that station.
"""
tempDict = {
'max_start': ('', -1),
'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
}
return {
'max_start': ('', -1),
'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
}
def _update_active_rides_fast(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- see Task 5 of the assignment handout
"""
pass
def create_stations(stations_file: str) -> Dict[str, 'Station']:
"""Return the stations described in the given JSON data file.
Each key in the returned dictionary is a station id,
and each value is the corresponding Station object.
Note that you need to call Station(...) to create these objects!
Precondition: stations_file matches the format specified in the
assignment handout.
This function should be called *before* _read_rides because the
rides CSV file refers to station ids.
"""
# Read in raw data using the json library.
with open(stations_file) as file:
raw_stations = json.load(file)
stations = {}
for s in raw_stations['stations']:
# Extract the relevant fields from the raw station JSON.
# s is a dictionary with the keys 'n', 's', 'la', 'lo', 'da', and 'ba'
# as described in the assignment handout.
# NOTE: all of the corresponding values are strings, and so you need
# to convert some of them to numbers explicitly using int() or float().
# Inputs for Station Class (with keys from dictionary) :
# -Lon/Lat (lo/la)
# -Capacity (da + ba)
# -Number of bikes (da)
# -Name (s)
station = Station((s['lo'], s['la']), s['da'] + s['ba'],\
s['da'], s['s'])
stations[s['n']] = station
return stations
def create_rides(rides_file: str,
stations: Dict[str, 'Station']) -> List['Ride']:
"""Return the rides described in the given CSV file.
Lookup the station ids contained in the rides file in <stations>
to access the corresponding Station objects.
Ignore any ride whose start or end station is not present in <stations>.
Precondition: rides_file matches the format specified in the
assignment handout.
"""
rides = []
with open(rides_file) as file:
for line in csv.reader(file):
# line is a list of strings, following the format described
# in the assignment handout.
#
# Convert between a string and a datetime object
# using the function datetime.strptime and the DATETIME_FORMAT
# constant we defined above. Example:
# >>> datetime.strptime('2017-06-01 8:00', DATETIME_FORMAT)
# datetime.datetime(2017, 6, 1, 8, 0)
# CSV Columns:
# -Start time [0]
# -Start station code [1]
# -End time [2]
# -End station code [3]
# -ignore the rest [4,5]
# Ride class inputs:
# -Start station (Station())
# -End station (Station())
# -Times (Tuple(start,end))
start_station_code = line[1]
end_station_code = line[3]
# First check whether the stations from the ride are present in the
# stations registry
if start_station_code and end_station_code in stations:
start_time = datetime.strptime(line[0], DATETIME_FORMAT)
end_time = datetime.strptime(line[2], DATETIME_FORMAT)
start_station = stations[start_station_code]
end_station = stations[end_station_code]
ride = Ride(start_station, end_station, (start_time, end_time))
rides.append(ride)
return rides
class Event:
"""An event in the bike share simulation.
Events are ordered by their timestamp.
"""
simulation: 'Simulation'
time: datetime
def __init__(self, simulation: 'Simulation', time: datetime) -> None:
"""Initialize a new event."""
self.simulation = simulation
self.time = time
def __lt__(self, other: 'Event') -> bool:
"""Return whether this event is less than <other>.
Events are ordered by their timestamp.
"""
return self.time < other.time
def process(self) -> List['Event']:
"""Process this event by updating the state of the simulation.
Return a list of new events spawned by this event.
"""
raise NotImplementedError
class RideStartEvent(Event):
"""An event corresponding to the start of a ride."""
pass
class RideEndEvent(Event):
"""An event corresponding to the start of a ride."""
pass
def sample_simulation() -> Dict[str, Tuple[str, float]]:
"""Run a sample simulation. For testing purposes only."""
sim = Simulation('stations.json', 'sample_rides.csv')
sim.run(datetime(2017, 6, 1, 8, 0, 0),
datetime(2017, 6, 1, 9, 0, 0))
return sim.calculate_statistics()
if __name__ == '__main__':
# Uncomment these lines when you want to check your work using python_ta!
# import python_ta
# python_ta.check_all(config={
# 'allowed-io': ['create_stations', 'create_rides'],
# 'allowed-import-modules': [
# 'doctest', 'python_ta', 'typing',
# 'csv', 'datetime', 'json',
# 'bikeshare', 'container', 'visualizer'
# ]
# })
print(sample_simulation())
| Simulation | identifier_name |
simulation.py | """Assignment 1 - Simulation
=== CSC148 Fall 2017 ===
Diane Horton and David Liu
Department of Computer Science,
University of Toronto
=== Module Description ===
This file contains the Simulation class, which is the main class for your
bike-share simulation.
At the bottom of the file, there is a sample_simulation function that you
can use to try running the simulation at any time.
"""
import csv
from datetime import datetime, timedelta
import json
from typing import Dict, List, Tuple
from bikeshare import Ride, Station
from container import PriorityQueue
from visualizer import Visualizer
# Datetime format to parse the ride data
DATETIME_FORMAT = '%Y-%m-%d %H:%M'
#Function constants for reporting beggining and ending of rides
RIDE_BEGUN = True
RIDE_FINISHED = False
# Stock issues report
SUCCESSFUL_REPORT = 0
EMPTY_STATION_ISSUE = 1
FULL_STATION_ISSUE = 2
class Simulation:
"""Runs the core of the simulation through time.
=== Attributes ===
all_rides:
A list of all the rides in this simulation.
Note that not all rides might be used, depending on the timeframe
when the simulation is run.
all_stations:
A dictionary containing all the stations in this simulation.
visualizer:
A helper class for visualizing the simulation.
active_rides:
All rides that are active during simulation
"""
all_stations: Dict[str, Station]
all_rides: List[Ride]
visualizer: Visualizer
active_rides: List[Ride]
def __init__(self, station_file: str, ride_file: str) -> None:
"""Initialize this simulation with the given configuration settings.
"""
self.all_stations = create_stations(station_file)
self.all_rides = create_rides(ride_file, self.all_stations)
self.visualizer = Visualizer()
self.active_rides = []
def run(self, start: datetime, end: datetime) -> None:
"""Run the simulation from <start> to <end>.
"""
step = timedelta(minutes=1) # Each iteration spans one minute of time
current_time = start
while current_time <= end:
self._update_active_rides(current_time)
# Method that draws all stations and bikes on the map
self.visualizer.render_drawables(list(self.all_stations.values())\
+ self.active_rides, current_time)
current_time += step
# Leave this code at the very bottom of this method.
# It will keep the visualization window open until you close
# it by pressing the 'X'.
while True:
if self.visualizer.handle_window_events():
return # Stop the simulation
def _update_active_rides(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- Loop through `self.all_rides` and compare each Ride's start and
end times with <time>.
If <time> is between the ride's start and end times (inclusive),
then add the ride to self.active_rides if it isn't already in
that list.
Otherwise, remove the ride from self.active_rides if it is in
that list.
- This means that if a ride started before the simulation's time
period but ends during or after the simulation's time period,
it should still be added to self.active_rides.
"""
for ride in self.all_rides:
# Check whether the current time is between start and end
if time > ride.start_time and time < ride.end_time:
# Check whether it is already in the active rides list
if not ride in self.active_rides:
# Reports that this ride has just begun
# this method will also lead to an update on station's bike
# number.
if ride.report_status(RIDE_BEGUN, time) \
== SUCCESSFUL_REPORT:
# Adds to the active rides list if no anomaly was
# detected
self.active_rides.append(ride)
else:
if ride in self.active_rides:
# Reports that this ride has finished
# this method will also lead to an update on station's bike
# number
ride.report_status(RIDE_FINISHED, time)
# If a finished or not yet beginned ride is in this
# list, removes it.
self.active_rides.remove(ride)
def calculate_statistics(self) -> Dict[str, Tuple[str, float]]:
"""Return a dictionary containing statistics for this simulation.
The returned dictionary has exactly four keys, corresponding
to the four statistics tracked for each station:
- 'max_start'
- 'max_end'
- 'max_time_low_availability'
- 'max_time_low_unoccupied'
The corresponding value of each key is a tuple of two elements,
where the first element is the name (NOT id) of the station that has
the maximum value of the quantity specified by that key,
and the second element is the value of that quantity.
For example, the value corresponding to key 'max_start' should be the
name of the station with the most number of rides started at that
station, and the number of rides that started at that station.
"""
tempDict = {
'max_start': ('', -1),
'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
}
return { | 'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
}
def _update_active_rides_fast(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- see Task 5 of the assignment handout
"""
pass
def create_stations(stations_file: str) -> Dict[str, 'Station']:
"""Return the stations described in the given JSON data file.
Each key in the returned dictionary is a station id,
and each value is the corresponding Station object.
Note that you need to call Station(...) to create these objects!
Precondition: stations_file matches the format specified in the
assignment handout.
This function should be called *before* _read_rides because the
rides CSV file refers to station ids.
"""
# Read in raw data using the json library.
with open(stations_file) as file:
raw_stations = json.load(file)
stations = {}
for s in raw_stations['stations']:
# Extract the relevant fields from the raw station JSON.
# s is a dictionary with the keys 'n', 's', 'la', 'lo', 'da', and 'ba'
# as described in the assignment handout.
# NOTE: all of the corresponding values are strings, and so you need
# to convert some of them to numbers explicitly using int() or float().
# Inputs for Station Class (with keys from dictionary) :
# -Lon/Lat (lo/la)
# -Capacity (da + ba)
# -Number of bikes (da)
# -Name (s)
station = Station((s['lo'], s['la']), s['da'] + s['ba'],\
s['da'], s['s'])
stations[s['n']] = station
return stations
def create_rides(rides_file: str,
stations: Dict[str, 'Station']) -> List['Ride']:
"""Return the rides described in the given CSV file.
Lookup the station ids contained in the rides file in <stations>
to access the corresponding Station objects.
Ignore any ride whose start or end station is not present in <stations>.
Precondition: rides_file matches the format specified in the
assignment handout.
"""
rides = []
with open(rides_file) as file:
for line in csv.reader(file):
# line is a list of strings, following the format described
# in the assignment handout.
#
# Convert between a string and a datetime object
# using the function datetime.strptime and the DATETIME_FORMAT
# constant we defined above. Example:
# >>> datetime.strptime('2017-06-01 8:00', DATETIME_FORMAT)
# datetime.datetime(2017, 6, 1, 8, 0)
# CSV Columns:
# -Start time [0]
# -Start station code [1]
# -End time [2]
# -End station code [3]
# -ignore the rest [4,5]
# Ride class inputs:
# -Start station (Station())
# -End station (Station())
# -Times (Tuple(start,end))
start_station_code = line[1]
end_station_code = line[3]
# First check whether the stations from the ride are present in the
# stations registry
if start_station_code and end_station_code in stations:
start_time = datetime.strptime(line[0], DATETIME_FORMAT)
end_time = datetime.strptime(line[2], DATETIME_FORMAT)
start_station = stations[start_station_code]
end_station = stations[end_station_code]
ride = Ride(start_station, end_station, (start_time, end_time))
rides.append(ride)
return rides
class Event:
"""An event in the bike share simulation.
Events are ordered by their timestamp.
"""
simulation: 'Simulation'
time: datetime
def __init__(self, simulation: 'Simulation', time: datetime) -> None:
"""Initialize a new event."""
self.simulation = simulation
self.time = time
def __lt__(self, other: 'Event') -> bool:
"""Return whether this event is less than <other>.
Events are ordered by their timestamp.
"""
return self.time < other.time
def process(self) -> List['Event']:
"""Process this event by updating the state of the simulation.
Return a list of new events spawned by this event.
"""
raise NotImplementedError
class RideStartEvent(Event):
"""An event corresponding to the start of a ride."""
pass
class RideEndEvent(Event):
"""An event corresponding to the start of a ride."""
pass
def sample_simulation() -> Dict[str, Tuple[str, float]]:
"""Run a sample simulation. For testing purposes only."""
sim = Simulation('stations.json', 'sample_rides.csv')
sim.run(datetime(2017, 6, 1, 8, 0, 0),
datetime(2017, 6, 1, 9, 0, 0))
return sim.calculate_statistics()
if __name__ == '__main__':
# Uncomment these lines when you want to check your work using python_ta!
# import python_ta
# python_ta.check_all(config={
# 'allowed-io': ['create_stations', 'create_rides'],
# 'allowed-import-modules': [
# 'doctest', 'python_ta', 'typing',
# 'csv', 'datetime', 'json',
# 'bikeshare', 'container', 'visualizer'
# ]
# })
print(sample_simulation()) | 'max_start': ('', -1), | random_line_split |
simulation.py | """Assignment 1 - Simulation
=== CSC148 Fall 2017 ===
Diane Horton and David Liu
Department of Computer Science,
University of Toronto
=== Module Description ===
This file contains the Simulation class, which is the main class for your
bike-share simulation.
At the bottom of the file, there is a sample_simulation function that you
can use to try running the simulation at any time.
"""
import csv
from datetime import datetime, timedelta
import json
from typing import Dict, List, Tuple
from bikeshare import Ride, Station
from container import PriorityQueue
from visualizer import Visualizer
# Datetime format to parse the ride data
DATETIME_FORMAT = '%Y-%m-%d %H:%M'
#Function constants for reporting beggining and ending of rides
RIDE_BEGUN = True
RIDE_FINISHED = False
# Stock issues report
SUCCESSFUL_REPORT = 0
EMPTY_STATION_ISSUE = 1
FULL_STATION_ISSUE = 2
class Simulation:
"""Runs the core of the simulation through time.
=== Attributes ===
all_rides:
A list of all the rides in this simulation.
Note that not all rides might be used, depending on the timeframe
when the simulation is run.
all_stations:
A dictionary containing all the stations in this simulation.
visualizer:
A helper class for visualizing the simulation.
active_rides:
All rides that are active during simulation
"""
all_stations: Dict[str, Station]
all_rides: List[Ride]
visualizer: Visualizer
active_rides: List[Ride]
def __init__(self, station_file: str, ride_file: str) -> None:
"""Initialize this simulation with the given configuration settings.
"""
self.all_stations = create_stations(station_file)
self.all_rides = create_rides(ride_file, self.all_stations)
self.visualizer = Visualizer()
self.active_rides = []
def run(self, start: datetime, end: datetime) -> None:
"""Run the simulation from <start> to <end>.
"""
step = timedelta(minutes=1) # Each iteration spans one minute of time
current_time = start
while current_time <= end:
self._update_active_rides(current_time)
# Method that draws all stations and bikes on the map
self.visualizer.render_drawables(list(self.all_stations.values())\
+ self.active_rides, current_time)
current_time += step
# Leave this code at the very bottom of this method.
# It will keep the visualization window open until you close
# it by pressing the 'X'.
while True:
|
def _update_active_rides(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- Loop through `self.all_rides` and compare each Ride's start and
end times with <time>.
If <time> is between the ride's start and end times (inclusive),
then add the ride to self.active_rides if it isn't already in
that list.
Otherwise, remove the ride from self.active_rides if it is in
that list.
- This means that if a ride started before the simulation's time
period but ends during or after the simulation's time period,
it should still be added to self.active_rides.
"""
for ride in self.all_rides:
# Check whether the current time is between start and end
if time > ride.start_time and time < ride.end_time:
# Check whether it is already in the active rides list
if not ride in self.active_rides:
# Reports that this ride has just begun
# this method will also lead to an update on station's bike
# number.
if ride.report_status(RIDE_BEGUN, time) \
== SUCCESSFUL_REPORT:
# Adds to the active rides list if no anomaly was
# detected
self.active_rides.append(ride)
else:
if ride in self.active_rides:
# Reports that this ride has finished
# this method will also lead to an update on station's bike
# number
ride.report_status(RIDE_FINISHED, time)
# If a finished or not yet beginned ride is in this
# list, removes it.
self.active_rides.remove(ride)
def calculate_statistics(self) -> Dict[str, Tuple[str, float]]:
"""Return a dictionary containing statistics for this simulation.
The returned dictionary has exactly four keys, corresponding
to the four statistics tracked for each station:
- 'max_start'
- 'max_end'
- 'max_time_low_availability'
- 'max_time_low_unoccupied'
The corresponding value of each key is a tuple of two elements,
where the first element is the name (NOT id) of the station that has
the maximum value of the quantity specified by that key,
and the second element is the value of that quantity.
For example, the value corresponding to key 'max_start' should be the
name of the station with the most number of rides started at that
station, and the number of rides that started at that station.
"""
tempDict = {
'max_start': ('', -1),
'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
}
return {
'max_start': ('', -1),
'max_end': ('', -1),
'max_time_low_availability': ('', -1),
'max_time_low_unoccupied': ('', -1)
}
def _update_active_rides_fast(self, time: datetime) -> None:
"""Update this simulation's list of active rides for the given time.
REQUIRED IMPLEMENTATION NOTES:
- see Task 5 of the assignment handout
"""
pass
def create_stations(stations_file: str) -> Dict[str, 'Station']:
"""Return the stations described in the given JSON data file.
Each key in the returned dictionary is a station id,
and each value is the corresponding Station object.
Note that you need to call Station(...) to create these objects!
Precondition: stations_file matches the format specified in the
assignment handout.
This function should be called *before* _read_rides because the
rides CSV file refers to station ids.
"""
# Read in raw data using the json library.
with open(stations_file) as file:
raw_stations = json.load(file)
stations = {}
for s in raw_stations['stations']:
# Extract the relevant fields from the raw station JSON.
# s is a dictionary with the keys 'n', 's', 'la', 'lo', 'da', and 'ba'
# as described in the assignment handout.
# NOTE: all of the corresponding values are strings, and so you need
# to convert some of them to numbers explicitly using int() or float().
# Inputs for Station Class (with keys from dictionary) :
# -Lon/Lat (lo/la)
# -Capacity (da + ba)
# -Number of bikes (da)
# -Name (s)
station = Station((s['lo'], s['la']), s['da'] + s['ba'],\
s['da'], s['s'])
stations[s['n']] = station
return stations
def create_rides(rides_file: str,
stations: Dict[str, 'Station']) -> List['Ride']:
"""Return the rides described in the given CSV file.
Lookup the station ids contained in the rides file in <stations>
to access the corresponding Station objects.
Ignore any ride whose start or end station is not present in <stations>.
Precondition: rides_file matches the format specified in the
assignment handout.
"""
rides = []
with open(rides_file) as file:
for line in csv.reader(file):
# line is a list of strings, following the format described
# in the assignment handout.
#
# Convert between a string and a datetime object
# using the function datetime.strptime and the DATETIME_FORMAT
# constant we defined above. Example:
# >>> datetime.strptime('2017-06-01 8:00', DATETIME_FORMAT)
# datetime.datetime(2017, 6, 1, 8, 0)
# CSV Columns:
# -Start time [0]
# -Start station code [1]
# -End time [2]
# -End station code [3]
# -ignore the rest [4,5]
# Ride class inputs:
# -Start station (Station())
# -End station (Station())
# -Times (Tuple(start,end))
start_station_code = line[1]
end_station_code = line[3]
# First check whether the stations from the ride are present in the
# stations registry
if start_station_code and end_station_code in stations:
start_time = datetime.strptime(line[0], DATETIME_FORMAT)
end_time = datetime.strptime(line[2], DATETIME_FORMAT)
start_station = stations[start_station_code]
end_station = stations[end_station_code]
ride = Ride(start_station, end_station, (start_time, end_time))
rides.append(ride)
return rides
class Event:
"""An event in the bike share simulation.
Events are ordered by their timestamp.
"""
simulation: 'Simulation'
time: datetime
def __init__(self, simulation: 'Simulation', time: datetime) -> None:
"""Initialize a new event."""
self.simulation = simulation
self.time = time
def __lt__(self, other: 'Event') -> bool:
"""Return whether this event is less than <other>.
Events are ordered by their timestamp.
"""
return self.time < other.time
def process(self) -> List['Event']:
"""Process this event by updating the state of the simulation.
Return a list of new events spawned by this event.
"""
raise NotImplementedError
class RideStartEvent(Event):
"""An event corresponding to the start of a ride."""
pass
class RideEndEvent(Event):
"""An event corresponding to the start of a ride."""
pass
def sample_simulation() -> Dict[str, Tuple[str, float]]:
"""Run a sample simulation. For testing purposes only."""
sim = Simulation('stations.json', 'sample_rides.csv')
sim.run(datetime(2017, 6, 1, 8, 0, 0),
datetime(2017, 6, 1, 9, 0, 0))
return sim.calculate_statistics()
if __name__ == '__main__':
# Uncomment these lines when you want to check your work using python_ta!
# import python_ta
# python_ta.check_all(config={
# 'allowed-io': ['create_stations', 'create_rides'],
# 'allowed-import-modules': [
# 'doctest', 'python_ta', 'typing',
# 'csv', 'datetime', 'json',
# 'bikeshare', 'container', 'visualizer'
# ]
# })
print(sample_simulation())
| if self.visualizer.handle_window_events():
return # Stop the simulation | conditional_block |
conn.rs | // Copyright 2016 The Grin Developers
//
// 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.
//! Provides a connection wrapper that handles the lower level tasks in sending
//! or receiving data from the TCP socket, as well as dealing with timeouts.
use std::iter;
use std::ops::Deref;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use futures;
use futures::{Future, Stream};
use futures::stream;
use futures::sync::mpsc::{Sender, UnboundedReceiver, UnboundedSender};
use tokio_core::net::TcpStream;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_io::io::{read_exact, write_all};
use tokio_timer::{Timer, TimerError};
use core::core::hash::Hash;
use core::ser;
use msg::*;
use types::Error;
use rate_limit::*;
use util::LOGGER;
/// Handler to provide to the connection, will be called back anytime a message
/// is received. The provided sender can be use to immediately send back
/// another message.
pub trait Handler: Sync + Send {
/// Handle function to implement to process incoming messages. A sender to
/// reply immediately as well as the message header and its unparsed body
/// are provided.
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error>;
}
impl<F> Handler for F
where
F: Fn(UnboundedSender<Vec<u8>>, MsgHeader, Vec<u8>)
-> Result<Option<Hash>, ser::Error>,
F: Sync + Send,
{
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error> {
self(sender, header, body)
}
}
/// A higher level connection wrapping the TcpStream. Maintains the amount of
/// data transmitted and deals with the low-level task of sending and
/// receiving data, parsing message headers and timeouts.
#[allow(dead_code)]
pub struct Connection {
// Channel to push bytes to the remote peer
outbound_chan: UnboundedSender<Vec<u8>>,
// Close the connection with the remote peer
close_chan: Sender<()>,
// Bytes we've sent.
sent_bytes: Arc<Mutex<u64>>,
// Bytes we've received.
received_bytes: Arc<Mutex<u64>>,
// Counter for read errors.
error_count: Mutex<u64>,
}
impl Connection {
/// Start listening on the provided connection and wraps it. Does not hang
/// the current thread, instead just returns a future and the Connection
/// itself.
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (Connection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let (reader, writer) = conn.split();
// Set Max Read to 12 Mb/s
let reader = ThrottledReader::new(reader, 12_000_000);
// Set Max Write to 12 Mb/s
let writer = ThrottledWriter::new(writer, 12_000_000);
// prepare the channel that will transmit data to the connection writer
let (tx, rx) = futures::sync::mpsc::unbounded();
// same for closing the connection
let (close_tx, close_rx) = futures::sync::mpsc::channel(1);
let close_conn = close_rx
.for_each(|_| Ok(()))
.map_err(|_| Error::ConnectionClose);
let me = Connection {
outbound_chan: tx.clone(),
close_chan: close_tx,
sent_bytes: Arc::new(Mutex::new(0)),
received_bytes: Arc::new(Mutex::new(0)),
error_count: Mutex::new(0),
};
// setup the reading future, getting messages from the peer and processing them
let read_msg = me.read_msg(tx, reader, handler).map(|_| ());
// setting the writing future, getting messages from our system and sending
// them out
let write_msg = me.write_msg(rx, writer).map(|_| ());
// select between our different futures and return them
let fut = Box::new(
close_conn
.select(read_msg.select(write_msg).map(|_| ()).map_err(|(e, _)| e))
.map(|_| ())
.map_err(|(e, _)| e),
);
(me, fut)
}
/// Prepares the future that gets message data produced by our system and
/// sends it to the peer connection
fn write_msg<W>(
&self,
rx: UnboundedReceiver<Vec<u8>>,
writer: W,
) -> Box<Future<Item = W, Error = Error>>
where
W: AsyncWrite + 'static,
{
let sent_bytes = self.sent_bytes.clone();
let send_data = rx
.map_err(|_| Error::ConnectionClose)
.map(move |data| {
// add the count of bytes sent
let mut sent_bytes = sent_bytes.lock().unwrap();
*sent_bytes += data.len() as u64;
data
})
// write the data and make sure the future returns the right types
.fold(writer, |writer, data| {
write_all(writer, data).map_err(|e| Error::Connection(e)).map(|(writer, _)| writer)
});
Box::new(send_data)
}
/// Prepares the future reading from the peer connection, parsing each
/// message and forwarding them appropriately based on their type
fn read_msg<F, R>(
&self,
sender: UnboundedSender<Vec<u8>>,
reader: R,
handler: F,
) -> Box<Future<Item = R, Error = Error>>
where
F: Handler + 'static,
R: AsyncRead + 'static,
{
// infinite iterator stream so we repeat the message reading logic until the
// peer is stopped
let iter = stream::iter_ok(iter::repeat(()).map(Ok::<(), Error>));
// setup the reading future, getting messages from the peer and processing them
let recv_bytes = self.received_bytes.clone();
let handler = Arc::new(handler);
let read_msg = iter.fold(reader, move |reader, _| {
let recv_bytes = recv_bytes.clone();
let handler = handler.clone();
let sender_inner = sender.clone();
// first read the message header
read_exact(reader, vec![0u8; HEADER_LEN as usize])
.from_err()
.and_then(move |(reader, buf)| {
let header = try!(ser::deserialize::<MsgHeader>(&mut &buf[..]));
Ok((reader, header))
})
.and_then(move |(reader, header)| {
// now that we have a size, proceed with the body
read_exact(reader, vec![0u8; header.msg_len as usize])
.map(|(reader, buf)| (reader, header, buf))
.from_err()
})
.and_then(move |(reader, header, buf)| {
// add the count of bytes received
let mut recv_bytes = recv_bytes.lock().unwrap();
*recv_bytes += header.serialized_len() + header.msg_len;
// and handle the different message types
let msg_type = header.msg_type;
if let Err(e) = handler.handle(sender_inner.clone(), header, buf) {
debug!(LOGGER, "Invalid {:?} message: {}", msg_type, e);
return Err(Error::Serialization(e));
}
Ok(reader)
})
});
Box::new(read_msg)
}
/// Utility function to send any Writeable. Handles adding the header and
/// serialization.
pub fn | <W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
let mut body_data = vec![];
try!(ser::serialize(&mut body_data, body));
let mut data = vec![];
try!(ser::serialize(
&mut data,
&MsgHeader::new(t, body_data.len() as u64),
));
data.append(&mut body_data);
self.outbound_chan
.unbounded_send(data)
.map_err(|_| Error::ConnectionClose)
}
/// Bytes sent and received by this peer to the remote peer.
pub fn transmitted_bytes(&self) -> (u64, u64) {
let sent = *self.sent_bytes.lock().unwrap();
let recv = *self.received_bytes.lock().unwrap();
(sent, recv)
}
}
/// Connection wrapper that handles a request/response oriented interaction with
/// a timeout.
pub struct TimeoutConnection {
underlying: Connection,
expected_responses: Arc<Mutex<Vec<(Type, Option<Hash>, Instant)>>>,
}
impl TimeoutConnection {
/// Same as Connection
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (TimeoutConnection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let expects = Arc::new(Mutex::new(vec![]));
// Decorates the handler to remove the "subscription" from the expected
// responses. We got our replies, so no timeout should occur.
let exp = expects.clone();
let (conn, fut) = Connection::listen(conn, move |sender, header: MsgHeader, data| {
let msg_type = header.msg_type;
let recv_h = try!(handler.handle(sender, header, data));
let mut expects = exp.lock().unwrap();
let filtered = expects
.iter()
.filter(|&&(typ, h, _): &&(Type, Option<Hash>, Instant)| {
msg_type != typ || h.is_some() && recv_h != h
})
.map(|&x| x)
.collect::<Vec<_>>();
*expects = filtered;
Ok(recv_h)
});
// Registers a timer with the event loop to regularly check for timeouts.
let exp = expects.clone();
let timer = Timer::default()
.interval(Duration::new(2, 0))
.fold((), move |_, _| {
let exp = exp.lock().unwrap();
for &(ty, h, t) in exp.deref() {
if Instant::now() - t > Duration::new(5, 0) {
trace!(LOGGER, "Too long: {:?} {:?}", ty, h);
return Err(TimerError::TooLong);
}
}
Ok(())
})
.from_err();
let me = TimeoutConnection {
underlying: conn,
expected_responses: expects,
};
(
me,
Box::new(fut.select(timer).map(|_| ()).map_err(|(e1, _)| e1)),
)
}
/// Sends a request and registers a timer on the provided message type and
/// optionally the hash of the sent data.
pub fn send_request<W: ser::Writeable>(
&self,
t: Type,
rt: Type,
body: &W,
expect_h: Option<(Hash)>,
) -> Result<(), Error> {
let _sent = try!(self.underlying.send_msg(t, body));
let mut expects = self.expected_responses.lock().unwrap();
expects.push((rt, expect_h, Instant::now()));
Ok(())
}
/// Same as Connection
pub fn send_msg<W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
self.underlying.send_msg(t, body)
}
/// Same as Connection
pub fn transmitted_bytes(&self) -> (u64, u64) {
self.underlying.transmitted_bytes()
}
}
| send_msg | identifier_name |
conn.rs | // Copyright 2016 The Grin Developers
//
// 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.
//! Provides a connection wrapper that handles the lower level tasks in sending
//! or receiving data from the TCP socket, as well as dealing with timeouts.
use std::iter;
use std::ops::Deref;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use futures;
use futures::{Future, Stream};
use futures::stream;
use futures::sync::mpsc::{Sender, UnboundedReceiver, UnboundedSender};
use tokio_core::net::TcpStream;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_io::io::{read_exact, write_all};
use tokio_timer::{Timer, TimerError};
use core::core::hash::Hash;
use core::ser;
use msg::*;
use types::Error;
use rate_limit::*;
use util::LOGGER;
/// Handler to provide to the connection, will be called back anytime a message
/// is received. The provided sender can be use to immediately send back
/// another message.
pub trait Handler: Sync + Send {
/// Handle function to implement to process incoming messages. A sender to
/// reply immediately as well as the message header and its unparsed body
/// are provided.
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error>;
}
impl<F> Handler for F
where
F: Fn(UnboundedSender<Vec<u8>>, MsgHeader, Vec<u8>)
-> Result<Option<Hash>, ser::Error>,
F: Sync + Send,
{
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error> {
self(sender, header, body)
}
}
/// A higher level connection wrapping the TcpStream. Maintains the amount of
/// data transmitted and deals with the low-level task of sending and
/// receiving data, parsing message headers and timeouts.
#[allow(dead_code)]
pub struct Connection {
// Channel to push bytes to the remote peer
outbound_chan: UnboundedSender<Vec<u8>>,
// Close the connection with the remote peer
close_chan: Sender<()>,
// Bytes we've sent.
sent_bytes: Arc<Mutex<u64>>,
// Bytes we've received.
received_bytes: Arc<Mutex<u64>>,
// Counter for read errors.
error_count: Mutex<u64>,
}
impl Connection {
/// Start listening on the provided connection and wraps it. Does not hang
/// the current thread, instead just returns a future and the Connection
/// itself.
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (Connection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let (reader, writer) = conn.split();
// Set Max Read to 12 Mb/s
let reader = ThrottledReader::new(reader, 12_000_000);
// Set Max Write to 12 Mb/s
let writer = ThrottledWriter::new(writer, 12_000_000);
// prepare the channel that will transmit data to the connection writer
let (tx, rx) = futures::sync::mpsc::unbounded();
// same for closing the connection
let (close_tx, close_rx) = futures::sync::mpsc::channel(1);
let close_conn = close_rx
.for_each(|_| Ok(()))
.map_err(|_| Error::ConnectionClose);
let me = Connection {
outbound_chan: tx.clone(),
close_chan: close_tx,
sent_bytes: Arc::new(Mutex::new(0)),
received_bytes: Arc::new(Mutex::new(0)),
error_count: Mutex::new(0),
};
// setup the reading future, getting messages from the peer and processing them
let read_msg = me.read_msg(tx, reader, handler).map(|_| ());
// setting the writing future, getting messages from our system and sending
// them out
let write_msg = me.write_msg(rx, writer).map(|_| ());
// select between our different futures and return them
let fut = Box::new(
close_conn
.select(read_msg.select(write_msg).map(|_| ()).map_err(|(e, _)| e))
.map(|_| ())
.map_err(|(e, _)| e),
);
(me, fut)
}
/// Prepares the future that gets message data produced by our system and
/// sends it to the peer connection
fn write_msg<W>(
&self,
rx: UnboundedReceiver<Vec<u8>>,
writer: W,
) -> Box<Future<Item = W, Error = Error>>
where
W: AsyncWrite + 'static,
{
let sent_bytes = self.sent_bytes.clone();
let send_data = rx
.map_err(|_| Error::ConnectionClose)
.map(move |data| {
// add the count of bytes sent
let mut sent_bytes = sent_bytes.lock().unwrap();
*sent_bytes += data.len() as u64;
data
})
// write the data and make sure the future returns the right types
.fold(writer, |writer, data| {
write_all(writer, data).map_err(|e| Error::Connection(e)).map(|(writer, _)| writer)
});
Box::new(send_data)
}
/// Prepares the future reading from the peer connection, parsing each
/// message and forwarding them appropriately based on their type
fn read_msg<F, R>(
&self,
sender: UnboundedSender<Vec<u8>>,
reader: R,
handler: F,
) -> Box<Future<Item = R, Error = Error>>
where
F: Handler + 'static,
R: AsyncRead + 'static,
{
// infinite iterator stream so we repeat the message reading logic until the
// peer is stopped
let iter = stream::iter_ok(iter::repeat(()).map(Ok::<(), Error>));
// setup the reading future, getting messages from the peer and processing them
let recv_bytes = self.received_bytes.clone();
let handler = Arc::new(handler);
let read_msg = iter.fold(reader, move |reader, _| {
let recv_bytes = recv_bytes.clone();
let handler = handler.clone();
let sender_inner = sender.clone();
// first read the message header
read_exact(reader, vec![0u8; HEADER_LEN as usize])
.from_err()
.and_then(move |(reader, buf)| {
let header = try!(ser::deserialize::<MsgHeader>(&mut &buf[..]));
Ok((reader, header))
})
.and_then(move |(reader, header)| {
// now that we have a size, proceed with the body
read_exact(reader, vec![0u8; header.msg_len as usize])
.map(|(reader, buf)| (reader, header, buf))
.from_err()
})
.and_then(move |(reader, header, buf)| {
// add the count of bytes received
let mut recv_bytes = recv_bytes.lock().unwrap();
*recv_bytes += header.serialized_len() + header.msg_len;
// and handle the different message types
let msg_type = header.msg_type;
if let Err(e) = handler.handle(sender_inner.clone(), header, buf) {
debug!(LOGGER, "Invalid {:?} message: {}", msg_type, e);
return Err(Error::Serialization(e));
}
Ok(reader)
})
});
Box::new(read_msg)
}
/// Utility function to send any Writeable. Handles adding the header and
/// serialization.
pub fn send_msg<W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
let mut body_data = vec![];
try!(ser::serialize(&mut body_data, body));
let mut data = vec![];
try!(ser::serialize(
&mut data,
&MsgHeader::new(t, body_data.len() as u64),
));
data.append(&mut body_data);
self.outbound_chan
.unbounded_send(data)
.map_err(|_| Error::ConnectionClose)
}
/// Bytes sent and received by this peer to the remote peer.
pub fn transmitted_bytes(&self) -> (u64, u64) {
let sent = *self.sent_bytes.lock().unwrap();
let recv = *self.received_bytes.lock().unwrap();
(sent, recv)
}
}
/// Connection wrapper that handles a request/response oriented interaction with
/// a timeout.
pub struct TimeoutConnection {
underlying: Connection,
expected_responses: Arc<Mutex<Vec<(Type, Option<Hash>, Instant)>>>,
}
impl TimeoutConnection {
/// Same as Connection
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (TimeoutConnection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let expects = Arc::new(Mutex::new(vec![]));
| let (conn, fut) = Connection::listen(conn, move |sender, header: MsgHeader, data| {
let msg_type = header.msg_type;
let recv_h = try!(handler.handle(sender, header, data));
let mut expects = exp.lock().unwrap();
let filtered = expects
.iter()
.filter(|&&(typ, h, _): &&(Type, Option<Hash>, Instant)| {
msg_type != typ || h.is_some() && recv_h != h
})
.map(|&x| x)
.collect::<Vec<_>>();
*expects = filtered;
Ok(recv_h)
});
// Registers a timer with the event loop to regularly check for timeouts.
let exp = expects.clone();
let timer = Timer::default()
.interval(Duration::new(2, 0))
.fold((), move |_, _| {
let exp = exp.lock().unwrap();
for &(ty, h, t) in exp.deref() {
if Instant::now() - t > Duration::new(5, 0) {
trace!(LOGGER, "Too long: {:?} {:?}", ty, h);
return Err(TimerError::TooLong);
}
}
Ok(())
})
.from_err();
let me = TimeoutConnection {
underlying: conn,
expected_responses: expects,
};
(
me,
Box::new(fut.select(timer).map(|_| ()).map_err(|(e1, _)| e1)),
)
}
/// Sends a request and registers a timer on the provided message type and
/// optionally the hash of the sent data.
pub fn send_request<W: ser::Writeable>(
&self,
t: Type,
rt: Type,
body: &W,
expect_h: Option<(Hash)>,
) -> Result<(), Error> {
let _sent = try!(self.underlying.send_msg(t, body));
let mut expects = self.expected_responses.lock().unwrap();
expects.push((rt, expect_h, Instant::now()));
Ok(())
}
/// Same as Connection
pub fn send_msg<W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
self.underlying.send_msg(t, body)
}
/// Same as Connection
pub fn transmitted_bytes(&self) -> (u64, u64) {
self.underlying.transmitted_bytes()
}
} | // Decorates the handler to remove the "subscription" from the expected
// responses. We got our replies, so no timeout should occur.
let exp = expects.clone(); | random_line_split |
conn.rs | // Copyright 2016 The Grin Developers
//
// 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.
//! Provides a connection wrapper that handles the lower level tasks in sending
//! or receiving data from the TCP socket, as well as dealing with timeouts.
use std::iter;
use std::ops::Deref;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use futures;
use futures::{Future, Stream};
use futures::stream;
use futures::sync::mpsc::{Sender, UnboundedReceiver, UnboundedSender};
use tokio_core::net::TcpStream;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_io::io::{read_exact, write_all};
use tokio_timer::{Timer, TimerError};
use core::core::hash::Hash;
use core::ser;
use msg::*;
use types::Error;
use rate_limit::*;
use util::LOGGER;
/// Handler to provide to the connection, will be called back anytime a message
/// is received. The provided sender can be use to immediately send back
/// another message.
pub trait Handler: Sync + Send {
/// Handle function to implement to process incoming messages. A sender to
/// reply immediately as well as the message header and its unparsed body
/// are provided.
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error>;
}
impl<F> Handler for F
where
F: Fn(UnboundedSender<Vec<u8>>, MsgHeader, Vec<u8>)
-> Result<Option<Hash>, ser::Error>,
F: Sync + Send,
{
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error> |
}
/// A higher level connection wrapping the TcpStream. Maintains the amount of
/// data transmitted and deals with the low-level task of sending and
/// receiving data, parsing message headers and timeouts.
#[allow(dead_code)]
pub struct Connection {
// Channel to push bytes to the remote peer
outbound_chan: UnboundedSender<Vec<u8>>,
// Close the connection with the remote peer
close_chan: Sender<()>,
// Bytes we've sent.
sent_bytes: Arc<Mutex<u64>>,
// Bytes we've received.
received_bytes: Arc<Mutex<u64>>,
// Counter for read errors.
error_count: Mutex<u64>,
}
impl Connection {
/// Start listening on the provided connection and wraps it. Does not hang
/// the current thread, instead just returns a future and the Connection
/// itself.
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (Connection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let (reader, writer) = conn.split();
// Set Max Read to 12 Mb/s
let reader = ThrottledReader::new(reader, 12_000_000);
// Set Max Write to 12 Mb/s
let writer = ThrottledWriter::new(writer, 12_000_000);
// prepare the channel that will transmit data to the connection writer
let (tx, rx) = futures::sync::mpsc::unbounded();
// same for closing the connection
let (close_tx, close_rx) = futures::sync::mpsc::channel(1);
let close_conn = close_rx
.for_each(|_| Ok(()))
.map_err(|_| Error::ConnectionClose);
let me = Connection {
outbound_chan: tx.clone(),
close_chan: close_tx,
sent_bytes: Arc::new(Mutex::new(0)),
received_bytes: Arc::new(Mutex::new(0)),
error_count: Mutex::new(0),
};
// setup the reading future, getting messages from the peer and processing them
let read_msg = me.read_msg(tx, reader, handler).map(|_| ());
// setting the writing future, getting messages from our system and sending
// them out
let write_msg = me.write_msg(rx, writer).map(|_| ());
// select between our different futures and return them
let fut = Box::new(
close_conn
.select(read_msg.select(write_msg).map(|_| ()).map_err(|(e, _)| e))
.map(|_| ())
.map_err(|(e, _)| e),
);
(me, fut)
}
/// Prepares the future that gets message data produced by our system and
/// sends it to the peer connection
fn write_msg<W>(
&self,
rx: UnboundedReceiver<Vec<u8>>,
writer: W,
) -> Box<Future<Item = W, Error = Error>>
where
W: AsyncWrite + 'static,
{
let sent_bytes = self.sent_bytes.clone();
let send_data = rx
.map_err(|_| Error::ConnectionClose)
.map(move |data| {
// add the count of bytes sent
let mut sent_bytes = sent_bytes.lock().unwrap();
*sent_bytes += data.len() as u64;
data
})
// write the data and make sure the future returns the right types
.fold(writer, |writer, data| {
write_all(writer, data).map_err(|e| Error::Connection(e)).map(|(writer, _)| writer)
});
Box::new(send_data)
}
/// Prepares the future reading from the peer connection, parsing each
/// message and forwarding them appropriately based on their type
fn read_msg<F, R>(
&self,
sender: UnboundedSender<Vec<u8>>,
reader: R,
handler: F,
) -> Box<Future<Item = R, Error = Error>>
where
F: Handler + 'static,
R: AsyncRead + 'static,
{
// infinite iterator stream so we repeat the message reading logic until the
// peer is stopped
let iter = stream::iter_ok(iter::repeat(()).map(Ok::<(), Error>));
// setup the reading future, getting messages from the peer and processing them
let recv_bytes = self.received_bytes.clone();
let handler = Arc::new(handler);
let read_msg = iter.fold(reader, move |reader, _| {
let recv_bytes = recv_bytes.clone();
let handler = handler.clone();
let sender_inner = sender.clone();
// first read the message header
read_exact(reader, vec![0u8; HEADER_LEN as usize])
.from_err()
.and_then(move |(reader, buf)| {
let header = try!(ser::deserialize::<MsgHeader>(&mut &buf[..]));
Ok((reader, header))
})
.and_then(move |(reader, header)| {
// now that we have a size, proceed with the body
read_exact(reader, vec![0u8; header.msg_len as usize])
.map(|(reader, buf)| (reader, header, buf))
.from_err()
})
.and_then(move |(reader, header, buf)| {
// add the count of bytes received
let mut recv_bytes = recv_bytes.lock().unwrap();
*recv_bytes += header.serialized_len() + header.msg_len;
// and handle the different message types
let msg_type = header.msg_type;
if let Err(e) = handler.handle(sender_inner.clone(), header, buf) {
debug!(LOGGER, "Invalid {:?} message: {}", msg_type, e);
return Err(Error::Serialization(e));
}
Ok(reader)
})
});
Box::new(read_msg)
}
/// Utility function to send any Writeable. Handles adding the header and
/// serialization.
pub fn send_msg<W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
let mut body_data = vec![];
try!(ser::serialize(&mut body_data, body));
let mut data = vec![];
try!(ser::serialize(
&mut data,
&MsgHeader::new(t, body_data.len() as u64),
));
data.append(&mut body_data);
self.outbound_chan
.unbounded_send(data)
.map_err(|_| Error::ConnectionClose)
}
/// Bytes sent and received by this peer to the remote peer.
pub fn transmitted_bytes(&self) -> (u64, u64) {
let sent = *self.sent_bytes.lock().unwrap();
let recv = *self.received_bytes.lock().unwrap();
(sent, recv)
}
}
/// Connection wrapper that handles a request/response oriented interaction with
/// a timeout.
pub struct TimeoutConnection {
underlying: Connection,
expected_responses: Arc<Mutex<Vec<(Type, Option<Hash>, Instant)>>>,
}
impl TimeoutConnection {
/// Same as Connection
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (TimeoutConnection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let expects = Arc::new(Mutex::new(vec![]));
// Decorates the handler to remove the "subscription" from the expected
// responses. We got our replies, so no timeout should occur.
let exp = expects.clone();
let (conn, fut) = Connection::listen(conn, move |sender, header: MsgHeader, data| {
let msg_type = header.msg_type;
let recv_h = try!(handler.handle(sender, header, data));
let mut expects = exp.lock().unwrap();
let filtered = expects
.iter()
.filter(|&&(typ, h, _): &&(Type, Option<Hash>, Instant)| {
msg_type != typ || h.is_some() && recv_h != h
})
.map(|&x| x)
.collect::<Vec<_>>();
*expects = filtered;
Ok(recv_h)
});
// Registers a timer with the event loop to regularly check for timeouts.
let exp = expects.clone();
let timer = Timer::default()
.interval(Duration::new(2, 0))
.fold((), move |_, _| {
let exp = exp.lock().unwrap();
for &(ty, h, t) in exp.deref() {
if Instant::now() - t > Duration::new(5, 0) {
trace!(LOGGER, "Too long: {:?} {:?}", ty, h);
return Err(TimerError::TooLong);
}
}
Ok(())
})
.from_err();
let me = TimeoutConnection {
underlying: conn,
expected_responses: expects,
};
(
me,
Box::new(fut.select(timer).map(|_| ()).map_err(|(e1, _)| e1)),
)
}
/// Sends a request and registers a timer on the provided message type and
/// optionally the hash of the sent data.
pub fn send_request<W: ser::Writeable>(
&self,
t: Type,
rt: Type,
body: &W,
expect_h: Option<(Hash)>,
) -> Result<(), Error> {
let _sent = try!(self.underlying.send_msg(t, body));
let mut expects = self.expected_responses.lock().unwrap();
expects.push((rt, expect_h, Instant::now()));
Ok(())
}
/// Same as Connection
pub fn send_msg<W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
self.underlying.send_msg(t, body)
}
/// Same as Connection
pub fn transmitted_bytes(&self) -> (u64, u64) {
self.underlying.transmitted_bytes()
}
}
| {
self(sender, header, body)
} | identifier_body |
conn.rs | // Copyright 2016 The Grin Developers
//
// 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.
//! Provides a connection wrapper that handles the lower level tasks in sending
//! or receiving data from the TCP socket, as well as dealing with timeouts.
use std::iter;
use std::ops::Deref;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use futures;
use futures::{Future, Stream};
use futures::stream;
use futures::sync::mpsc::{Sender, UnboundedReceiver, UnboundedSender};
use tokio_core::net::TcpStream;
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_io::io::{read_exact, write_all};
use tokio_timer::{Timer, TimerError};
use core::core::hash::Hash;
use core::ser;
use msg::*;
use types::Error;
use rate_limit::*;
use util::LOGGER;
/// Handler to provide to the connection, will be called back anytime a message
/// is received. The provided sender can be use to immediately send back
/// another message.
pub trait Handler: Sync + Send {
/// Handle function to implement to process incoming messages. A sender to
/// reply immediately as well as the message header and its unparsed body
/// are provided.
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error>;
}
impl<F> Handler for F
where
F: Fn(UnboundedSender<Vec<u8>>, MsgHeader, Vec<u8>)
-> Result<Option<Hash>, ser::Error>,
F: Sync + Send,
{
fn handle(
&self,
sender: UnboundedSender<Vec<u8>>,
header: MsgHeader,
body: Vec<u8>,
) -> Result<Option<Hash>, ser::Error> {
self(sender, header, body)
}
}
/// A higher level connection wrapping the TcpStream. Maintains the amount of
/// data transmitted and deals with the low-level task of sending and
/// receiving data, parsing message headers and timeouts.
#[allow(dead_code)]
pub struct Connection {
// Channel to push bytes to the remote peer
outbound_chan: UnboundedSender<Vec<u8>>,
// Close the connection with the remote peer
close_chan: Sender<()>,
// Bytes we've sent.
sent_bytes: Arc<Mutex<u64>>,
// Bytes we've received.
received_bytes: Arc<Mutex<u64>>,
// Counter for read errors.
error_count: Mutex<u64>,
}
impl Connection {
/// Start listening on the provided connection and wraps it. Does not hang
/// the current thread, instead just returns a future and the Connection
/// itself.
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (Connection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let (reader, writer) = conn.split();
// Set Max Read to 12 Mb/s
let reader = ThrottledReader::new(reader, 12_000_000);
// Set Max Write to 12 Mb/s
let writer = ThrottledWriter::new(writer, 12_000_000);
// prepare the channel that will transmit data to the connection writer
let (tx, rx) = futures::sync::mpsc::unbounded();
// same for closing the connection
let (close_tx, close_rx) = futures::sync::mpsc::channel(1);
let close_conn = close_rx
.for_each(|_| Ok(()))
.map_err(|_| Error::ConnectionClose);
let me = Connection {
outbound_chan: tx.clone(),
close_chan: close_tx,
sent_bytes: Arc::new(Mutex::new(0)),
received_bytes: Arc::new(Mutex::new(0)),
error_count: Mutex::new(0),
};
// setup the reading future, getting messages from the peer and processing them
let read_msg = me.read_msg(tx, reader, handler).map(|_| ());
// setting the writing future, getting messages from our system and sending
// them out
let write_msg = me.write_msg(rx, writer).map(|_| ());
// select between our different futures and return them
let fut = Box::new(
close_conn
.select(read_msg.select(write_msg).map(|_| ()).map_err(|(e, _)| e))
.map(|_| ())
.map_err(|(e, _)| e),
);
(me, fut)
}
/// Prepares the future that gets message data produced by our system and
/// sends it to the peer connection
fn write_msg<W>(
&self,
rx: UnboundedReceiver<Vec<u8>>,
writer: W,
) -> Box<Future<Item = W, Error = Error>>
where
W: AsyncWrite + 'static,
{
let sent_bytes = self.sent_bytes.clone();
let send_data = rx
.map_err(|_| Error::ConnectionClose)
.map(move |data| {
// add the count of bytes sent
let mut sent_bytes = sent_bytes.lock().unwrap();
*sent_bytes += data.len() as u64;
data
})
// write the data and make sure the future returns the right types
.fold(writer, |writer, data| {
write_all(writer, data).map_err(|e| Error::Connection(e)).map(|(writer, _)| writer)
});
Box::new(send_data)
}
/// Prepares the future reading from the peer connection, parsing each
/// message and forwarding them appropriately based on their type
fn read_msg<F, R>(
&self,
sender: UnboundedSender<Vec<u8>>,
reader: R,
handler: F,
) -> Box<Future<Item = R, Error = Error>>
where
F: Handler + 'static,
R: AsyncRead + 'static,
{
// infinite iterator stream so we repeat the message reading logic until the
// peer is stopped
let iter = stream::iter_ok(iter::repeat(()).map(Ok::<(), Error>));
// setup the reading future, getting messages from the peer and processing them
let recv_bytes = self.received_bytes.clone();
let handler = Arc::new(handler);
let read_msg = iter.fold(reader, move |reader, _| {
let recv_bytes = recv_bytes.clone();
let handler = handler.clone();
let sender_inner = sender.clone();
// first read the message header
read_exact(reader, vec![0u8; HEADER_LEN as usize])
.from_err()
.and_then(move |(reader, buf)| {
let header = try!(ser::deserialize::<MsgHeader>(&mut &buf[..]));
Ok((reader, header))
})
.and_then(move |(reader, header)| {
// now that we have a size, proceed with the body
read_exact(reader, vec![0u8; header.msg_len as usize])
.map(|(reader, buf)| (reader, header, buf))
.from_err()
})
.and_then(move |(reader, header, buf)| {
// add the count of bytes received
let mut recv_bytes = recv_bytes.lock().unwrap();
*recv_bytes += header.serialized_len() + header.msg_len;
// and handle the different message types
let msg_type = header.msg_type;
if let Err(e) = handler.handle(sender_inner.clone(), header, buf) |
Ok(reader)
})
});
Box::new(read_msg)
}
/// Utility function to send any Writeable. Handles adding the header and
/// serialization.
pub fn send_msg<W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
let mut body_data = vec![];
try!(ser::serialize(&mut body_data, body));
let mut data = vec![];
try!(ser::serialize(
&mut data,
&MsgHeader::new(t, body_data.len() as u64),
));
data.append(&mut body_data);
self.outbound_chan
.unbounded_send(data)
.map_err(|_| Error::ConnectionClose)
}
/// Bytes sent and received by this peer to the remote peer.
pub fn transmitted_bytes(&self) -> (u64, u64) {
let sent = *self.sent_bytes.lock().unwrap();
let recv = *self.received_bytes.lock().unwrap();
(sent, recv)
}
}
/// Connection wrapper that handles a request/response oriented interaction with
/// a timeout.
pub struct TimeoutConnection {
underlying: Connection,
expected_responses: Arc<Mutex<Vec<(Type, Option<Hash>, Instant)>>>,
}
impl TimeoutConnection {
/// Same as Connection
pub fn listen<F>(
conn: TcpStream,
handler: F,
) -> (TimeoutConnection, Box<Future<Item = (), Error = Error>>)
where
F: Handler + 'static,
{
let expects = Arc::new(Mutex::new(vec![]));
// Decorates the handler to remove the "subscription" from the expected
// responses. We got our replies, so no timeout should occur.
let exp = expects.clone();
let (conn, fut) = Connection::listen(conn, move |sender, header: MsgHeader, data| {
let msg_type = header.msg_type;
let recv_h = try!(handler.handle(sender, header, data));
let mut expects = exp.lock().unwrap();
let filtered = expects
.iter()
.filter(|&&(typ, h, _): &&(Type, Option<Hash>, Instant)| {
msg_type != typ || h.is_some() && recv_h != h
})
.map(|&x| x)
.collect::<Vec<_>>();
*expects = filtered;
Ok(recv_h)
});
// Registers a timer with the event loop to regularly check for timeouts.
let exp = expects.clone();
let timer = Timer::default()
.interval(Duration::new(2, 0))
.fold((), move |_, _| {
let exp = exp.lock().unwrap();
for &(ty, h, t) in exp.deref() {
if Instant::now() - t > Duration::new(5, 0) {
trace!(LOGGER, "Too long: {:?} {:?}", ty, h);
return Err(TimerError::TooLong);
}
}
Ok(())
})
.from_err();
let me = TimeoutConnection {
underlying: conn,
expected_responses: expects,
};
(
me,
Box::new(fut.select(timer).map(|_| ()).map_err(|(e1, _)| e1)),
)
}
/// Sends a request and registers a timer on the provided message type and
/// optionally the hash of the sent data.
pub fn send_request<W: ser::Writeable>(
&self,
t: Type,
rt: Type,
body: &W,
expect_h: Option<(Hash)>,
) -> Result<(), Error> {
let _sent = try!(self.underlying.send_msg(t, body));
let mut expects = self.expected_responses.lock().unwrap();
expects.push((rt, expect_h, Instant::now()));
Ok(())
}
/// Same as Connection
pub fn send_msg<W: ser::Writeable>(&self, t: Type, body: &W) -> Result<(), Error> {
self.underlying.send_msg(t, body)
}
/// Same as Connection
pub fn transmitted_bytes(&self) -> (u64, u64) {
self.underlying.transmitted_bytes()
}
}
| {
debug!(LOGGER, "Invalid {:?} message: {}", msg_type, e);
return Err(Error::Serialization(e));
} | conditional_block |
dpkg_install.go | package main
import (
"archive/tar"
"bytes"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/blakesmith/ar"
"github.com/julien-sobczak/deb822"
)
func main() {
// This program expects one or more package files to install.
if len(os.Args) < 2 {
log.Fatalf("Missing package archive(s)")
}
// Read the DPKG database
db, _ := loadDatabase()
// Unpack and configure the archive(s)
for _, archivePath := range os.Args[1:] {
processArchive(db, archivePath)
}
// For simplicity reasons, we don't manage a queue to defer
// the configuration of packages like in the official code.
}
//
// Dpkg Database
//
type Database struct {
// File /var/lib/dpkg/status
Status deb822.Document
// Packages under /var/lib/dpkg/info/
Packages []*PackageInfo
}
type PackageInfo struct {
Paragraph deb822.Paragraph // Extracted section in /var/lib/dpkg/status
// info
Files []string // File <name>.list
Conffiles []string // File <name>.conffiles
MaintainerScripts map[string]string // File <name>.{preinst,prerm,...}
Status string // Current status (as present in `Paragraph`)
StatusDirty bool // True to ask for sync
}
func (p *PackageInfo) Name() string {
// Extract the package name from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Package")
}
func (p *PackageInfo) Version() string {
// Extract the package version from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Version")
}
// isConffile determines if a file must be processed as a conffile.
func (p *PackageInfo) isConffile(path string) bool {
for _, conffile := range p.Conffiles {
if path == conffile {
return true
}
}
return false
}
// InfoPath returns the path of a file under /var/lib/dpkg/info/.
// Ex: "list" => /var/lib/dpkg/info/hello.list
func (p *PackageInfo) | (filename string) string {
return filepath.Join("/var/lib/dpkg", p.Name()+"."+filename)
}
// We now add a method to change the package status
// and make sure the section in the status file is updated too.
// This method will be used several times at the different steps
// of the installation process.
func (p *PackageInfo) SetStatus(new string) {
p.Status = new
p.StatusDirty = true
// Override in DEB 822 document used to write the status file
old := p.Paragraph.Values["Status"]
parts := strings.Split(old, " ")
newStatus := fmt.Sprintf("%s %s %s", parts[0], parts[1], new)
p.Paragraph.Values["Status"] = newStatus
}
// Now, we are ready to read the database directory to initialize the structs.
func loadDatabase() (*Database, error) {
// Load the status file
f, _ := os.Open("/var/lib/dpkg/status")
parser, _ := deb822.NewParser(f)
status, _ := parser.Parse()
// Read the info directory
var packages []*PackageInfo
for _, statusParagraph := range status.Paragraphs {
statusField := statusParagraph.Value("Status") // install ok installed
statusValues := strings.Split(statusField, " ")
pkg := PackageInfo{
Paragraph: statusParagraph,
MaintainerScripts: make(map[string]string),
Status: statusValues[2],
StatusDirty: false,
}
// Read the configuration files
pkg.Files, _ = ReadLines(pkg.InfoPath("list"))
pkg.Conffiles, _ = ReadLines(pkg.InfoPath("conffiles"))
// Read the maintainer scripts
maintainerScripts := []string{"preinst", "postinst", "prerm", "postrm"}
for _, script := range maintainerScripts {
scriptPath := pkg.InfoPath(script)
if _, err := os.Stat(scriptPath); !os.IsNotExist(err) {
content, err := os.ReadFile(scriptPath)
if err != nil {
return nil, err
}
pkg.MaintainerScripts[script] = string(content)
}
}
packages = append(packages, &pkg)
}
// We have read everything that interest us and are ready
// to populate the Database struct.
return &Database{
Status: status,
Packages: packages,
}, nil
}
// Now we are ready to process an archive to install.
func processArchive(db *Database, archivePath string) error {
// Read the Debian archive file
f, err := os.Open(archivePath)
if err != nil {
return err
}
defer f.Close()
reader := ar.NewReader(f)
// Skip debian-binary
reader.Next()
// control.tar
reader.Next()
var bufControl bytes.Buffer
io.Copy(&bufControl, reader)
pkg, err := parseControl(db, bufControl)
if err != nil {
return err
}
// Add the new package in the database
db.Packages = append(db.Packages, pkg)
db.Sync()
// data.tar
reader.Next()
var bufData bytes.Buffer
io.Copy(&bufData, reader)
fmt.Printf("Preparing to unpack %s ...\n", filepath.Base(archivePath))
if err := pkg.Unpack(bufData); err != nil {
return err
}
if err := pkg.Configure(); err != nil {
return err
}
db.Sync()
return nil
}
// parseControl processes the control.tar archive.
func parseControl(db *Database, buf bytes.Buffer) (*PackageInfo, error) {
// The control.tar archive contains the most important files
// we need to install the package.
// We need to extract metadata from the control file, determine
// if the package contains conffiles and maintainer scripts.
pkg := PackageInfo{
MaintainerScripts: make(map[string]string),
Status: "not-installed",
StatusDirty: true,
}
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return nil, err
}
// Read the file content
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return nil, err
}
switch filepath.Base(hdr.Name) {
case "control":
parser, _ := deb822.NewParser(strings.NewReader(buf.String()))
document, _ := parser.Parse()
controlParagraph := document.Paragraphs[0]
// Copy control fields and add the Status field in second position
pkg.Paragraph = deb822.Paragraph{
Values: make(map[string]string),
}
// Make sure the field "Package' comes first, then "Status",
// then remaining fields.
pkg.Paragraph.Order = append(
pkg.Paragraph.Order, "Package", "Status")
pkg.Paragraph.Values["Package"] = controlParagraph.Value("Package")
pkg.Paragraph.Values["Status"] = "install ok non-installed"
for _, field := range controlParagraph.Order {
if field == "Package" {
continue
}
pkg.Paragraph.Order = append(pkg.Paragraph.Order, field)
pkg.Paragraph.Values[field] = controlParagraph.Value(field)
}
case "conffiles":
pkg.Conffiles = SplitLines(buf.String())
case "prerm":
fallthrough
case "preinst":
fallthrough
case "postinst":
fallthrough
case "postrm":
pkg.MaintainerScripts[filepath.Base(hdr.Name)] = buf.String()
}
}
return &pkg, nil
}
// Unpack processes the data.tar archive.
func (p *PackageInfo) Unpack(buf bytes.Buffer) error {
// The unpacking process consists in extracting all files
// in data.tar to their final destination, except for conffiles,
// which are copied with a special extension that will be removed
// in the configure step.
if err := p.runMaintainerScript("preinst"); err != nil {
return err
}
fmt.Printf("Unpacking %s (%s) ...\n", p.Name(), p.Version())
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return err
}
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return err
}
switch hdr.Typeflag {
case tar.TypeReg:
dest := hdr.Name
if strings.HasPrefix(dest, "./") {
// ./usr/bin/hello => /usr/bin/hello
dest = dest[1:]
}
if !strings.HasPrefix(dest, "/") {
// usr/bin/hello => /usr/bin/hello
dest = "/" + dest
}
tmpdest := dest
if p.isConffile(tmpdest) {
// Extract using the extension .dpkg-new
tmpdest += ".dpkg-new"
}
if err := os.MkdirAll(filepath.Dir(tmpdest), 0755); err != nil {
log.Fatalf("Failed to unpack directory %s: %v", tmpdest, err)
}
content := buf.Bytes()
if err := os.WriteFile(tmpdest, content, 0755); err != nil {
log.Fatalf("Failed to unpack file %s: %v", tmpdest, err)
}
p.Files = append(p.Files, dest)
}
}
p.SetStatus("unpacked")
p.Sync()
return nil
}
// Configure processes the conffiles.
func (p *PackageInfo) Configure() error {
// The configure process consists in renaming the conffiles
// unpacked at the previous step.
//
// We ignore some implementation concerns like checking if a conffile
// has been updated using the last known checksum.
fmt.Printf("Setting up %s (%s) ...\n", p.Name(), p.Version())
// Rename conffiles
for _, conffile := range p.Conffiles {
os.Rename(conffile+".dpkg-new", conffile)
}
p.SetStatus("half-configured")
p.Sync()
// Run maintainer script
if err := p.runMaintainerScript("postinst"); err != nil {
return err
}
p.SetStatus("installed")
p.Sync()
return nil
}
func (p *PackageInfo) runMaintainerScript(name string) error {
// The control.tar file can contains scripts to be run at
// specific moments. This function uses the standard Go library
// to run the `sh` command with a maintainer scrpit as an argument.
if _, ok := p.MaintainerScripts[name]; !ok {
// Nothing to run
return nil
}
out, err := exec.Command("/bin/sh", p.InfoPath(name)).Output()
if err != nil {
return err
}
fmt.Print(string(out))
return nil
}
// We have covered the different steps of the installation process.
// We still need to write the code to sync the database.
func (d *Database) Sync() error {
newStatus := deb822.Document{
Paragraphs: []deb822.Paragraph{},
}
// Sync the /var/lib/dpkg/info directory
for _, pkg := range d.Packages {
newStatus.Paragraphs = append(newStatus.Paragraphs, pkg.Paragraph)
if pkg.StatusDirty {
if err := pkg.Sync(); err != nil {
return err
}
}
}
// Make a new version of /var/lib/dpkg/status
os.Rename("/var/lib/dpkg/status", "/var/lib/dpkg/status-old")
formatter := deb822.NewFormatter()
formatter.SetFoldedFields("Description")
formatter.SetMultilineFields("Conffiles")
if err := os.WriteFile("/var/lib/dpkg/status",
[]byte(formatter.Format(newStatus)), 0644); err != nil {
return err
}
return nil
}
func (p *PackageInfo) Sync() error {
// This function synchronizes the files under /var/lib/dpkg/info
// for a single package.
// Write <package>.list
if err := os.WriteFile(p.InfoPath("list"),
[]byte(MergeLines(p.Files)), 0644); err != nil {
return err
}
// Write <package>.conffiles
if err := os.WriteFile(p.InfoPath("conffiles"),
[]byte(MergeLines(p.Conffiles)), 0644); err != nil {
return err
}
// Write <package>.{preinst,prerm,postinst,postrm}
for name, content := range p.MaintainerScripts {
err := os.WriteFile(p.InfoPath(name), []byte(content), 0755)
if err != nil {
return err
}
}
p.StatusDirty = false
return nil
}
/* Utility functions */
func ReadLines(path string) ([]string, error) {
if _, err := os.Stat(path); !os.IsNotExist(err) {
content, err := os.ReadFile(path)
if err != nil {
return nil, err
}
return SplitLines(string(content)), nil
}
return nil, nil
}
func SplitLines(content string) []string {
var lines []string
for _, line := range strings.Split(string(content), "\n") {
if strings.TrimSpace(line) == "" {
continue
}
lines = append(lines, line)
}
return lines
}
func MergeLines(lines []string) string {
return strings.Join(lines, "\n") + "\n"
}
| InfoPath | identifier_name |
dpkg_install.go | package main
import (
"archive/tar"
"bytes"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/blakesmith/ar"
"github.com/julien-sobczak/deb822"
)
func main() {
// This program expects one or more package files to install.
if len(os.Args) < 2 {
log.Fatalf("Missing package archive(s)")
}
// Read the DPKG database
db, _ := loadDatabase()
// Unpack and configure the archive(s)
for _, archivePath := range os.Args[1:] {
processArchive(db, archivePath)
}
// For simplicity reasons, we don't manage a queue to defer
// the configuration of packages like in the official code.
}
//
// Dpkg Database
//
type Database struct {
// File /var/lib/dpkg/status
Status deb822.Document
// Packages under /var/lib/dpkg/info/
Packages []*PackageInfo
}
type PackageInfo struct {
Paragraph deb822.Paragraph // Extracted section in /var/lib/dpkg/status
// info
Files []string // File <name>.list
Conffiles []string // File <name>.conffiles
MaintainerScripts map[string]string // File <name>.{preinst,prerm,...}
Status string // Current status (as present in `Paragraph`)
StatusDirty bool // True to ask for sync
}
func (p *PackageInfo) Name() string {
// Extract the package name from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Package")
}
func (p *PackageInfo) Version() string {
// Extract the package version from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Version")
}
// isConffile determines if a file must be processed as a conffile.
func (p *PackageInfo) isConffile(path string) bool {
for _, conffile := range p.Conffiles {
if path == conffile {
return true
}
}
return false
}
// InfoPath returns the path of a file under /var/lib/dpkg/info/.
// Ex: "list" => /var/lib/dpkg/info/hello.list
func (p *PackageInfo) InfoPath(filename string) string {
return filepath.Join("/var/lib/dpkg", p.Name()+"."+filename)
}
// We now add a method to change the package status
// and make sure the section in the status file is updated too.
// This method will be used several times at the different steps
// of the installation process.
func (p *PackageInfo) SetStatus(new string) {
p.Status = new
p.StatusDirty = true
// Override in DEB 822 document used to write the status file
old := p.Paragraph.Values["Status"]
parts := strings.Split(old, " ")
newStatus := fmt.Sprintf("%s %s %s", parts[0], parts[1], new)
p.Paragraph.Values["Status"] = newStatus
}
// Now, we are ready to read the database directory to initialize the structs.
func loadDatabase() (*Database, error) {
// Load the status file
f, _ := os.Open("/var/lib/dpkg/status")
parser, _ := deb822.NewParser(f)
status, _ := parser.Parse()
// Read the info directory
var packages []*PackageInfo
for _, statusParagraph := range status.Paragraphs {
statusField := statusParagraph.Value("Status") // install ok installed
statusValues := strings.Split(statusField, " ")
pkg := PackageInfo{
Paragraph: statusParagraph,
MaintainerScripts: make(map[string]string),
Status: statusValues[2],
StatusDirty: false,
}
// Read the configuration files
pkg.Files, _ = ReadLines(pkg.InfoPath("list"))
pkg.Conffiles, _ = ReadLines(pkg.InfoPath("conffiles"))
// Read the maintainer scripts
maintainerScripts := []string{"preinst", "postinst", "prerm", "postrm"}
for _, script := range maintainerScripts {
scriptPath := pkg.InfoPath(script)
if _, err := os.Stat(scriptPath); !os.IsNotExist(err) {
content, err := os.ReadFile(scriptPath)
if err != nil {
return nil, err
}
pkg.MaintainerScripts[script] = string(content)
}
}
packages = append(packages, &pkg)
}
// We have read everything that interest us and are ready
// to populate the Database struct.
return &Database{
Status: status,
Packages: packages,
}, nil
}
// Now we are ready to process an archive to install.
func processArchive(db *Database, archivePath string) error {
// Read the Debian archive file
f, err := os.Open(archivePath)
if err != nil {
return err
}
defer f.Close()
reader := ar.NewReader(f)
// Skip debian-binary
reader.Next()
// control.tar
reader.Next()
var bufControl bytes.Buffer
io.Copy(&bufControl, reader)
pkg, err := parseControl(db, bufControl)
if err != nil {
return err
}
// Add the new package in the database
db.Packages = append(db.Packages, pkg)
db.Sync()
// data.tar
reader.Next()
var bufData bytes.Buffer
io.Copy(&bufData, reader)
fmt.Printf("Preparing to unpack %s ...\n", filepath.Base(archivePath))
if err := pkg.Unpack(bufData); err != nil {
return err
}
if err := pkg.Configure(); err != nil {
return err
}
db.Sync()
return nil
}
// parseControl processes the control.tar archive.
func parseControl(db *Database, buf bytes.Buffer) (*PackageInfo, error) {
// The control.tar archive contains the most important files
// we need to install the package.
// We need to extract metadata from the control file, determine
// if the package contains conffiles and maintainer scripts.
pkg := PackageInfo{
MaintainerScripts: make(map[string]string),
Status: "not-installed",
StatusDirty: true,
}
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return nil, err
}
// Read the file content
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return nil, err
}
switch filepath.Base(hdr.Name) {
case "control":
parser, _ := deb822.NewParser(strings.NewReader(buf.String()))
document, _ := parser.Parse()
controlParagraph := document.Paragraphs[0]
// Copy control fields and add the Status field in second position
pkg.Paragraph = deb822.Paragraph{
Values: make(map[string]string),
}
// Make sure the field "Package' comes first, then "Status",
// then remaining fields.
pkg.Paragraph.Order = append(
pkg.Paragraph.Order, "Package", "Status")
pkg.Paragraph.Values["Package"] = controlParagraph.Value("Package")
pkg.Paragraph.Values["Status"] = "install ok non-installed"
for _, field := range controlParagraph.Order {
if field == "Package" {
continue
}
pkg.Paragraph.Order = append(pkg.Paragraph.Order, field)
pkg.Paragraph.Values[field] = controlParagraph.Value(field)
}
case "conffiles":
pkg.Conffiles = SplitLines(buf.String())
case "prerm":
fallthrough
case "preinst":
fallthrough
case "postinst":
fallthrough
case "postrm":
pkg.MaintainerScripts[filepath.Base(hdr.Name)] = buf.String()
}
}
return &pkg, nil
}
// Unpack processes the data.tar archive.
func (p *PackageInfo) Unpack(buf bytes.Buffer) error {
// The unpacking process consists in extracting all files
// in data.tar to their final destination, except for conffiles,
// which are copied with a special extension that will be removed
// in the configure step.
if err := p.runMaintainerScript("preinst"); err != nil {
return err
}
fmt.Printf("Unpacking %s (%s) ...\n", p.Name(), p.Version())
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return err
}
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return err
}
switch hdr.Typeflag {
case tar.TypeReg:
dest := hdr.Name
if strings.HasPrefix(dest, "./") {
// ./usr/bin/hello => /usr/bin/hello
dest = dest[1:]
}
if !strings.HasPrefix(dest, "/") {
// usr/bin/hello => /usr/bin/hello
dest = "/" + dest
}
tmpdest := dest
if p.isConffile(tmpdest) {
// Extract using the extension .dpkg-new
tmpdest += ".dpkg-new"
}
if err := os.MkdirAll(filepath.Dir(tmpdest), 0755); err != nil {
log.Fatalf("Failed to unpack directory %s: %v", tmpdest, err)
}
content := buf.Bytes()
if err := os.WriteFile(tmpdest, content, 0755); err != nil {
log.Fatalf("Failed to unpack file %s: %v", tmpdest, err)
}
p.Files = append(p.Files, dest)
}
}
p.SetStatus("unpacked")
p.Sync()
return nil
}
// Configure processes the conffiles.
func (p *PackageInfo) Configure() error {
// The configure process consists in renaming the conffiles
// unpacked at the previous step.
//
// We ignore some implementation concerns like checking if a conffile
// has been updated using the last known checksum.
fmt.Printf("Setting up %s (%s) ...\n", p.Name(), p.Version())
// Rename conffiles
for _, conffile := range p.Conffiles {
os.Rename(conffile+".dpkg-new", conffile)
}
p.SetStatus("half-configured")
p.Sync()
// Run maintainer script
if err := p.runMaintainerScript("postinst"); err != nil {
return err
}
p.SetStatus("installed")
p.Sync()
return nil
}
func (p *PackageInfo) runMaintainerScript(name string) error {
// The control.tar file can contains scripts to be run at
// specific moments. This function uses the standard Go library
// to run the `sh` command with a maintainer scrpit as an argument.
if _, ok := p.MaintainerScripts[name]; !ok {
// Nothing to run
return nil
}
out, err := exec.Command("/bin/sh", p.InfoPath(name)).Output()
if err != nil {
return err
}
fmt.Print(string(out))
return nil
}
// We have covered the different steps of the installation process.
// We still need to write the code to sync the database.
func (d *Database) Sync() error {
newStatus := deb822.Document{
Paragraphs: []deb822.Paragraph{},
}
// Sync the /var/lib/dpkg/info directory
for _, pkg := range d.Packages {
newStatus.Paragraphs = append(newStatus.Paragraphs, pkg.Paragraph)
if pkg.StatusDirty {
if err := pkg.Sync(); err != nil {
return err
}
}
}
// Make a new version of /var/lib/dpkg/status
os.Rename("/var/lib/dpkg/status", "/var/lib/dpkg/status-old")
formatter := deb822.NewFormatter()
formatter.SetFoldedFields("Description")
formatter.SetMultilineFields("Conffiles")
if err := os.WriteFile("/var/lib/dpkg/status",
[]byte(formatter.Format(newStatus)), 0644); err != nil {
return err
}
return nil
}
func (p *PackageInfo) Sync() error |
/* Utility functions */
func ReadLines(path string) ([]string, error) {
if _, err := os.Stat(path); !os.IsNotExist(err) {
content, err := os.ReadFile(path)
if err != nil {
return nil, err
}
return SplitLines(string(content)), nil
}
return nil, nil
}
func SplitLines(content string) []string {
var lines []string
for _, line := range strings.Split(string(content), "\n") {
if strings.TrimSpace(line) == "" {
continue
}
lines = append(lines, line)
}
return lines
}
func MergeLines(lines []string) string {
return strings.Join(lines, "\n") + "\n"
}
| {
// This function synchronizes the files under /var/lib/dpkg/info
// for a single package.
// Write <package>.list
if err := os.WriteFile(p.InfoPath("list"),
[]byte(MergeLines(p.Files)), 0644); err != nil {
return err
}
// Write <package>.conffiles
if err := os.WriteFile(p.InfoPath("conffiles"),
[]byte(MergeLines(p.Conffiles)), 0644); err != nil {
return err
}
// Write <package>.{preinst,prerm,postinst,postrm}
for name, content := range p.MaintainerScripts {
err := os.WriteFile(p.InfoPath(name), []byte(content), 0755)
if err != nil {
return err
}
}
p.StatusDirty = false
return nil
} | identifier_body |
dpkg_install.go | package main
import (
"archive/tar"
"bytes"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/blakesmith/ar"
"github.com/julien-sobczak/deb822"
)
func main() {
// This program expects one or more package files to install.
if len(os.Args) < 2 {
log.Fatalf("Missing package archive(s)")
}
// Read the DPKG database
db, _ := loadDatabase()
// Unpack and configure the archive(s)
for _, archivePath := range os.Args[1:] {
processArchive(db, archivePath)
}
// For simplicity reasons, we don't manage a queue to defer
// the configuration of packages like in the official code.
}
//
// Dpkg Database
//
type Database struct {
// File /var/lib/dpkg/status
Status deb822.Document
// Packages under /var/lib/dpkg/info/
Packages []*PackageInfo
}
type PackageInfo struct {
Paragraph deb822.Paragraph // Extracted section in /var/lib/dpkg/status
// info
Files []string // File <name>.list
Conffiles []string // File <name>.conffiles
MaintainerScripts map[string]string // File <name>.{preinst,prerm,...}
Status string // Current status (as present in `Paragraph`)
StatusDirty bool // True to ask for sync
}
func (p *PackageInfo) Name() string {
// Extract the package name from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Package")
}
func (p *PackageInfo) Version() string {
// Extract the package version from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Version")
}
// isConffile determines if a file must be processed as a conffile.
func (p *PackageInfo) isConffile(path string) bool {
for _, conffile := range p.Conffiles {
if path == conffile {
return true
}
}
return false
}
// InfoPath returns the path of a file under /var/lib/dpkg/info/.
// Ex: "list" => /var/lib/dpkg/info/hello.list
func (p *PackageInfo) InfoPath(filename string) string {
return filepath.Join("/var/lib/dpkg", p.Name()+"."+filename)
}
// We now add a method to change the package status
// and make sure the section in the status file is updated too.
// This method will be used several times at the different steps
// of the installation process.
func (p *PackageInfo) SetStatus(new string) {
p.Status = new
p.StatusDirty = true
// Override in DEB 822 document used to write the status file
old := p.Paragraph.Values["Status"]
parts := strings.Split(old, " ")
newStatus := fmt.Sprintf("%s %s %s", parts[0], parts[1], new)
p.Paragraph.Values["Status"] = newStatus
}
// Now, we are ready to read the database directory to initialize the structs.
func loadDatabase() (*Database, error) {
// Load the status file
f, _ := os.Open("/var/lib/dpkg/status")
parser, _ := deb822.NewParser(f)
status, _ := parser.Parse()
// Read the info directory
var packages []*PackageInfo
for _, statusParagraph := range status.Paragraphs {
statusField := statusParagraph.Value("Status") // install ok installed
statusValues := strings.Split(statusField, " ")
pkg := PackageInfo{
Paragraph: statusParagraph,
MaintainerScripts: make(map[string]string),
Status: statusValues[2],
StatusDirty: false,
}
// Read the configuration files
pkg.Files, _ = ReadLines(pkg.InfoPath("list"))
pkg.Conffiles, _ = ReadLines(pkg.InfoPath("conffiles"))
// Read the maintainer scripts
maintainerScripts := []string{"preinst", "postinst", "prerm", "postrm"}
for _, script := range maintainerScripts {
scriptPath := pkg.InfoPath(script)
if _, err := os.Stat(scriptPath); !os.IsNotExist(err) {
content, err := os.ReadFile(scriptPath)
if err != nil {
return nil, err
}
pkg.MaintainerScripts[script] = string(content)
}
}
packages = append(packages, &pkg)
}
// We have read everything that interest us and are ready
// to populate the Database struct.
return &Database{
Status: status,
Packages: packages,
}, nil
}
// Now we are ready to process an archive to install.
func processArchive(db *Database, archivePath string) error {
// Read the Debian archive file
f, err := os.Open(archivePath)
if err != nil {
return err
}
defer f.Close()
reader := ar.NewReader(f)
// Skip debian-binary
reader.Next() | var bufControl bytes.Buffer
io.Copy(&bufControl, reader)
pkg, err := parseControl(db, bufControl)
if err != nil {
return err
}
// Add the new package in the database
db.Packages = append(db.Packages, pkg)
db.Sync()
// data.tar
reader.Next()
var bufData bytes.Buffer
io.Copy(&bufData, reader)
fmt.Printf("Preparing to unpack %s ...\n", filepath.Base(archivePath))
if err := pkg.Unpack(bufData); err != nil {
return err
}
if err := pkg.Configure(); err != nil {
return err
}
db.Sync()
return nil
}
// parseControl processes the control.tar archive.
func parseControl(db *Database, buf bytes.Buffer) (*PackageInfo, error) {
// The control.tar archive contains the most important files
// we need to install the package.
// We need to extract metadata from the control file, determine
// if the package contains conffiles and maintainer scripts.
pkg := PackageInfo{
MaintainerScripts: make(map[string]string),
Status: "not-installed",
StatusDirty: true,
}
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return nil, err
}
// Read the file content
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return nil, err
}
switch filepath.Base(hdr.Name) {
case "control":
parser, _ := deb822.NewParser(strings.NewReader(buf.String()))
document, _ := parser.Parse()
controlParagraph := document.Paragraphs[0]
// Copy control fields and add the Status field in second position
pkg.Paragraph = deb822.Paragraph{
Values: make(map[string]string),
}
// Make sure the field "Package' comes first, then "Status",
// then remaining fields.
pkg.Paragraph.Order = append(
pkg.Paragraph.Order, "Package", "Status")
pkg.Paragraph.Values["Package"] = controlParagraph.Value("Package")
pkg.Paragraph.Values["Status"] = "install ok non-installed"
for _, field := range controlParagraph.Order {
if field == "Package" {
continue
}
pkg.Paragraph.Order = append(pkg.Paragraph.Order, field)
pkg.Paragraph.Values[field] = controlParagraph.Value(field)
}
case "conffiles":
pkg.Conffiles = SplitLines(buf.String())
case "prerm":
fallthrough
case "preinst":
fallthrough
case "postinst":
fallthrough
case "postrm":
pkg.MaintainerScripts[filepath.Base(hdr.Name)] = buf.String()
}
}
return &pkg, nil
}
// Unpack processes the data.tar archive.
func (p *PackageInfo) Unpack(buf bytes.Buffer) error {
// The unpacking process consists in extracting all files
// in data.tar to their final destination, except for conffiles,
// which are copied with a special extension that will be removed
// in the configure step.
if err := p.runMaintainerScript("preinst"); err != nil {
return err
}
fmt.Printf("Unpacking %s (%s) ...\n", p.Name(), p.Version())
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return err
}
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return err
}
switch hdr.Typeflag {
case tar.TypeReg:
dest := hdr.Name
if strings.HasPrefix(dest, "./") {
// ./usr/bin/hello => /usr/bin/hello
dest = dest[1:]
}
if !strings.HasPrefix(dest, "/") {
// usr/bin/hello => /usr/bin/hello
dest = "/" + dest
}
tmpdest := dest
if p.isConffile(tmpdest) {
// Extract using the extension .dpkg-new
tmpdest += ".dpkg-new"
}
if err := os.MkdirAll(filepath.Dir(tmpdest), 0755); err != nil {
log.Fatalf("Failed to unpack directory %s: %v", tmpdest, err)
}
content := buf.Bytes()
if err := os.WriteFile(tmpdest, content, 0755); err != nil {
log.Fatalf("Failed to unpack file %s: %v", tmpdest, err)
}
p.Files = append(p.Files, dest)
}
}
p.SetStatus("unpacked")
p.Sync()
return nil
}
// Configure processes the conffiles.
func (p *PackageInfo) Configure() error {
// The configure process consists in renaming the conffiles
// unpacked at the previous step.
//
// We ignore some implementation concerns like checking if a conffile
// has been updated using the last known checksum.
fmt.Printf("Setting up %s (%s) ...\n", p.Name(), p.Version())
// Rename conffiles
for _, conffile := range p.Conffiles {
os.Rename(conffile+".dpkg-new", conffile)
}
p.SetStatus("half-configured")
p.Sync()
// Run maintainer script
if err := p.runMaintainerScript("postinst"); err != nil {
return err
}
p.SetStatus("installed")
p.Sync()
return nil
}
func (p *PackageInfo) runMaintainerScript(name string) error {
// The control.tar file can contains scripts to be run at
// specific moments. This function uses the standard Go library
// to run the `sh` command with a maintainer scrpit as an argument.
if _, ok := p.MaintainerScripts[name]; !ok {
// Nothing to run
return nil
}
out, err := exec.Command("/bin/sh", p.InfoPath(name)).Output()
if err != nil {
return err
}
fmt.Print(string(out))
return nil
}
// We have covered the different steps of the installation process.
// We still need to write the code to sync the database.
func (d *Database) Sync() error {
newStatus := deb822.Document{
Paragraphs: []deb822.Paragraph{},
}
// Sync the /var/lib/dpkg/info directory
for _, pkg := range d.Packages {
newStatus.Paragraphs = append(newStatus.Paragraphs, pkg.Paragraph)
if pkg.StatusDirty {
if err := pkg.Sync(); err != nil {
return err
}
}
}
// Make a new version of /var/lib/dpkg/status
os.Rename("/var/lib/dpkg/status", "/var/lib/dpkg/status-old")
formatter := deb822.NewFormatter()
formatter.SetFoldedFields("Description")
formatter.SetMultilineFields("Conffiles")
if err := os.WriteFile("/var/lib/dpkg/status",
[]byte(formatter.Format(newStatus)), 0644); err != nil {
return err
}
return nil
}
func (p *PackageInfo) Sync() error {
// This function synchronizes the files under /var/lib/dpkg/info
// for a single package.
// Write <package>.list
if err := os.WriteFile(p.InfoPath("list"),
[]byte(MergeLines(p.Files)), 0644); err != nil {
return err
}
// Write <package>.conffiles
if err := os.WriteFile(p.InfoPath("conffiles"),
[]byte(MergeLines(p.Conffiles)), 0644); err != nil {
return err
}
// Write <package>.{preinst,prerm,postinst,postrm}
for name, content := range p.MaintainerScripts {
err := os.WriteFile(p.InfoPath(name), []byte(content), 0755)
if err != nil {
return err
}
}
p.StatusDirty = false
return nil
}
/* Utility functions */
func ReadLines(path string) ([]string, error) {
if _, err := os.Stat(path); !os.IsNotExist(err) {
content, err := os.ReadFile(path)
if err != nil {
return nil, err
}
return SplitLines(string(content)), nil
}
return nil, nil
}
func SplitLines(content string) []string {
var lines []string
for _, line := range strings.Split(string(content), "\n") {
if strings.TrimSpace(line) == "" {
continue
}
lines = append(lines, line)
}
return lines
}
func MergeLines(lines []string) string {
return strings.Join(lines, "\n") + "\n"
} |
// control.tar
reader.Next() | random_line_split |
dpkg_install.go | package main
import (
"archive/tar"
"bytes"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/blakesmith/ar"
"github.com/julien-sobczak/deb822"
)
func main() {
// This program expects one or more package files to install.
if len(os.Args) < 2 {
log.Fatalf("Missing package archive(s)")
}
// Read the DPKG database
db, _ := loadDatabase()
// Unpack and configure the archive(s)
for _, archivePath := range os.Args[1:] {
processArchive(db, archivePath)
}
// For simplicity reasons, we don't manage a queue to defer
// the configuration of packages like in the official code.
}
//
// Dpkg Database
//
type Database struct {
// File /var/lib/dpkg/status
Status deb822.Document
// Packages under /var/lib/dpkg/info/
Packages []*PackageInfo
}
type PackageInfo struct {
Paragraph deb822.Paragraph // Extracted section in /var/lib/dpkg/status
// info
Files []string // File <name>.list
Conffiles []string // File <name>.conffiles
MaintainerScripts map[string]string // File <name>.{preinst,prerm,...}
Status string // Current status (as present in `Paragraph`)
StatusDirty bool // True to ask for sync
}
func (p *PackageInfo) Name() string {
// Extract the package name from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Package")
}
func (p *PackageInfo) Version() string {
// Extract the package version from its section in /var/lib/dpkg/status
return p.Paragraph.Value("Version")
}
// isConffile determines if a file must be processed as a conffile.
func (p *PackageInfo) isConffile(path string) bool {
for _, conffile := range p.Conffiles {
if path == conffile {
return true
}
}
return false
}
// InfoPath returns the path of a file under /var/lib/dpkg/info/.
// Ex: "list" => /var/lib/dpkg/info/hello.list
func (p *PackageInfo) InfoPath(filename string) string {
return filepath.Join("/var/lib/dpkg", p.Name()+"."+filename)
}
// We now add a method to change the package status
// and make sure the section in the status file is updated too.
// This method will be used several times at the different steps
// of the installation process.
func (p *PackageInfo) SetStatus(new string) {
p.Status = new
p.StatusDirty = true
// Override in DEB 822 document used to write the status file
old := p.Paragraph.Values["Status"]
parts := strings.Split(old, " ")
newStatus := fmt.Sprintf("%s %s %s", parts[0], parts[1], new)
p.Paragraph.Values["Status"] = newStatus
}
// Now, we are ready to read the database directory to initialize the structs.
func loadDatabase() (*Database, error) {
// Load the status file
f, _ := os.Open("/var/lib/dpkg/status")
parser, _ := deb822.NewParser(f)
status, _ := parser.Parse()
// Read the info directory
var packages []*PackageInfo
for _, statusParagraph := range status.Paragraphs {
statusField := statusParagraph.Value("Status") // install ok installed
statusValues := strings.Split(statusField, " ")
pkg := PackageInfo{
Paragraph: statusParagraph,
MaintainerScripts: make(map[string]string),
Status: statusValues[2],
StatusDirty: false,
}
// Read the configuration files
pkg.Files, _ = ReadLines(pkg.InfoPath("list"))
pkg.Conffiles, _ = ReadLines(pkg.InfoPath("conffiles"))
// Read the maintainer scripts
maintainerScripts := []string{"preinst", "postinst", "prerm", "postrm"}
for _, script := range maintainerScripts {
scriptPath := pkg.InfoPath(script)
if _, err := os.Stat(scriptPath); !os.IsNotExist(err) {
content, err := os.ReadFile(scriptPath)
if err != nil {
return nil, err
}
pkg.MaintainerScripts[script] = string(content)
}
}
packages = append(packages, &pkg)
}
// We have read everything that interest us and are ready
// to populate the Database struct.
return &Database{
Status: status,
Packages: packages,
}, nil
}
// Now we are ready to process an archive to install.
func processArchive(db *Database, archivePath string) error {
// Read the Debian archive file
f, err := os.Open(archivePath)
if err != nil {
return err
}
defer f.Close()
reader := ar.NewReader(f)
// Skip debian-binary
reader.Next()
// control.tar
reader.Next()
var bufControl bytes.Buffer
io.Copy(&bufControl, reader)
pkg, err := parseControl(db, bufControl)
if err != nil |
// Add the new package in the database
db.Packages = append(db.Packages, pkg)
db.Sync()
// data.tar
reader.Next()
var bufData bytes.Buffer
io.Copy(&bufData, reader)
fmt.Printf("Preparing to unpack %s ...\n", filepath.Base(archivePath))
if err := pkg.Unpack(bufData); err != nil {
return err
}
if err := pkg.Configure(); err != nil {
return err
}
db.Sync()
return nil
}
// parseControl processes the control.tar archive.
func parseControl(db *Database, buf bytes.Buffer) (*PackageInfo, error) {
// The control.tar archive contains the most important files
// we need to install the package.
// We need to extract metadata from the control file, determine
// if the package contains conffiles and maintainer scripts.
pkg := PackageInfo{
MaintainerScripts: make(map[string]string),
Status: "not-installed",
StatusDirty: true,
}
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return nil, err
}
// Read the file content
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return nil, err
}
switch filepath.Base(hdr.Name) {
case "control":
parser, _ := deb822.NewParser(strings.NewReader(buf.String()))
document, _ := parser.Parse()
controlParagraph := document.Paragraphs[0]
// Copy control fields and add the Status field in second position
pkg.Paragraph = deb822.Paragraph{
Values: make(map[string]string),
}
// Make sure the field "Package' comes first, then "Status",
// then remaining fields.
pkg.Paragraph.Order = append(
pkg.Paragraph.Order, "Package", "Status")
pkg.Paragraph.Values["Package"] = controlParagraph.Value("Package")
pkg.Paragraph.Values["Status"] = "install ok non-installed"
for _, field := range controlParagraph.Order {
if field == "Package" {
continue
}
pkg.Paragraph.Order = append(pkg.Paragraph.Order, field)
pkg.Paragraph.Values[field] = controlParagraph.Value(field)
}
case "conffiles":
pkg.Conffiles = SplitLines(buf.String())
case "prerm":
fallthrough
case "preinst":
fallthrough
case "postinst":
fallthrough
case "postrm":
pkg.MaintainerScripts[filepath.Base(hdr.Name)] = buf.String()
}
}
return &pkg, nil
}
// Unpack processes the data.tar archive.
func (p *PackageInfo) Unpack(buf bytes.Buffer) error {
// The unpacking process consists in extracting all files
// in data.tar to their final destination, except for conffiles,
// which are copied with a special extension that will be removed
// in the configure step.
if err := p.runMaintainerScript("preinst"); err != nil {
return err
}
fmt.Printf("Unpacking %s (%s) ...\n", p.Name(), p.Version())
tr := tar.NewReader(&buf)
for {
hdr, err := tr.Next()
if err == io.EOF {
break // End of archive
}
if err != nil {
return err
}
var buf bytes.Buffer
if _, err := io.Copy(&buf, tr); err != nil {
return err
}
switch hdr.Typeflag {
case tar.TypeReg:
dest := hdr.Name
if strings.HasPrefix(dest, "./") {
// ./usr/bin/hello => /usr/bin/hello
dest = dest[1:]
}
if !strings.HasPrefix(dest, "/") {
// usr/bin/hello => /usr/bin/hello
dest = "/" + dest
}
tmpdest := dest
if p.isConffile(tmpdest) {
// Extract using the extension .dpkg-new
tmpdest += ".dpkg-new"
}
if err := os.MkdirAll(filepath.Dir(tmpdest), 0755); err != nil {
log.Fatalf("Failed to unpack directory %s: %v", tmpdest, err)
}
content := buf.Bytes()
if err := os.WriteFile(tmpdest, content, 0755); err != nil {
log.Fatalf("Failed to unpack file %s: %v", tmpdest, err)
}
p.Files = append(p.Files, dest)
}
}
p.SetStatus("unpacked")
p.Sync()
return nil
}
// Configure processes the conffiles.
func (p *PackageInfo) Configure() error {
// The configure process consists in renaming the conffiles
// unpacked at the previous step.
//
// We ignore some implementation concerns like checking if a conffile
// has been updated using the last known checksum.
fmt.Printf("Setting up %s (%s) ...\n", p.Name(), p.Version())
// Rename conffiles
for _, conffile := range p.Conffiles {
os.Rename(conffile+".dpkg-new", conffile)
}
p.SetStatus("half-configured")
p.Sync()
// Run maintainer script
if err := p.runMaintainerScript("postinst"); err != nil {
return err
}
p.SetStatus("installed")
p.Sync()
return nil
}
func (p *PackageInfo) runMaintainerScript(name string) error {
// The control.tar file can contains scripts to be run at
// specific moments. This function uses the standard Go library
// to run the `sh` command with a maintainer scrpit as an argument.
if _, ok := p.MaintainerScripts[name]; !ok {
// Nothing to run
return nil
}
out, err := exec.Command("/bin/sh", p.InfoPath(name)).Output()
if err != nil {
return err
}
fmt.Print(string(out))
return nil
}
// We have covered the different steps of the installation process.
// We still need to write the code to sync the database.
func (d *Database) Sync() error {
newStatus := deb822.Document{
Paragraphs: []deb822.Paragraph{},
}
// Sync the /var/lib/dpkg/info directory
for _, pkg := range d.Packages {
newStatus.Paragraphs = append(newStatus.Paragraphs, pkg.Paragraph)
if pkg.StatusDirty {
if err := pkg.Sync(); err != nil {
return err
}
}
}
// Make a new version of /var/lib/dpkg/status
os.Rename("/var/lib/dpkg/status", "/var/lib/dpkg/status-old")
formatter := deb822.NewFormatter()
formatter.SetFoldedFields("Description")
formatter.SetMultilineFields("Conffiles")
if err := os.WriteFile("/var/lib/dpkg/status",
[]byte(formatter.Format(newStatus)), 0644); err != nil {
return err
}
return nil
}
func (p *PackageInfo) Sync() error {
// This function synchronizes the files under /var/lib/dpkg/info
// for a single package.
// Write <package>.list
if err := os.WriteFile(p.InfoPath("list"),
[]byte(MergeLines(p.Files)), 0644); err != nil {
return err
}
// Write <package>.conffiles
if err := os.WriteFile(p.InfoPath("conffiles"),
[]byte(MergeLines(p.Conffiles)), 0644); err != nil {
return err
}
// Write <package>.{preinst,prerm,postinst,postrm}
for name, content := range p.MaintainerScripts {
err := os.WriteFile(p.InfoPath(name), []byte(content), 0755)
if err != nil {
return err
}
}
p.StatusDirty = false
return nil
}
/* Utility functions */
func ReadLines(path string) ([]string, error) {
if _, err := os.Stat(path); !os.IsNotExist(err) {
content, err := os.ReadFile(path)
if err != nil {
return nil, err
}
return SplitLines(string(content)), nil
}
return nil, nil
}
func SplitLines(content string) []string {
var lines []string
for _, line := range strings.Split(string(content), "\n") {
if strings.TrimSpace(line) == "" {
continue
}
lines = append(lines, line)
}
return lines
}
func MergeLines(lines []string) string {
return strings.Join(lines, "\n") + "\n"
}
| {
return err
} | conditional_block |
clarans.py | """!
@brief Cluster analysis algorithm: CLARANS.
@details Implementation based on paper @cite article::clarans::1.
@authors Andrei Novikov (pyclustering@yandex.ru)
@date 2014-2019
@copyright GNU Public License
@cond GNU_PUBLIC_LICENSE
PyClustering is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
PyClustering is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@endcond
"""
import random
from pyclustering.cluster.encoder import type_encoding
from pyclustering.utils import euclidean_distance_square
def plot_pam(data, cl, equal_axis_scale = False):
import matplotlib.pyplot as plt
import numpy as np
fig,ax = plt.subplots(figsize=(14,6))
plt.scatter(np.array(data)[:,0], np.array(data)[:,1], s=300, color="white", edgecolor="black")
colors = { 0:"seagreen", 1:'beige', 2:'yellow', 3:'grey',
4:'pink', 5:'turquoise', 6:'orange', 7:'purple', 8:'yellowgreen', 9:'olive', 10:'brown',
11:'tan', 12: 'plum', 13:'rosybrown', 14:'lightblue', 15:"khaki", 16:"gainsboro", 17:"peachpuff"}
for i,el in enumerate(list(cl.values())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=300, color=colors[i%17], edgecolor="black")
for i,el in enumerate(list(cl.keys())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=500, color="red", marker="X", edgecolor="black")
xmin, xmax, ymin, ymax = plt.axis()
xwidth = xmax - xmin
ywidth = ymax - ymin
xw1 = xwidth*0.01
yw1 = ywidth*0.01
xw2 = xwidth*0.005
yw2 = ywidth*0.01
xw3 = xwidth*0.01
yw3 = ywidth*0.01
for i, txt in enumerate(range(len(data))):
if len(str(txt))==2:
ax.annotate(txt, (np.array(data)[:,0][i]-xw1, np.array(data)[:,1][i]-yw1), fontsize=12, size=12)
elif len(str(txt))==1:
ax.annotate(txt, (np.array(data)[:,0][i]-xw2, np.array(data)[:,1][i]-yw2), fontsize=12, size=12)
else:
ax.annotate(txt, (np.array(data)[:,0][i]-xw3, np.array(data)[:,1][i]-yw3), fontsize=9, size=9)
if equal_axis_scale == True:
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
class clarans:
"""!
@brief Class represents clustering algorithm CLARANS (a method for clustering objects for spatial data mining).
"""
def __init__(self, data, number_clusters, numlocal, maxneighbor):
"""!
@brief Constructor of clustering algorithm CLARANS.
@details The higher the value of maxneighbor, the closer is CLARANS to K-Medoids, and the longer is each search of a local minima.
@param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.
@param[in] number_clusters (uint): Amount of clusters that should be allocated.
@param[in] numlocal (uint): The number of local minima obtained (amount of iterations for solving the problem).
@param[in] maxneighbor (uint): The maximum number of neighbors examined.
"""
self.__pointer_data = data
self.__numlocal = numlocal
self.__maxneighbor = maxneighbor
self.__number_clusters = number_clusters
self.__clusters = []
self.__current = []
self.__belong = []
self.__optimal_medoids = []
self.__optimal_estimation = float('inf')
self.__verify_arguments()
def __verify_arguments(self):
"""!
@brief Verify input parameters for the algorithm and throw exception in case of incorrectness.
"""
if len(self.__pointer_data) == 0:
raise ValueError("Input data is empty (size: '%d')." % len(self.__pointer_data))
if self.__number_clusters <= 0:
raise ValueError("Amount of cluster (current value: '%d') for allocation should be greater than 0." %
self.__number_clusters)
if self.__numlocal < 0:
raise ValueError("Local minima (current value: '%d') should be greater or equal to 0." % self.__numlocal)
if self.__maxneighbor < 0:
raise ValueError("Maximum number of neighbors (current value: '%d') should be greater or "
"equal to 0." % self.__maxneighbor)
def process(self, plotting=False):
"""!
@brief Performs cluster analysis in line with rules of CLARANS algorithm.
@return (clarans) Returns itself (CLARANS instance).
@see get_clusters()
@see get_medoids()
"""
random.seed()
# loop for a numlocal number of times
for _ in range(0, self.__numlocal):
print("numlocal: ", _)
# set (current) random medoids
self.__current = random.sample(range(0, len(self.__pointer_data)), self.__number_clusters)
# update clusters in line with random allocated medoids
self.__update_clusters(self.__current)
# optimize configuration
self.__optimize_configuration()
# obtain cost of current cluster configuration and compare it with the best obtained
estimation = self.__calculate_estimation()
if estimation < self.__optimal_estimation:
print("Better configuration found with medoids: {0} and cost: {1}".format(self.__current[:], estimation))
self.__optimal_medoids = self.__current[:]
self.__optimal_estimation = estimation
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
else:
print("Configuration found does not improve current best one because its cost is {0}".format(estimation))
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
self.__update_clusters(self.__optimal_medoids)
return self
def get_clusters(self):
"""!
@brief Returns allocated clusters by the algorithm.
@remark Allocated clusters can be returned only after data processing (use method process()), otherwise empty list is returned.
@return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.
@see process()
@see get_medoids()
"""
return self.__clusters
def get_medoids(self):
"""!
@brief Returns list of medoids of allocated clusters.
@see process()
@see get_clusters()
"""
return self.__optimal_medoids
def get_cluster_encoding(self):
"""!
@brief Returns clustering result representation type that indicate how clusters are encoded.
@return (type_encoding) Clustering result representation.
@see get_clusters()
"""
return type_encoding.CLUSTER_INDEX_LIST_SEPARATION
def __update_clusters(self, medoids):
"""!
@brief Forms cluster in line with specified medoids by calculation distance from each point to medoids.
"""
self.__belong = [0] * len(self.__pointer_data)
self.__clusters = [[] for i in range(len(medoids))]
for index_point in range(len(self.__pointer_data)):
index_optim = -1
dist_optim = 0.0
for index in range(len(medoids)):
dist = euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[medoids[index]])
if (dist < dist_optim) or (index is 0):
index_optim = index
dist_optim = dist
self.__clusters[index_optim].append(index_point)
self.__belong[index_point] = index_optim
# If cluster is not able to capture object it should be removed
self.__clusters = [cluster for cluster in self.__clusters if len(cluster) > 0]
def __optimize_configuration(self):
"""!
@brief Finds quasi-optimal medoids and updates in line with them clusters in line with algorithm's rules.
"""
index_neighbor = 0
counter = 0
while (index_neighbor < self.__maxneighbor):
# get random current medoid that is to be replaced
current_medoid_index = self.__current[random.randint(0, self.__number_clusters - 1)]
current_medoid_cluster_index = self.__belong[current_medoid_index]
# get new candidate to be medoid
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
while candidate_medoid_index in self.__current:
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
candidate_cost = 0.0
for point_index in range(0, len(self.__pointer_data)):
if point_index not in self.__current:
# get non-medoid point and its medoid
point_cluster_index = self.__belong[point_index]
point_medoid_index = self.__current[point_cluster_index]
# get other medoid that is nearest to the point (except current and candidate)
other_medoid_index = self.__find_another_nearest_medoid(point_index, current_medoid_index)
other_medoid_cluster_index = self.__belong[other_medoid_index]
# for optimization calculate all required distances
# from the point to current medoid
distance_current = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
# from the point to candidate median
distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[candidate_medoid_index])
# from the point to nearest (own) medoid
distance_nearest = float('inf')
if ( (point_medoid_index != candidate_medoid_index) and (point_medoid_index != current_medoid_cluster_index) ):
distance_nearest = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[point_medoid_index])
# apply rules for cost calculation
if (point_cluster_index == current_medoid_cluster_index):
# case 1:
if (distance_candidate >= distance_nearest):
candidate_cost += distance_nearest - distance_current
# case 2:
else:
candidate_cost += distance_candidate - distance_current
elif (point_cluster_index == other_medoid_cluster_index):
# case 3 ('nearest medoid' is the representative object of that cluster and object is more similar to 'nearest' than to 'candidate'):
if (distance_candidate > distance_nearest):
pass;
# case 4:
else:
candidate_cost += distance_candidate - distance_nearest
if (candidate_cost < 0):
counter+=1
# set candidate that has won
self.__current[current_medoid_cluster_index] = candidate_medoid_index
# recalculate clusters
self.__update_clusters(self.__current)
# reset iterations and starts investigation from the begining
index_neighbor = 0
else:
index_neighbor += 1
print("Medoid set changed {0} times".format(counter))
def __find_another_nearest_medoid(self, point_index, current_medoid_index):
|
def __calculate_estimation(self):
"""!
@brief Calculates estimation (cost) of the current clusters. The lower the estimation,
the more optimally configuration of clusters.
@return (double) estimation of current clusters.
"""
estimation = 0.0
for index_cluster in range(0, len(self.__clusters)):
cluster = self.__clusters[index_cluster]
index_medoid = self.__current[index_cluster]
for index_point in cluster:
estimation += euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[index_medoid])
return estimation
| """!
@brief Finds the another nearest medoid for the specified point that is different from the specified medoid.
@param[in] point_index: index of point in dataspace for that searching of medoid in current list of medoids is perfomed.
@param[in] current_medoid_index: index of medoid that shouldn't be considered as a nearest.
@return (uint) index of the another nearest medoid for the point.
"""
other_medoid_index = -1
other_distance_nearest = float('inf')
for index_medoid in self.__current:
if (index_medoid != current_medoid_index):
other_distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
if other_distance_candidate < other_distance_nearest:
other_distance_nearest = other_distance_candidate
other_medoid_index = index_medoid
return other_medoid_index | identifier_body |
clarans.py | """!
@brief Cluster analysis algorithm: CLARANS.
@details Implementation based on paper @cite article::clarans::1.
@authors Andrei Novikov (pyclustering@yandex.ru)
@date 2014-2019
@copyright GNU Public License
@cond GNU_PUBLIC_LICENSE
PyClustering is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
PyClustering is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@endcond
"""
import random
from pyclustering.cluster.encoder import type_encoding
from pyclustering.utils import euclidean_distance_square
def plot_pam(data, cl, equal_axis_scale = False):
import matplotlib.pyplot as plt
import numpy as np
fig,ax = plt.subplots(figsize=(14,6))
plt.scatter(np.array(data)[:,0], np.array(data)[:,1], s=300, color="white", edgecolor="black")
colors = { 0:"seagreen", 1:'beige', 2:'yellow', 3:'grey',
4:'pink', 5:'turquoise', 6:'orange', 7:'purple', 8:'yellowgreen', 9:'olive', 10:'brown',
11:'tan', 12: 'plum', 13:'rosybrown', 14:'lightblue', 15:"khaki", 16:"gainsboro", 17:"peachpuff"}
for i,el in enumerate(list(cl.values())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=300, color=colors[i%17], edgecolor="black")
for i,el in enumerate(list(cl.keys())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=500, color="red", marker="X", edgecolor="black")
xmin, xmax, ymin, ymax = plt.axis()
xwidth = xmax - xmin
ywidth = ymax - ymin
xw1 = xwidth*0.01
yw1 = ywidth*0.01
xw2 = xwidth*0.005
yw2 = ywidth*0.01
xw3 = xwidth*0.01
yw3 = ywidth*0.01
for i, txt in enumerate(range(len(data))):
if len(str(txt))==2:
ax.annotate(txt, (np.array(data)[:,0][i]-xw1, np.array(data)[:,1][i]-yw1), fontsize=12, size=12)
elif len(str(txt))==1:
ax.annotate(txt, (np.array(data)[:,0][i]-xw2, np.array(data)[:,1][i]-yw2), fontsize=12, size=12)
else:
ax.annotate(txt, (np.array(data)[:,0][i]-xw3, np.array(data)[:,1][i]-yw3), fontsize=9, size=9)
if equal_axis_scale == True:
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
class clarans:
"""!
@brief Class represents clustering algorithm CLARANS (a method for clustering objects for spatial data mining).
"""
def __init__(self, data, number_clusters, numlocal, maxneighbor):
"""!
@brief Constructor of clustering algorithm CLARANS.
@details The higher the value of maxneighbor, the closer is CLARANS to K-Medoids, and the longer is each search of a local minima.
@param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.
@param[in] number_clusters (uint): Amount of clusters that should be allocated.
@param[in] numlocal (uint): The number of local minima obtained (amount of iterations for solving the problem).
@param[in] maxneighbor (uint): The maximum number of neighbors examined.
"""
self.__pointer_data = data
self.__numlocal = numlocal
self.__maxneighbor = maxneighbor
self.__number_clusters = number_clusters
self.__clusters = []
self.__current = []
self.__belong = []
self.__optimal_medoids = []
self.__optimal_estimation = float('inf')
self.__verify_arguments()
def __verify_arguments(self):
"""!
@brief Verify input parameters for the algorithm and throw exception in case of incorrectness.
"""
if len(self.__pointer_data) == 0:
raise ValueError("Input data is empty (size: '%d')." % len(self.__pointer_data))
if self.__number_clusters <= 0:
raise ValueError("Amount of cluster (current value: '%d') for allocation should be greater than 0." %
self.__number_clusters)
if self.__numlocal < 0:
raise ValueError("Local minima (current value: '%d') should be greater or equal to 0." % self.__numlocal)
if self.__maxneighbor < 0:
raise ValueError("Maximum number of neighbors (current value: '%d') should be greater or "
"equal to 0." % self.__maxneighbor)
def process(self, plotting=False):
"""!
@brief Performs cluster analysis in line with rules of CLARANS algorithm.
@return (clarans) Returns itself (CLARANS instance).
@see get_clusters()
@see get_medoids()
"""
random.seed()
# loop for a numlocal number of times
for _ in range(0, self.__numlocal):
print("numlocal: ", _)
# set (current) random medoids
self.__current = random.sample(range(0, len(self.__pointer_data)), self.__number_clusters)
# update clusters in line with random allocated medoids
self.__update_clusters(self.__current)
# optimize configuration
self.__optimize_configuration()
# obtain cost of current cluster configuration and compare it with the best obtained
estimation = self.__calculate_estimation()
if estimation < self.__optimal_estimation:
print("Better configuration found with medoids: {0} and cost: {1}".format(self.__current[:], estimation))
self.__optimal_medoids = self.__current[:]
self.__optimal_estimation = estimation
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
else:
print("Configuration found does not improve current best one because its cost is {0}".format(estimation))
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
self.__update_clusters(self.__optimal_medoids)
return self
def get_clusters(self):
"""!
@brief Returns allocated clusters by the algorithm.
@remark Allocated clusters can be returned only after data processing (use method process()), otherwise empty list is returned.
@return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.
@see process()
@see get_medoids()
"""
return self.__clusters
def get_medoids(self):
"""!
@brief Returns list of medoids of allocated clusters.
@see process()
@see get_clusters()
"""
return self.__optimal_medoids
def get_cluster_encoding(self):
"""!
@brief Returns clustering result representation type that indicate how clusters are encoded.
@return (type_encoding) Clustering result representation.
@see get_clusters()
"""
return type_encoding.CLUSTER_INDEX_LIST_SEPARATION
def __update_clusters(self, medoids):
"""!
@brief Forms cluster in line with specified medoids by calculation distance from each point to medoids.
"""
self.__belong = [0] * len(self.__pointer_data)
self.__clusters = [[] for i in range(len(medoids))]
for index_point in range(len(self.__pointer_data)):
index_optim = -1
dist_optim = 0.0
for index in range(len(medoids)):
dist = euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[medoids[index]])
if (dist < dist_optim) or (index is 0):
index_optim = index
dist_optim = dist
self.__clusters[index_optim].append(index_point)
self.__belong[index_point] = index_optim
# If cluster is not able to capture object it should be removed
self.__clusters = [cluster for cluster in self.__clusters if len(cluster) > 0]
def __optimize_configuration(self):
"""!
@brief Finds quasi-optimal medoids and updates in line with them clusters in line with algorithm's rules.
"""
index_neighbor = 0
counter = 0
while (index_neighbor < self.__maxneighbor):
# get random current medoid that is to be replaced
current_medoid_index = self.__current[random.randint(0, self.__number_clusters - 1)]
current_medoid_cluster_index = self.__belong[current_medoid_index]
# get new candidate to be medoid
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
while candidate_medoid_index in self.__current:
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
candidate_cost = 0.0
for point_index in range(0, len(self.__pointer_data)):
if point_index not in self.__current:
# get non-medoid point and its medoid
point_cluster_index = self.__belong[point_index]
point_medoid_index = self.__current[point_cluster_index]
# get other medoid that is nearest to the point (except current and candidate)
other_medoid_index = self.__find_another_nearest_medoid(point_index, current_medoid_index)
other_medoid_cluster_index = self.__belong[other_medoid_index]
# for optimization calculate all required distances
# from the point to current medoid
distance_current = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
# from the point to candidate median
distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[candidate_medoid_index])
# from the point to nearest (own) medoid
distance_nearest = float('inf')
if ( (point_medoid_index != candidate_medoid_index) and (point_medoid_index != current_medoid_cluster_index) ):
distance_nearest = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[point_medoid_index])
# apply rules for cost calculation
if (point_cluster_index == current_medoid_cluster_index):
# case 1:
if (distance_candidate >= distance_nearest):
|
# case 2:
else:
candidate_cost += distance_candidate - distance_current
elif (point_cluster_index == other_medoid_cluster_index):
# case 3 ('nearest medoid' is the representative object of that cluster and object is more similar to 'nearest' than to 'candidate'):
if (distance_candidate > distance_nearest):
pass;
# case 4:
else:
candidate_cost += distance_candidate - distance_nearest
if (candidate_cost < 0):
counter+=1
# set candidate that has won
self.__current[current_medoid_cluster_index] = candidate_medoid_index
# recalculate clusters
self.__update_clusters(self.__current)
# reset iterations and starts investigation from the begining
index_neighbor = 0
else:
index_neighbor += 1
print("Medoid set changed {0} times".format(counter))
def __find_another_nearest_medoid(self, point_index, current_medoid_index):
"""!
@brief Finds the another nearest medoid for the specified point that is different from the specified medoid.
@param[in] point_index: index of point in dataspace for that searching of medoid in current list of medoids is perfomed.
@param[in] current_medoid_index: index of medoid that shouldn't be considered as a nearest.
@return (uint) index of the another nearest medoid for the point.
"""
other_medoid_index = -1
other_distance_nearest = float('inf')
for index_medoid in self.__current:
if (index_medoid != current_medoid_index):
other_distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
if other_distance_candidate < other_distance_nearest:
other_distance_nearest = other_distance_candidate
other_medoid_index = index_medoid
return other_medoid_index
def __calculate_estimation(self):
"""!
@brief Calculates estimation (cost) of the current clusters. The lower the estimation,
the more optimally configuration of clusters.
@return (double) estimation of current clusters.
"""
estimation = 0.0
for index_cluster in range(0, len(self.__clusters)):
cluster = self.__clusters[index_cluster]
index_medoid = self.__current[index_cluster]
for index_point in cluster:
estimation += euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[index_medoid])
return estimation
| candidate_cost += distance_nearest - distance_current | conditional_block |
clarans.py | """!
@brief Cluster analysis algorithm: CLARANS.
@details Implementation based on paper @cite article::clarans::1.
@authors Andrei Novikov (pyclustering@yandex.ru)
@date 2014-2019
@copyright GNU Public License
@cond GNU_PUBLIC_LICENSE
PyClustering is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
PyClustering is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@endcond
"""
import random
from pyclustering.cluster.encoder import type_encoding
from pyclustering.utils import euclidean_distance_square
def plot_pam(data, cl, equal_axis_scale = False):
import matplotlib.pyplot as plt
import numpy as np
fig,ax = plt.subplots(figsize=(14,6))
plt.scatter(np.array(data)[:,0], np.array(data)[:,1], s=300, color="white", edgecolor="black")
colors = { 0:"seagreen", 1:'beige', 2:'yellow', 3:'grey',
4:'pink', 5:'turquoise', 6:'orange', 7:'purple', 8:'yellowgreen', 9:'olive', 10:'brown',
11:'tan', 12: 'plum', 13:'rosybrown', 14:'lightblue', 15:"khaki", 16:"gainsboro", 17:"peachpuff"}
for i,el in enumerate(list(cl.values())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=300, color=colors[i%17], edgecolor="black")
for i,el in enumerate(list(cl.keys())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=500, color="red", marker="X", edgecolor="black")
xmin, xmax, ymin, ymax = plt.axis()
xwidth = xmax - xmin
ywidth = ymax - ymin
xw1 = xwidth*0.01
yw1 = ywidth*0.01
xw2 = xwidth*0.005
yw2 = ywidth*0.01
xw3 = xwidth*0.01
yw3 = ywidth*0.01
for i, txt in enumerate(range(len(data))):
if len(str(txt))==2:
ax.annotate(txt, (np.array(data)[:,0][i]-xw1, np.array(data)[:,1][i]-yw1), fontsize=12, size=12)
elif len(str(txt))==1:
ax.annotate(txt, (np.array(data)[:,0][i]-xw2, np.array(data)[:,1][i]-yw2), fontsize=12, size=12)
else:
ax.annotate(txt, (np.array(data)[:,0][i]-xw3, np.array(data)[:,1][i]-yw3), fontsize=9, size=9)
if equal_axis_scale == True:
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
class clarans:
"""!
@brief Class represents clustering algorithm CLARANS (a method for clustering objects for spatial data mining).
"""
def __init__(self, data, number_clusters, numlocal, maxneighbor):
"""!
@brief Constructor of clustering algorithm CLARANS.
@details The higher the value of maxneighbor, the closer is CLARANS to K-Medoids, and the longer is each search of a local minima.
@param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.
@param[in] number_clusters (uint): Amount of clusters that should be allocated.
@param[in] numlocal (uint): The number of local minima obtained (amount of iterations for solving the problem).
@param[in] maxneighbor (uint): The maximum number of neighbors examined.
"""
self.__pointer_data = data
self.__numlocal = numlocal
self.__maxneighbor = maxneighbor
self.__number_clusters = number_clusters
self.__clusters = []
self.__current = []
self.__belong = []
self.__optimal_medoids = []
self.__optimal_estimation = float('inf')
self.__verify_arguments()
def __verify_arguments(self):
"""!
@brief Verify input parameters for the algorithm and throw exception in case of incorrectness.
"""
if len(self.__pointer_data) == 0:
raise ValueError("Input data is empty (size: '%d')." % len(self.__pointer_data))
if self.__number_clusters <= 0:
raise ValueError("Amount of cluster (current value: '%d') for allocation should be greater than 0." %
self.__number_clusters)
if self.__numlocal < 0:
raise ValueError("Local minima (current value: '%d') should be greater or equal to 0." % self.__numlocal)
if self.__maxneighbor < 0:
raise ValueError("Maximum number of neighbors (current value: '%d') should be greater or "
"equal to 0." % self.__maxneighbor)
def process(self, plotting=False):
"""!
@brief Performs cluster analysis in line with rules of CLARANS algorithm.
@return (clarans) Returns itself (CLARANS instance).
@see get_clusters()
@see get_medoids()
"""
random.seed()
# loop for a numlocal number of times
for _ in range(0, self.__numlocal):
print("numlocal: ", _)
# set (current) random medoids
self.__current = random.sample(range(0, len(self.__pointer_data)), self.__number_clusters)
# update clusters in line with random allocated medoids
self.__update_clusters(self.__current)
# optimize configuration
self.__optimize_configuration()
# obtain cost of current cluster configuration and compare it with the best obtained
estimation = self.__calculate_estimation()
if estimation < self.__optimal_estimation:
print("Better configuration found with medoids: {0} and cost: {1}".format(self.__current[:], estimation))
self.__optimal_medoids = self.__current[:]
self.__optimal_estimation = estimation
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
else:
print("Configuration found does not improve current best one because its cost is {0}".format(estimation))
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
self.__update_clusters(self.__optimal_medoids)
return self
def | (self):
"""!
@brief Returns allocated clusters by the algorithm.
@remark Allocated clusters can be returned only after data processing (use method process()), otherwise empty list is returned.
@return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.
@see process()
@see get_medoids()
"""
return self.__clusters
def get_medoids(self):
"""!
@brief Returns list of medoids of allocated clusters.
@see process()
@see get_clusters()
"""
return self.__optimal_medoids
def get_cluster_encoding(self):
"""!
@brief Returns clustering result representation type that indicate how clusters are encoded.
@return (type_encoding) Clustering result representation.
@see get_clusters()
"""
return type_encoding.CLUSTER_INDEX_LIST_SEPARATION
def __update_clusters(self, medoids):
"""!
@brief Forms cluster in line with specified medoids by calculation distance from each point to medoids.
"""
self.__belong = [0] * len(self.__pointer_data)
self.__clusters = [[] for i in range(len(medoids))]
for index_point in range(len(self.__pointer_data)):
index_optim = -1
dist_optim = 0.0
for index in range(len(medoids)):
dist = euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[medoids[index]])
if (dist < dist_optim) or (index is 0):
index_optim = index
dist_optim = dist
self.__clusters[index_optim].append(index_point)
self.__belong[index_point] = index_optim
# If cluster is not able to capture object it should be removed
self.__clusters = [cluster for cluster in self.__clusters if len(cluster) > 0]
def __optimize_configuration(self):
"""!
@brief Finds quasi-optimal medoids and updates in line with them clusters in line with algorithm's rules.
"""
index_neighbor = 0
counter = 0
while (index_neighbor < self.__maxneighbor):
# get random current medoid that is to be replaced
current_medoid_index = self.__current[random.randint(0, self.__number_clusters - 1)]
current_medoid_cluster_index = self.__belong[current_medoid_index]
# get new candidate to be medoid
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
while candidate_medoid_index in self.__current:
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
candidate_cost = 0.0
for point_index in range(0, len(self.__pointer_data)):
if point_index not in self.__current:
# get non-medoid point and its medoid
point_cluster_index = self.__belong[point_index]
point_medoid_index = self.__current[point_cluster_index]
# get other medoid that is nearest to the point (except current and candidate)
other_medoid_index = self.__find_another_nearest_medoid(point_index, current_medoid_index)
other_medoid_cluster_index = self.__belong[other_medoid_index]
# for optimization calculate all required distances
# from the point to current medoid
distance_current = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
# from the point to candidate median
distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[candidate_medoid_index])
# from the point to nearest (own) medoid
distance_nearest = float('inf')
if ( (point_medoid_index != candidate_medoid_index) and (point_medoid_index != current_medoid_cluster_index) ):
distance_nearest = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[point_medoid_index])
# apply rules for cost calculation
if (point_cluster_index == current_medoid_cluster_index):
# case 1:
if (distance_candidate >= distance_nearest):
candidate_cost += distance_nearest - distance_current
# case 2:
else:
candidate_cost += distance_candidate - distance_current
elif (point_cluster_index == other_medoid_cluster_index):
# case 3 ('nearest medoid' is the representative object of that cluster and object is more similar to 'nearest' than to 'candidate'):
if (distance_candidate > distance_nearest):
pass;
# case 4:
else:
candidate_cost += distance_candidate - distance_nearest
if (candidate_cost < 0):
counter+=1
# set candidate that has won
self.__current[current_medoid_cluster_index] = candidate_medoid_index
# recalculate clusters
self.__update_clusters(self.__current)
# reset iterations and starts investigation from the begining
index_neighbor = 0
else:
index_neighbor += 1
print("Medoid set changed {0} times".format(counter))
def __find_another_nearest_medoid(self, point_index, current_medoid_index):
"""!
@brief Finds the another nearest medoid for the specified point that is different from the specified medoid.
@param[in] point_index: index of point in dataspace for that searching of medoid in current list of medoids is perfomed.
@param[in] current_medoid_index: index of medoid that shouldn't be considered as a nearest.
@return (uint) index of the another nearest medoid for the point.
"""
other_medoid_index = -1
other_distance_nearest = float('inf')
for index_medoid in self.__current:
if (index_medoid != current_medoid_index):
other_distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
if other_distance_candidate < other_distance_nearest:
other_distance_nearest = other_distance_candidate
other_medoid_index = index_medoid
return other_medoid_index
def __calculate_estimation(self):
"""!
@brief Calculates estimation (cost) of the current clusters. The lower the estimation,
the more optimally configuration of clusters.
@return (double) estimation of current clusters.
"""
estimation = 0.0
for index_cluster in range(0, len(self.__clusters)):
cluster = self.__clusters[index_cluster]
index_medoid = self.__current[index_cluster]
for index_point in cluster:
estimation += euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[index_medoid])
return estimation
| get_clusters | identifier_name |
clarans.py | """!
@brief Cluster analysis algorithm: CLARANS.
@details Implementation based on paper @cite article::clarans::1.
@authors Andrei Novikov (pyclustering@yandex.ru)
@date 2014-2019
@copyright GNU Public License
@cond GNU_PUBLIC_LICENSE
PyClustering is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
PyClustering is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@endcond
"""
import random
from pyclustering.cluster.encoder import type_encoding
from pyclustering.utils import euclidean_distance_square
def plot_pam(data, cl, equal_axis_scale = False):
import matplotlib.pyplot as plt
import numpy as np
fig,ax = plt.subplots(figsize=(14,6))
plt.scatter(np.array(data)[:,0], np.array(data)[:,1], s=300, color="white", edgecolor="black")
colors = { 0:"seagreen", 1:'beige', 2:'yellow', 3:'grey',
4:'pink', 5:'turquoise', 6:'orange', 7:'purple', 8:'yellowgreen', 9:'olive', 10:'brown',
11:'tan', 12: 'plum', 13:'rosybrown', 14:'lightblue', 15:"khaki", 16:"gainsboro", 17:"peachpuff"}
for i,el in enumerate(list(cl.values())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=300, color=colors[i%17], edgecolor="black")
for i,el in enumerate(list(cl.keys())):
plt.scatter(np.array(data)[el,0], np.array(data)[el,1], s=500, color="red", marker="X", edgecolor="black")
xmin, xmax, ymin, ymax = plt.axis()
xwidth = xmax - xmin
ywidth = ymax - ymin
xw1 = xwidth*0.01
yw1 = ywidth*0.01
xw2 = xwidth*0.005
yw2 = ywidth*0.01
xw3 = xwidth*0.01
yw3 = ywidth*0.01
for i, txt in enumerate(range(len(data))):
if len(str(txt))==2:
ax.annotate(txt, (np.array(data)[:,0][i]-xw1, np.array(data)[:,1][i]-yw1), fontsize=12, size=12)
elif len(str(txt))==1:
ax.annotate(txt, (np.array(data)[:,0][i]-xw2, np.array(data)[:,1][i]-yw2), fontsize=12, size=12)
else:
ax.annotate(txt, (np.array(data)[:,0][i]-xw3, np.array(data)[:,1][i]-yw3), fontsize=9, size=9)
if equal_axis_scale == True:
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
class clarans:
"""!
@brief Class represents clustering algorithm CLARANS (a method for clustering objects for spatial data mining).
"""
def __init__(self, data, number_clusters, numlocal, maxneighbor):
"""!
@brief Constructor of clustering algorithm CLARANS.
@details The higher the value of maxneighbor, the closer is CLARANS to K-Medoids, and the longer is each search of a local minima.
@param[in] data (list): Input data that is presented as list of points (objects), each point should be represented by list or tuple.
@param[in] number_clusters (uint): Amount of clusters that should be allocated.
@param[in] numlocal (uint): The number of local minima obtained (amount of iterations for solving the problem).
@param[in] maxneighbor (uint): The maximum number of neighbors examined.
"""
self.__pointer_data = data
self.__numlocal = numlocal
self.__maxneighbor = maxneighbor
self.__number_clusters = number_clusters
self.__clusters = []
self.__current = []
self.__belong = []
self.__optimal_medoids = []
self.__optimal_estimation = float('inf')
self.__verify_arguments()
def __verify_arguments(self):
"""!
@brief Verify input parameters for the algorithm and throw exception in case of incorrectness.
"""
if len(self.__pointer_data) == 0:
raise ValueError("Input data is empty (size: '%d')." % len(self.__pointer_data))
if self.__number_clusters <= 0:
raise ValueError("Amount of cluster (current value: '%d') for allocation should be greater than 0." %
self.__number_clusters)
if self.__numlocal < 0:
raise ValueError("Local minima (current value: '%d') should be greater or equal to 0." % self.__numlocal)
if self.__maxneighbor < 0:
raise ValueError("Maximum number of neighbors (current value: '%d') should be greater or "
"equal to 0." % self.__maxneighbor)
|
@see get_clusters()
@see get_medoids()
"""
random.seed()
# loop for a numlocal number of times
for _ in range(0, self.__numlocal):
print("numlocal: ", _)
# set (current) random medoids
self.__current = random.sample(range(0, len(self.__pointer_data)), self.__number_clusters)
# update clusters in line with random allocated medoids
self.__update_clusters(self.__current)
# optimize configuration
self.__optimize_configuration()
# obtain cost of current cluster configuration and compare it with the best obtained
estimation = self.__calculate_estimation()
if estimation < self.__optimal_estimation:
print("Better configuration found with medoids: {0} and cost: {1}".format(self.__current[:], estimation))
self.__optimal_medoids = self.__current[:]
self.__optimal_estimation = estimation
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
else:
print("Configuration found does not improve current best one because its cost is {0}".format(estimation))
if plotting == True:
self.__update_clusters(self.__optimal_medoids)
plot_pam(self.__pointer_data,
dict(zip(self.__optimal_medoids,self.__clusters)))
self.__update_clusters(self.__optimal_medoids)
return self
def get_clusters(self):
"""!
@brief Returns allocated clusters by the algorithm.
@remark Allocated clusters can be returned only after data processing (use method process()), otherwise empty list is returned.
@return (list) List of allocated clusters, each cluster contains indexes of objects in list of data.
@see process()
@see get_medoids()
"""
return self.__clusters
def get_medoids(self):
"""!
@brief Returns list of medoids of allocated clusters.
@see process()
@see get_clusters()
"""
return self.__optimal_medoids
def get_cluster_encoding(self):
"""!
@brief Returns clustering result representation type that indicate how clusters are encoded.
@return (type_encoding) Clustering result representation.
@see get_clusters()
"""
return type_encoding.CLUSTER_INDEX_LIST_SEPARATION
def __update_clusters(self, medoids):
"""!
@brief Forms cluster in line with specified medoids by calculation distance from each point to medoids.
"""
self.__belong = [0] * len(self.__pointer_data)
self.__clusters = [[] for i in range(len(medoids))]
for index_point in range(len(self.__pointer_data)):
index_optim = -1
dist_optim = 0.0
for index in range(len(medoids)):
dist = euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[medoids[index]])
if (dist < dist_optim) or (index is 0):
index_optim = index
dist_optim = dist
self.__clusters[index_optim].append(index_point)
self.__belong[index_point] = index_optim
# If cluster is not able to capture object it should be removed
self.__clusters = [cluster for cluster in self.__clusters if len(cluster) > 0]
def __optimize_configuration(self):
"""!
@brief Finds quasi-optimal medoids and updates in line with them clusters in line with algorithm's rules.
"""
index_neighbor = 0
counter = 0
while (index_neighbor < self.__maxneighbor):
# get random current medoid that is to be replaced
current_medoid_index = self.__current[random.randint(0, self.__number_clusters - 1)]
current_medoid_cluster_index = self.__belong[current_medoid_index]
# get new candidate to be medoid
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
while candidate_medoid_index in self.__current:
candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)
candidate_cost = 0.0
for point_index in range(0, len(self.__pointer_data)):
if point_index not in self.__current:
# get non-medoid point and its medoid
point_cluster_index = self.__belong[point_index]
point_medoid_index = self.__current[point_cluster_index]
# get other medoid that is nearest to the point (except current and candidate)
other_medoid_index = self.__find_another_nearest_medoid(point_index, current_medoid_index)
other_medoid_cluster_index = self.__belong[other_medoid_index]
# for optimization calculate all required distances
# from the point to current medoid
distance_current = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
# from the point to candidate median
distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[candidate_medoid_index])
# from the point to nearest (own) medoid
distance_nearest = float('inf')
if ( (point_medoid_index != candidate_medoid_index) and (point_medoid_index != current_medoid_cluster_index) ):
distance_nearest = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[point_medoid_index])
# apply rules for cost calculation
if (point_cluster_index == current_medoid_cluster_index):
# case 1:
if (distance_candidate >= distance_nearest):
candidate_cost += distance_nearest - distance_current
# case 2:
else:
candidate_cost += distance_candidate - distance_current
elif (point_cluster_index == other_medoid_cluster_index):
# case 3 ('nearest medoid' is the representative object of that cluster and object is more similar to 'nearest' than to 'candidate'):
if (distance_candidate > distance_nearest):
pass;
# case 4:
else:
candidate_cost += distance_candidate - distance_nearest
if (candidate_cost < 0):
counter+=1
# set candidate that has won
self.__current[current_medoid_cluster_index] = candidate_medoid_index
# recalculate clusters
self.__update_clusters(self.__current)
# reset iterations and starts investigation from the begining
index_neighbor = 0
else:
index_neighbor += 1
print("Medoid set changed {0} times".format(counter))
def __find_another_nearest_medoid(self, point_index, current_medoid_index):
"""!
@brief Finds the another nearest medoid for the specified point that is different from the specified medoid.
@param[in] point_index: index of point in dataspace for that searching of medoid in current list of medoids is perfomed.
@param[in] current_medoid_index: index of medoid that shouldn't be considered as a nearest.
@return (uint) index of the another nearest medoid for the point.
"""
other_medoid_index = -1
other_distance_nearest = float('inf')
for index_medoid in self.__current:
if (index_medoid != current_medoid_index):
other_distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])
if other_distance_candidate < other_distance_nearest:
other_distance_nearest = other_distance_candidate
other_medoid_index = index_medoid
return other_medoid_index
def __calculate_estimation(self):
"""!
@brief Calculates estimation (cost) of the current clusters. The lower the estimation,
the more optimally configuration of clusters.
@return (double) estimation of current clusters.
"""
estimation = 0.0
for index_cluster in range(0, len(self.__clusters)):
cluster = self.__clusters[index_cluster]
index_medoid = self.__current[index_cluster]
for index_point in cluster:
estimation += euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[index_medoid])
return estimation | def process(self, plotting=False):
"""!
@brief Performs cluster analysis in line with rules of CLARANS algorithm.
@return (clarans) Returns itself (CLARANS instance).
| random_line_split |
client.rs | use std::thread;
use std::net::SocketAddr;
use std::net::ToSocketAddrs;
use std::sync::mpsc;
use std::sync::Arc;
use futures;
use futures::Future;
use futures::stream::Stream;
use tokio_core;
use tokio_core::reactor;
use solicit::http::HttpScheme;
use solicit::http::HttpError;
use solicit::http::Header;
use solicit::http::StaticHeader;
use method::MethodDescriptor;
use error::*;
use result::*;
use futures_misc::*;
use futures_grpc::*;
use grpc::*;
use http_client::*;
use solicit_misc::*;
use assert_types::*;
trait GrpcResponseHandlerTrait : Send + 'static + HttpClientResponseHandler {
}
struct GrpcResponseHandlerTyped<Req : Send + 'static, Resp : Send + 'static> {
method: Arc<MethodDescriptor<Req, Resp>>,
complete: tokio_core::channel::Sender<ResultOrEof<Resp, GrpcError>>,
remaining_response: Vec<u8>,
}
impl<Req : Send + 'static, Resp : Send + 'static> GrpcResponseHandlerTrait for GrpcResponseHandlerTyped<Req, Resp> {
}
impl<Req : Send + 'static, Resp : Send + 'static> HttpClientResponseHandler for GrpcResponseHandlerTyped<Req, Resp> {
fn headers(&mut self, headers: Vec<StaticHeader>) -> bool {
println!("client: received headers");
if slice_get_header(&headers, ":status") != Some("200") {
if let Some(message) = slice_get_header(&headers, HEADER_GRPC_MESSAGE) {
self.complete.send(ResultOrEof::Error(GrpcError::GrpcMessage(GrpcMessageError { grpc_message: message.to_owned() }))).unwrap();
} else {
self.complete.send(ResultOrEof::Error(GrpcError::Other("not 200"))).unwrap();
}
false
} else {
true
}
}
fn data_frame(&mut self, chunk: Vec<u8>) -> bool {
self.remaining_response.extend(&chunk);
loop {
let len = match parse_grpc_frame(&self.remaining_response) {
Err(e) => {
self.complete.send(ResultOrEof::Error(e)).unwrap();
return false;
}
Ok(None) => break,
Ok(Some((message, len))) => {
let resp = self.method.resp_marshaller.read(&message);
self.complete.send(From::from(resp)).ok();
len
}
};
self.remaining_response.drain(..len);
}
true
}
fn trailers(&mut self, headers: Vec<StaticHeader>) -> bool {
let _status_200 = slice_get_header(&headers, ":status") == Some("200");
let grpc_status_0 = slice_get_header(&headers, HEADER_GRPC_STATUS) == Some("0");
if /* status_200 && */ grpc_status_0 {
true
} else {
if let Some(message) = slice_get_header(&headers, HEADER_GRPC_MESSAGE) {
self.complete.send(ResultOrEof::Error(GrpcError::GrpcMessage(GrpcMessageError { grpc_message: message.to_owned() }))).unwrap();
} else {
self.complete.send(ResultOrEof::Error(GrpcError::Other("not xxx"))).unwrap();
}
false
}
}
fn end(&mut self) {
self.complete.send(ResultOrEof::Eof).unwrap();
}
}
struct GrpcResponseHandler {
tr: Box<GrpcResponseHandlerTrait>,
}
impl HttpClientResponseHandler for GrpcResponseHandler {
fn headers(&mut self, headers: Vec<StaticHeader>) -> bool {
self.tr.headers(headers) |
fn data_frame(&mut self, chunk: Vec<u8>) -> bool {
self.tr.data_frame(chunk)
}
fn trailers(&mut self, headers: Vec<StaticHeader>) -> bool {
self.tr.trailers(headers)
}
fn end(&mut self) {
self.tr.end()
}
}
// Data sent from event loop to GrpcClient
struct LoopToClient {
// used only once to send shutdown signal
shutdown_tx: tokio_core::channel::Sender<()>,
loop_handle: reactor::Remote,
http_conn: Arc<HttpClientConnectionAsync<GrpcResponseHandler>>,
}
fn _assert_loop_to_client() {
assert_send::<reactor::Remote>();
assert_send::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_send::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_sync::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_send::<Arc<HttpClientConnectionAsync<GrpcResponseHandler>>>();
assert_send::<tokio_core::channel::Sender<()>>();
assert_send::<LoopToClient>();
}
/// gRPC client implementation.
/// Used by generated code.
pub struct GrpcClient {
loop_to_client: LoopToClient,
thread_join_handle: Option<thread::JoinHandle<()>>,
host: String,
http_scheme: HttpScheme,
}
impl GrpcClient {
/// Create a client connected to specified host and port.
pub fn new(host: &str, port: u16) -> GrpcResult<GrpcClient> {
// TODO: sync
// TODO: try connect to all addrs
let socket_addr = try!((host, port).to_socket_addrs()).next().unwrap();
// We need some data back from event loop.
// This channel is used to exchange that data
let (get_from_loop_tx, get_from_loop_rx) = mpsc::channel();
// Start event loop.
let join_handle = thread::spawn(move || {
run_client_event_loop(socket_addr, get_from_loop_tx);
});
// Get back call channel and shutdown channel.
let loop_to_client = try!(get_from_loop_rx.recv()
.map_err(|_| GrpcError::Other("get response from loop")));
Ok(GrpcClient {
loop_to_client: loop_to_client,
thread_join_handle: Some(join_handle),
host: host.to_owned(),
http_scheme: HttpScheme::Http,
})
}
pub fn new_resp_channel<Resp : Send + 'static>(&self)
-> futures::Oneshot<(tokio_core::channel::Sender<ResultOrEof<Resp, GrpcError>>, GrpcStreamSend<Resp>)>
{
let (one_sender, one_receiver) = futures::oneshot();
self.loop_to_client.loop_handle.spawn(move |handle| {
let (sender, receiver) = tokio_core::channel::channel(&handle).unwrap();
let receiver: GrpcStreamSend<ResultOrEof<Resp, GrpcError>> = Box::new(receiver.map_err(GrpcError::from));
let receiver: GrpcStreamSend<Resp> = Box::new(stream_with_eof_and_error(receiver));
one_sender.complete((sender, receiver));
futures::finished(())
});
one_receiver
}
pub fn call_impl<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
let host = self.host.clone();
let http_scheme = self.http_scheme.clone();
let http_conn = self.loop_to_client.http_conn.clone();
// A channel to send response back to caller
let future = self.new_resp_channel().map_err(GrpcError::from).and_then(move |(complete, receiver)| {
let headers = vec![
Header::new(":method", "POST"),
Header::new(":path", method.name.clone()),
Header::new(":authority", host.clone()),
Header::new(":scheme", http_scheme.as_bytes()),
];
let request_frames = {
let method = method.clone();
req
.and_then(move |req| {
let grpc_frame = try!(method.req_marshaller.write(&req));
Ok(write_grpc_frame_to_vec(&grpc_frame))
})
.map_err(|e| HttpError::Other(Box::new(e)))
};
let start_request = http_conn.start_request(
headers,
Box::new(request_frames),
GrpcResponseHandler {
tr: Box::new(GrpcResponseHandlerTyped {
method: method.clone(),
complete: complete,
remaining_response: Vec::new(),
}),
}
).map_err(GrpcError::from);
let receiver: GrpcStreamSend<Resp> = receiver;
start_request.map(move |()| receiver)
});
let s: GrpcStreamSend<Resp> = future_flatten_to_stream(future);
s
}
pub fn call_unary<Req : Send + 'static, Resp : Send + 'static>(&self, req: Req, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcFutureSend<Resp>
{
stream_single_send(self.call_impl(Box::new(stream_once_send(req)), method))
}
pub fn call_server_streaming<Req : Send + 'static, Resp : Send + 'static>(&self, req: Req, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
self.call_impl(stream_once_send(req).boxed(), method)
}
pub fn call_client_streaming<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcFutureSend<Resp>
{
stream_single_send(self.call_impl(req, method))
}
pub fn call_bidi<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
self.call_impl(req, method)
}
}
// We shutdown client in destructor.
impl Drop for GrpcClient {
fn drop(&mut self) {
// ignore error because even loop may be already dead
self.loop_to_client.shutdown_tx.send(()).ok();
// do not ignore errors because we own event loop thread
self.thread_join_handle.take().expect("handle.take")
.join().expect("join thread");
}
}
// Event loop entry point
fn run_client_event_loop(
socket_addr: SocketAddr,
send_to_back: mpsc::Sender<LoopToClient>)
{
// Create an event loop.
let mut lp = reactor::Core::new().unwrap();
// Create a channel to receive shutdown signal.
let (shutdown_tx, shutdown_rx) = tokio_core::channel::channel(&lp.handle()).unwrap();
let (http_conn, http_conn_future) = HttpClientConnectionAsync::new(lp.handle(), &socket_addr);
let http_conn_future: GrpcFuture<_> = Box::new(http_conn_future.map_err(GrpcError::from));
// Send channels back to GrpcClient
send_to_back
.send(LoopToClient {
shutdown_tx: shutdown_tx,
loop_handle: lp.remote(),
http_conn: Arc::new(http_conn),
})
.expect("send back");
let shutdown = shutdown_rx.into_future().map_err(|(e, _)| GrpcError::from(e)).and_then(move |_| {
// Must complete with error,
// so `join` with this future cancels another future.
futures::failed::<(), _>(GrpcError::Other("shutdown"))
});
// Wait for either completion of connection (i. e. error)
// or shutdown signal.
let done = http_conn_future.join(shutdown);
// TODO: do not ignore error
lp.run(done).ok();
} | } | random_line_split |
client.rs | use std::thread;
use std::net::SocketAddr;
use std::net::ToSocketAddrs;
use std::sync::mpsc;
use std::sync::Arc;
use futures;
use futures::Future;
use futures::stream::Stream;
use tokio_core;
use tokio_core::reactor;
use solicit::http::HttpScheme;
use solicit::http::HttpError;
use solicit::http::Header;
use solicit::http::StaticHeader;
use method::MethodDescriptor;
use error::*;
use result::*;
use futures_misc::*;
use futures_grpc::*;
use grpc::*;
use http_client::*;
use solicit_misc::*;
use assert_types::*;
trait GrpcResponseHandlerTrait : Send + 'static + HttpClientResponseHandler {
}
struct GrpcResponseHandlerTyped<Req : Send + 'static, Resp : Send + 'static> {
method: Arc<MethodDescriptor<Req, Resp>>,
complete: tokio_core::channel::Sender<ResultOrEof<Resp, GrpcError>>,
remaining_response: Vec<u8>,
}
impl<Req : Send + 'static, Resp : Send + 'static> GrpcResponseHandlerTrait for GrpcResponseHandlerTyped<Req, Resp> {
}
impl<Req : Send + 'static, Resp : Send + 'static> HttpClientResponseHandler for GrpcResponseHandlerTyped<Req, Resp> {
fn headers(&mut self, headers: Vec<StaticHeader>) -> bool {
println!("client: received headers");
if slice_get_header(&headers, ":status") != Some("200") {
if let Some(message) = slice_get_header(&headers, HEADER_GRPC_MESSAGE) {
self.complete.send(ResultOrEof::Error(GrpcError::GrpcMessage(GrpcMessageError { grpc_message: message.to_owned() }))).unwrap();
} else {
self.complete.send(ResultOrEof::Error(GrpcError::Other("not 200"))).unwrap();
}
false
} else {
true
}
}
fn data_frame(&mut self, chunk: Vec<u8>) -> bool {
self.remaining_response.extend(&chunk);
loop {
let len = match parse_grpc_frame(&self.remaining_response) {
Err(e) => {
self.complete.send(ResultOrEof::Error(e)).unwrap();
return false;
}
Ok(None) => break,
Ok(Some((message, len))) => {
let resp = self.method.resp_marshaller.read(&message);
self.complete.send(From::from(resp)).ok();
len
}
};
self.remaining_response.drain(..len);
}
true
}
fn trailers(&mut self, headers: Vec<StaticHeader>) -> bool {
let _status_200 = slice_get_header(&headers, ":status") == Some("200");
let grpc_status_0 = slice_get_header(&headers, HEADER_GRPC_STATUS) == Some("0");
if /* status_200 && */ grpc_status_0 {
true
} else {
if let Some(message) = slice_get_header(&headers, HEADER_GRPC_MESSAGE) {
self.complete.send(ResultOrEof::Error(GrpcError::GrpcMessage(GrpcMessageError { grpc_message: message.to_owned() }))).unwrap();
} else {
self.complete.send(ResultOrEof::Error(GrpcError::Other("not xxx"))).unwrap();
}
false
}
}
fn end(&mut self) {
self.complete.send(ResultOrEof::Eof).unwrap();
}
}
struct GrpcResponseHandler {
tr: Box<GrpcResponseHandlerTrait>,
}
impl HttpClientResponseHandler for GrpcResponseHandler {
fn headers(&mut self, headers: Vec<StaticHeader>) -> bool {
self.tr.headers(headers)
}
fn data_frame(&mut self, chunk: Vec<u8>) -> bool {
self.tr.data_frame(chunk)
}
fn trailers(&mut self, headers: Vec<StaticHeader>) -> bool {
self.tr.trailers(headers)
}
fn end(&mut self) {
self.tr.end()
}
}
// Data sent from event loop to GrpcClient
struct LoopToClient {
// used only once to send shutdown signal
shutdown_tx: tokio_core::channel::Sender<()>,
loop_handle: reactor::Remote,
http_conn: Arc<HttpClientConnectionAsync<GrpcResponseHandler>>,
}
fn _assert_loop_to_client() {
assert_send::<reactor::Remote>();
assert_send::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_send::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_sync::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_send::<Arc<HttpClientConnectionAsync<GrpcResponseHandler>>>();
assert_send::<tokio_core::channel::Sender<()>>();
assert_send::<LoopToClient>();
}
/// gRPC client implementation.
/// Used by generated code.
pub struct GrpcClient {
loop_to_client: LoopToClient,
thread_join_handle: Option<thread::JoinHandle<()>>,
host: String,
http_scheme: HttpScheme,
}
impl GrpcClient {
/// Create a client connected to specified host and port.
pub fn new(host: &str, port: u16) -> GrpcResult<GrpcClient> {
// TODO: sync
// TODO: try connect to all addrs
let socket_addr = try!((host, port).to_socket_addrs()).next().unwrap();
// We need some data back from event loop.
// This channel is used to exchange that data
let (get_from_loop_tx, get_from_loop_rx) = mpsc::channel();
// Start event loop.
let join_handle = thread::spawn(move || {
run_client_event_loop(socket_addr, get_from_loop_tx);
});
// Get back call channel and shutdown channel.
let loop_to_client = try!(get_from_loop_rx.recv()
.map_err(|_| GrpcError::Other("get response from loop")));
Ok(GrpcClient {
loop_to_client: loop_to_client,
thread_join_handle: Some(join_handle),
host: host.to_owned(),
http_scheme: HttpScheme::Http,
})
}
pub fn new_resp_channel<Resp : Send + 'static>(&self)
-> futures::Oneshot<(tokio_core::channel::Sender<ResultOrEof<Resp, GrpcError>>, GrpcStreamSend<Resp>)>
{
let (one_sender, one_receiver) = futures::oneshot();
self.loop_to_client.loop_handle.spawn(move |handle| {
let (sender, receiver) = tokio_core::channel::channel(&handle).unwrap();
let receiver: GrpcStreamSend<ResultOrEof<Resp, GrpcError>> = Box::new(receiver.map_err(GrpcError::from));
let receiver: GrpcStreamSend<Resp> = Box::new(stream_with_eof_and_error(receiver));
one_sender.complete((sender, receiver));
futures::finished(())
});
one_receiver
}
pub fn call_impl<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
let host = self.host.clone();
let http_scheme = self.http_scheme.clone();
let http_conn = self.loop_to_client.http_conn.clone();
// A channel to send response back to caller
let future = self.new_resp_channel().map_err(GrpcError::from).and_then(move |(complete, receiver)| {
let headers = vec![
Header::new(":method", "POST"),
Header::new(":path", method.name.clone()),
Header::new(":authority", host.clone()),
Header::new(":scheme", http_scheme.as_bytes()),
];
let request_frames = {
let method = method.clone();
req
.and_then(move |req| {
let grpc_frame = try!(method.req_marshaller.write(&req));
Ok(write_grpc_frame_to_vec(&grpc_frame))
})
.map_err(|e| HttpError::Other(Box::new(e)))
};
let start_request = http_conn.start_request(
headers,
Box::new(request_frames),
GrpcResponseHandler {
tr: Box::new(GrpcResponseHandlerTyped {
method: method.clone(),
complete: complete,
remaining_response: Vec::new(),
}),
}
).map_err(GrpcError::from);
let receiver: GrpcStreamSend<Resp> = receiver;
start_request.map(move |()| receiver)
});
let s: GrpcStreamSend<Resp> = future_flatten_to_stream(future);
s
}
pub fn call_unary<Req : Send + 'static, Resp : Send + 'static>(&self, req: Req, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcFutureSend<Resp>
{
stream_single_send(self.call_impl(Box::new(stream_once_send(req)), method))
}
pub fn call_server_streaming<Req : Send + 'static, Resp : Send + 'static>(&self, req: Req, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
self.call_impl(stream_once_send(req).boxed(), method)
}
pub fn | <Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcFutureSend<Resp>
{
stream_single_send(self.call_impl(req, method))
}
pub fn call_bidi<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
self.call_impl(req, method)
}
}
// We shutdown client in destructor.
impl Drop for GrpcClient {
fn drop(&mut self) {
// ignore error because even loop may be already dead
self.loop_to_client.shutdown_tx.send(()).ok();
// do not ignore errors because we own event loop thread
self.thread_join_handle.take().expect("handle.take")
.join().expect("join thread");
}
}
// Event loop entry point
fn run_client_event_loop(
socket_addr: SocketAddr,
send_to_back: mpsc::Sender<LoopToClient>)
{
// Create an event loop.
let mut lp = reactor::Core::new().unwrap();
// Create a channel to receive shutdown signal.
let (shutdown_tx, shutdown_rx) = tokio_core::channel::channel(&lp.handle()).unwrap();
let (http_conn, http_conn_future) = HttpClientConnectionAsync::new(lp.handle(), &socket_addr);
let http_conn_future: GrpcFuture<_> = Box::new(http_conn_future.map_err(GrpcError::from));
// Send channels back to GrpcClient
send_to_back
.send(LoopToClient {
shutdown_tx: shutdown_tx,
loop_handle: lp.remote(),
http_conn: Arc::new(http_conn),
})
.expect("send back");
let shutdown = shutdown_rx.into_future().map_err(|(e, _)| GrpcError::from(e)).and_then(move |_| {
// Must complete with error,
// so `join` with this future cancels another future.
futures::failed::<(), _>(GrpcError::Other("shutdown"))
});
// Wait for either completion of connection (i. e. error)
// or shutdown signal.
let done = http_conn_future.join(shutdown);
// TODO: do not ignore error
lp.run(done).ok();
}
| call_client_streaming | identifier_name |
client.rs | use std::thread;
use std::net::SocketAddr;
use std::net::ToSocketAddrs;
use std::sync::mpsc;
use std::sync::Arc;
use futures;
use futures::Future;
use futures::stream::Stream;
use tokio_core;
use tokio_core::reactor;
use solicit::http::HttpScheme;
use solicit::http::HttpError;
use solicit::http::Header;
use solicit::http::StaticHeader;
use method::MethodDescriptor;
use error::*;
use result::*;
use futures_misc::*;
use futures_grpc::*;
use grpc::*;
use http_client::*;
use solicit_misc::*;
use assert_types::*;
trait GrpcResponseHandlerTrait : Send + 'static + HttpClientResponseHandler {
}
struct GrpcResponseHandlerTyped<Req : Send + 'static, Resp : Send + 'static> {
method: Arc<MethodDescriptor<Req, Resp>>,
complete: tokio_core::channel::Sender<ResultOrEof<Resp, GrpcError>>,
remaining_response: Vec<u8>,
}
impl<Req : Send + 'static, Resp : Send + 'static> GrpcResponseHandlerTrait for GrpcResponseHandlerTyped<Req, Resp> {
}
impl<Req : Send + 'static, Resp : Send + 'static> HttpClientResponseHandler for GrpcResponseHandlerTyped<Req, Resp> {
fn headers(&mut self, headers: Vec<StaticHeader>) -> bool {
println!("client: received headers");
if slice_get_header(&headers, ":status") != Some("200") {
if let Some(message) = slice_get_header(&headers, HEADER_GRPC_MESSAGE) {
self.complete.send(ResultOrEof::Error(GrpcError::GrpcMessage(GrpcMessageError { grpc_message: message.to_owned() }))).unwrap();
} else {
self.complete.send(ResultOrEof::Error(GrpcError::Other("not 200"))).unwrap();
}
false
} else {
true
}
}
fn data_frame(&mut self, chunk: Vec<u8>) -> bool {
self.remaining_response.extend(&chunk);
loop {
let len = match parse_grpc_frame(&self.remaining_response) {
Err(e) => {
self.complete.send(ResultOrEof::Error(e)).unwrap();
return false;
}
Ok(None) => break,
Ok(Some((message, len))) => {
let resp = self.method.resp_marshaller.read(&message);
self.complete.send(From::from(resp)).ok();
len
}
};
self.remaining_response.drain(..len);
}
true
}
fn trailers(&mut self, headers: Vec<StaticHeader>) -> bool {
let _status_200 = slice_get_header(&headers, ":status") == Some("200");
let grpc_status_0 = slice_get_header(&headers, HEADER_GRPC_STATUS) == Some("0");
if /* status_200 && */ grpc_status_0 {
true
} else {
if let Some(message) = slice_get_header(&headers, HEADER_GRPC_MESSAGE) {
self.complete.send(ResultOrEof::Error(GrpcError::GrpcMessage(GrpcMessageError { grpc_message: message.to_owned() }))).unwrap();
} else {
self.complete.send(ResultOrEof::Error(GrpcError::Other("not xxx"))).unwrap();
}
false
}
}
fn end(&mut self) {
self.complete.send(ResultOrEof::Eof).unwrap();
}
}
struct GrpcResponseHandler {
tr: Box<GrpcResponseHandlerTrait>,
}
impl HttpClientResponseHandler for GrpcResponseHandler {
fn headers(&mut self, headers: Vec<StaticHeader>) -> bool {
self.tr.headers(headers)
}
fn data_frame(&mut self, chunk: Vec<u8>) -> bool {
self.tr.data_frame(chunk)
}
fn trailers(&mut self, headers: Vec<StaticHeader>) -> bool {
self.tr.trailers(headers)
}
fn end(&mut self) {
self.tr.end()
}
}
// Data sent from event loop to GrpcClient
struct LoopToClient {
// used only once to send shutdown signal
shutdown_tx: tokio_core::channel::Sender<()>,
loop_handle: reactor::Remote,
http_conn: Arc<HttpClientConnectionAsync<GrpcResponseHandler>>,
}
fn _assert_loop_to_client() {
assert_send::<reactor::Remote>();
assert_send::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_send::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_sync::<HttpClientConnectionAsync<GrpcResponseHandler>>();
assert_send::<Arc<HttpClientConnectionAsync<GrpcResponseHandler>>>();
assert_send::<tokio_core::channel::Sender<()>>();
assert_send::<LoopToClient>();
}
/// gRPC client implementation.
/// Used by generated code.
pub struct GrpcClient {
loop_to_client: LoopToClient,
thread_join_handle: Option<thread::JoinHandle<()>>,
host: String,
http_scheme: HttpScheme,
}
impl GrpcClient {
/// Create a client connected to specified host and port.
pub fn new(host: &str, port: u16) -> GrpcResult<GrpcClient> {
// TODO: sync
// TODO: try connect to all addrs
let socket_addr = try!((host, port).to_socket_addrs()).next().unwrap();
// We need some data back from event loop.
// This channel is used to exchange that data
let (get_from_loop_tx, get_from_loop_rx) = mpsc::channel();
// Start event loop.
let join_handle = thread::spawn(move || {
run_client_event_loop(socket_addr, get_from_loop_tx);
});
// Get back call channel and shutdown channel.
let loop_to_client = try!(get_from_loop_rx.recv()
.map_err(|_| GrpcError::Other("get response from loop")));
Ok(GrpcClient {
loop_to_client: loop_to_client,
thread_join_handle: Some(join_handle),
host: host.to_owned(),
http_scheme: HttpScheme::Http,
})
}
pub fn new_resp_channel<Resp : Send + 'static>(&self)
-> futures::Oneshot<(tokio_core::channel::Sender<ResultOrEof<Resp, GrpcError>>, GrpcStreamSend<Resp>)>
{
let (one_sender, one_receiver) = futures::oneshot();
self.loop_to_client.loop_handle.spawn(move |handle| {
let (sender, receiver) = tokio_core::channel::channel(&handle).unwrap();
let receiver: GrpcStreamSend<ResultOrEof<Resp, GrpcError>> = Box::new(receiver.map_err(GrpcError::from));
let receiver: GrpcStreamSend<Resp> = Box::new(stream_with_eof_and_error(receiver));
one_sender.complete((sender, receiver));
futures::finished(())
});
one_receiver
}
pub fn call_impl<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
let host = self.host.clone();
let http_scheme = self.http_scheme.clone();
let http_conn = self.loop_to_client.http_conn.clone();
// A channel to send response back to caller
let future = self.new_resp_channel().map_err(GrpcError::from).and_then(move |(complete, receiver)| {
let headers = vec![
Header::new(":method", "POST"),
Header::new(":path", method.name.clone()),
Header::new(":authority", host.clone()),
Header::new(":scheme", http_scheme.as_bytes()),
];
let request_frames = {
let method = method.clone();
req
.and_then(move |req| {
let grpc_frame = try!(method.req_marshaller.write(&req));
Ok(write_grpc_frame_to_vec(&grpc_frame))
})
.map_err(|e| HttpError::Other(Box::new(e)))
};
let start_request = http_conn.start_request(
headers,
Box::new(request_frames),
GrpcResponseHandler {
tr: Box::new(GrpcResponseHandlerTyped {
method: method.clone(),
complete: complete,
remaining_response: Vec::new(),
}),
}
).map_err(GrpcError::from);
let receiver: GrpcStreamSend<Resp> = receiver;
start_request.map(move |()| receiver)
});
let s: GrpcStreamSend<Resp> = future_flatten_to_stream(future);
s
}
pub fn call_unary<Req : Send + 'static, Resp : Send + 'static>(&self, req: Req, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcFutureSend<Resp>
{
stream_single_send(self.call_impl(Box::new(stream_once_send(req)), method))
}
pub fn call_server_streaming<Req : Send + 'static, Resp : Send + 'static>(&self, req: Req, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
self.call_impl(stream_once_send(req).boxed(), method)
}
pub fn call_client_streaming<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcFutureSend<Resp>
{
stream_single_send(self.call_impl(req, method))
}
pub fn call_bidi<Req : Send + 'static, Resp : Send + 'static>(&self, req: GrpcStreamSend<Req>, method: Arc<MethodDescriptor<Req, Resp>>)
-> GrpcStreamSend<Resp>
{
self.call_impl(req, method)
}
}
// We shutdown client in destructor.
impl Drop for GrpcClient {
fn drop(&mut self) |
}
// Event loop entry point
fn run_client_event_loop(
socket_addr: SocketAddr,
send_to_back: mpsc::Sender<LoopToClient>)
{
// Create an event loop.
let mut lp = reactor::Core::new().unwrap();
// Create a channel to receive shutdown signal.
let (shutdown_tx, shutdown_rx) = tokio_core::channel::channel(&lp.handle()).unwrap();
let (http_conn, http_conn_future) = HttpClientConnectionAsync::new(lp.handle(), &socket_addr);
let http_conn_future: GrpcFuture<_> = Box::new(http_conn_future.map_err(GrpcError::from));
// Send channels back to GrpcClient
send_to_back
.send(LoopToClient {
shutdown_tx: shutdown_tx,
loop_handle: lp.remote(),
http_conn: Arc::new(http_conn),
})
.expect("send back");
let shutdown = shutdown_rx.into_future().map_err(|(e, _)| GrpcError::from(e)).and_then(move |_| {
// Must complete with error,
// so `join` with this future cancels another future.
futures::failed::<(), _>(GrpcError::Other("shutdown"))
});
// Wait for either completion of connection (i. e. error)
// or shutdown signal.
let done = http_conn_future.join(shutdown);
// TODO: do not ignore error
lp.run(done).ok();
}
| {
// ignore error because even loop may be already dead
self.loop_to_client.shutdown_tx.send(()).ok();
// do not ignore errors because we own event loop thread
self.thread_join_handle.take().expect("handle.take")
.join().expect("join thread");
} | identifier_body |
fixed.rs | // Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you 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.
use crate::array::PrimitiveArray;
use crate::null_sentinel;
use arrow_array::builder::BufferBuilder;
use arrow_array::{ArrowPrimitiveType, BooleanArray, FixedSizeBinaryArray};
use arrow_buffer::{bit_util, i256, ArrowNativeType, Buffer, MutableBuffer};
use arrow_data::{ArrayData, ArrayDataBuilder};
use arrow_schema::{DataType, SortOptions};
use half::f16;
pub trait FromSlice {
fn from_slice(slice: &[u8], invert: bool) -> Self;
}
impl<const N: usize> FromSlice for [u8; N] {
#[inline]
fn from_slice(slice: &[u8], invert: bool) -> Self {
let mut t: Self = slice.try_into().unwrap();
if invert {
t.iter_mut().for_each(|o| *o = !*o);
}
t
}
}
/// Encodes a value of a particular fixed width type into bytes according to the rules
/// described on [`super::RowConverter`]
pub trait FixedLengthEncoding: Copy {
const ENCODED_LEN: usize = 1 + std::mem::size_of::<Self::Encoded>();
type Encoded: Sized + Copy + FromSlice + AsRef<[u8]> + AsMut<[u8]>;
fn encode(self) -> Self::Encoded;
fn decode(encoded: Self::Encoded) -> Self;
}
impl FixedLengthEncoding for bool {
type Encoded = [u8; 1];
fn encode(self) -> [u8; 1] {
[self as u8]
}
fn decode(encoded: Self::Encoded) -> Self {
encoded[0] != 0
}
}
macro_rules! encode_signed {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
let mut b = self.to_be_bytes();
// Toggle top "sign" bit to ensure consistent sort order
b[0] ^= 0x80;
b
}
fn decode(mut encoded: Self::Encoded) -> Self {
// Toggle top "sign" bit
encoded[0] ^= 0x80;
Self::from_be_bytes(encoded)
}
}
};
}
encode_signed!(1, i8);
encode_signed!(2, i16);
encode_signed!(4, i32);
encode_signed!(8, i64);
encode_signed!(16, i128);
encode_signed!(32, i256);
macro_rules! encode_unsigned {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
self.to_be_bytes()
}
fn decode(encoded: Self::Encoded) -> Self {
Self::from_be_bytes(encoded)
}
}
};
}
encode_unsigned!(1, u8);
encode_unsigned!(2, u16);
encode_unsigned!(4, u32);
encode_unsigned!(8, u64);
impl FixedLengthEncoding for f16 {
type Encoded = [u8; 2];
fn encode(self) -> [u8; 2] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i16;
let val = s ^ (((s >> 15) as u16) >> 1) as i16;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i16::decode(encoded);
let val = bits ^ (((bits >> 15) as u16) >> 1) as i16;
Self::from_bits(val as u16)
}
}
impl FixedLengthEncoding for f32 {
type Encoded = [u8; 4];
fn encode(self) -> [u8; 4] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i32;
let val = s ^ (((s >> 31) as u32) >> 1) as i32;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i32::decode(encoded);
let val = bits ^ (((bits >> 31) as u32) >> 1) as i32;
Self::from_bits(val as u32)
}
}
impl FixedLengthEncoding for f64 {
type Encoded = [u8; 8];
fn encode(self) -> [u8; 8] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i64;
let val = s ^ (((s >> 63) as u64) >> 1) as i64;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i64::decode(encoded);
let val = bits ^ (((bits >> 63) as u64) >> 1) as i64;
Self::from_bits(val as u64)
}
}
/// Returns the total encoded length (including null byte) for a value of type `T::Native`
pub const fn | <T>(_col: &PrimitiveArray<T>) -> usize
where
T: ArrowPrimitiveType,
T::Native: FixedLengthEncoding,
{
T::Native::ENCODED_LEN
}
/// Fixed width types are encoded as
///
/// - 1 byte `0` if null or `1` if valid
/// - bytes of [`FixedLengthEncoding`]
pub fn encode<T: FixedLengthEncoding, I: IntoIterator<Item = Option<T>>>(
data: &mut [u8],
offsets: &mut [usize],
i: I,
opts: SortOptions,
) {
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(i) {
let end_offset = *offset + T::ENCODED_LEN;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
let mut encoded = val.encode();
if opts.descending {
// Flip bits to reverse order
encoded.as_mut().iter_mut().for_each(|v| *v = !*v)
}
to_write[1..].copy_from_slice(encoded.as_ref())
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
pub fn encode_fixed_size_binary(
data: &mut [u8],
offsets: &mut [usize],
array: &FixedSizeBinaryArray,
opts: SortOptions,
) {
let len = array.value_length() as usize;
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(array.iter()) {
let end_offset = *offset + len + 1;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
to_write[1..].copy_from_slice(&val[..len]);
if opts.descending {
// Flip bits to reverse order
to_write[1..1 + len].iter_mut().for_each(|v| *v = !*v)
}
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
/// Splits `len` bytes from `src`
#[inline]
fn split_off<'a>(src: &mut &'a [u8], len: usize) -> &'a [u8] {
let v = &src[..len];
*src = &src[len..];
v
}
/// Decodes a `BooleanArray` from rows
pub fn decode_bool(rows: &mut [&[u8]], options: SortOptions) -> BooleanArray {
let true_val = match options.descending {
true => !1,
false => 1,
};
let len = rows.len();
let mut null_count = 0;
let mut nulls = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let mut values = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let chunks = len / 64;
let remainder = len % 64;
for chunk in 0..chunks {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..64 {
let i = split_off(&mut rows[bit_idx + chunk * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
if remainder != 0 {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..remainder {
let i = split_off(&mut rows[bit_idx + chunks * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
let builder = ArrayDataBuilder::new(DataType::Boolean)
.len(rows.len())
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls.into()));
// SAFETY:
// Buffers are the correct length
unsafe { BooleanArray::from(builder.build_unchecked()) }
}
/// Decodes a single byte from each row, interpreting `0x01` as a valid value
/// and all other values as a null
///
/// Returns the null count and null buffer
pub fn decode_nulls(rows: &[&[u8]]) -> (usize, Buffer) {
let mut null_count = 0;
let buffer = MutableBuffer::collect_bool(rows.len(), |idx| {
let valid = rows[idx][0] == 1;
null_count += !valid as usize;
valid
})
.into();
(null_count, buffer)
}
/// Decodes a `ArrayData` from rows based on the provided `FixedLengthEncoding` `T`
///
/// # Safety
///
/// `data_type` must be appropriate native type for `T`
unsafe fn decode_fixed<T: FixedLengthEncoding + ArrowNativeType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> ArrayData {
let len = rows.len();
let mut values = BufferBuilder::<T>::new(len);
let (null_count, nulls) = decode_nulls(rows);
for row in rows {
let i = split_off(row, T::ENCODED_LEN);
let value = T::Encoded::from_slice(&i[1..], options.descending);
values.append(T::decode(value));
}
let builder = ArrayDataBuilder::new(data_type)
.len(len)
.null_count(null_count)
.add_buffer(values.finish())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
builder.build_unchecked()
}
/// Decodes a `PrimitiveArray` from rows
pub fn decode_primitive<T: ArrowPrimitiveType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> PrimitiveArray<T>
where
T::Native: FixedLengthEncoding,
{
assert!(PrimitiveArray::<T>::is_compatible(&data_type));
// SAFETY:
// Validated data type above
unsafe { decode_fixed::<T::Native>(rows, data_type, options).into() }
}
/// Decodes a `FixedLengthBinary` from rows
pub fn decode_fixed_size_binary(
rows: &mut [&[u8]],
size: i32,
options: SortOptions,
) -> FixedSizeBinaryArray {
let len = rows.len();
let mut values = MutableBuffer::new(size as usize * rows.len());
let (null_count, nulls) = decode_nulls(rows);
let encoded_len = size as usize + 1;
for row in rows {
let i = split_off(row, encoded_len);
values.extend_from_slice(&i[1..]);
}
if options.descending {
for v in values.as_slice_mut() {
*v = !*v;
}
}
let builder = ArrayDataBuilder::new(DataType::FixedSizeBinary(size))
.len(len)
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
unsafe { builder.build_unchecked().into() }
}
| encoded_len | identifier_name |
fixed.rs | // Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you 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.
use crate::array::PrimitiveArray;
use crate::null_sentinel;
use arrow_array::builder::BufferBuilder;
use arrow_array::{ArrowPrimitiveType, BooleanArray, FixedSizeBinaryArray};
use arrow_buffer::{bit_util, i256, ArrowNativeType, Buffer, MutableBuffer};
use arrow_data::{ArrayData, ArrayDataBuilder};
use arrow_schema::{DataType, SortOptions};
use half::f16;
pub trait FromSlice {
fn from_slice(slice: &[u8], invert: bool) -> Self;
}
impl<const N: usize> FromSlice for [u8; N] {
#[inline]
fn from_slice(slice: &[u8], invert: bool) -> Self {
let mut t: Self = slice.try_into().unwrap();
if invert {
t.iter_mut().for_each(|o| *o = !*o);
}
t
}
}
/// Encodes a value of a particular fixed width type into bytes according to the rules
/// described on [`super::RowConverter`]
pub trait FixedLengthEncoding: Copy {
const ENCODED_LEN: usize = 1 + std::mem::size_of::<Self::Encoded>();
type Encoded: Sized + Copy + FromSlice + AsRef<[u8]> + AsMut<[u8]>;
fn encode(self) -> Self::Encoded;
fn decode(encoded: Self::Encoded) -> Self;
}
impl FixedLengthEncoding for bool {
type Encoded = [u8; 1];
fn encode(self) -> [u8; 1] {
[self as u8]
}
fn decode(encoded: Self::Encoded) -> Self {
encoded[0] != 0
}
}
macro_rules! encode_signed {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
let mut b = self.to_be_bytes();
// Toggle top "sign" bit to ensure consistent sort order
b[0] ^= 0x80;
b
}
fn decode(mut encoded: Self::Encoded) -> Self {
// Toggle top "sign" bit
encoded[0] ^= 0x80;
Self::from_be_bytes(encoded)
}
}
};
}
encode_signed!(1, i8);
encode_signed!(2, i16);
encode_signed!(4, i32);
encode_signed!(8, i64);
encode_signed!(16, i128);
encode_signed!(32, i256);
macro_rules! encode_unsigned {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
self.to_be_bytes()
}
fn decode(encoded: Self::Encoded) -> Self {
Self::from_be_bytes(encoded)
}
}
};
}
encode_unsigned!(1, u8);
encode_unsigned!(2, u16);
encode_unsigned!(4, u32);
encode_unsigned!(8, u64);
impl FixedLengthEncoding for f16 {
type Encoded = [u8; 2];
fn encode(self) -> [u8; 2] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i16;
let val = s ^ (((s >> 15) as u16) >> 1) as i16;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i16::decode(encoded);
let val = bits ^ (((bits >> 15) as u16) >> 1) as i16;
Self::from_bits(val as u16)
}
}
impl FixedLengthEncoding for f32 {
type Encoded = [u8; 4];
fn encode(self) -> [u8; 4] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i32;
let val = s ^ (((s >> 31) as u32) >> 1) as i32;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i32::decode(encoded);
let val = bits ^ (((bits >> 31) as u32) >> 1) as i32;
Self::from_bits(val as u32)
}
}
|
fn encode(self) -> [u8; 8] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i64;
let val = s ^ (((s >> 63) as u64) >> 1) as i64;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i64::decode(encoded);
let val = bits ^ (((bits >> 63) as u64) >> 1) as i64;
Self::from_bits(val as u64)
}
}
/// Returns the total encoded length (including null byte) for a value of type `T::Native`
pub const fn encoded_len<T>(_col: &PrimitiveArray<T>) -> usize
where
T: ArrowPrimitiveType,
T::Native: FixedLengthEncoding,
{
T::Native::ENCODED_LEN
}
/// Fixed width types are encoded as
///
/// - 1 byte `0` if null or `1` if valid
/// - bytes of [`FixedLengthEncoding`]
pub fn encode<T: FixedLengthEncoding, I: IntoIterator<Item = Option<T>>>(
data: &mut [u8],
offsets: &mut [usize],
i: I,
opts: SortOptions,
) {
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(i) {
let end_offset = *offset + T::ENCODED_LEN;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
let mut encoded = val.encode();
if opts.descending {
// Flip bits to reverse order
encoded.as_mut().iter_mut().for_each(|v| *v = !*v)
}
to_write[1..].copy_from_slice(encoded.as_ref())
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
pub fn encode_fixed_size_binary(
data: &mut [u8],
offsets: &mut [usize],
array: &FixedSizeBinaryArray,
opts: SortOptions,
) {
let len = array.value_length() as usize;
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(array.iter()) {
let end_offset = *offset + len + 1;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
to_write[1..].copy_from_slice(&val[..len]);
if opts.descending {
// Flip bits to reverse order
to_write[1..1 + len].iter_mut().for_each(|v| *v = !*v)
}
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
/// Splits `len` bytes from `src`
#[inline]
fn split_off<'a>(src: &mut &'a [u8], len: usize) -> &'a [u8] {
let v = &src[..len];
*src = &src[len..];
v
}
/// Decodes a `BooleanArray` from rows
pub fn decode_bool(rows: &mut [&[u8]], options: SortOptions) -> BooleanArray {
let true_val = match options.descending {
true => !1,
false => 1,
};
let len = rows.len();
let mut null_count = 0;
let mut nulls = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let mut values = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let chunks = len / 64;
let remainder = len % 64;
for chunk in 0..chunks {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..64 {
let i = split_off(&mut rows[bit_idx + chunk * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
if remainder != 0 {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..remainder {
let i = split_off(&mut rows[bit_idx + chunks * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
let builder = ArrayDataBuilder::new(DataType::Boolean)
.len(rows.len())
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls.into()));
// SAFETY:
// Buffers are the correct length
unsafe { BooleanArray::from(builder.build_unchecked()) }
}
/// Decodes a single byte from each row, interpreting `0x01` as a valid value
/// and all other values as a null
///
/// Returns the null count and null buffer
pub fn decode_nulls(rows: &[&[u8]]) -> (usize, Buffer) {
let mut null_count = 0;
let buffer = MutableBuffer::collect_bool(rows.len(), |idx| {
let valid = rows[idx][0] == 1;
null_count += !valid as usize;
valid
})
.into();
(null_count, buffer)
}
/// Decodes a `ArrayData` from rows based on the provided `FixedLengthEncoding` `T`
///
/// # Safety
///
/// `data_type` must be appropriate native type for `T`
unsafe fn decode_fixed<T: FixedLengthEncoding + ArrowNativeType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> ArrayData {
let len = rows.len();
let mut values = BufferBuilder::<T>::new(len);
let (null_count, nulls) = decode_nulls(rows);
for row in rows {
let i = split_off(row, T::ENCODED_LEN);
let value = T::Encoded::from_slice(&i[1..], options.descending);
values.append(T::decode(value));
}
let builder = ArrayDataBuilder::new(data_type)
.len(len)
.null_count(null_count)
.add_buffer(values.finish())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
builder.build_unchecked()
}
/// Decodes a `PrimitiveArray` from rows
pub fn decode_primitive<T: ArrowPrimitiveType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> PrimitiveArray<T>
where
T::Native: FixedLengthEncoding,
{
assert!(PrimitiveArray::<T>::is_compatible(&data_type));
// SAFETY:
// Validated data type above
unsafe { decode_fixed::<T::Native>(rows, data_type, options).into() }
}
/// Decodes a `FixedLengthBinary` from rows
pub fn decode_fixed_size_binary(
rows: &mut [&[u8]],
size: i32,
options: SortOptions,
) -> FixedSizeBinaryArray {
let len = rows.len();
let mut values = MutableBuffer::new(size as usize * rows.len());
let (null_count, nulls) = decode_nulls(rows);
let encoded_len = size as usize + 1;
for row in rows {
let i = split_off(row, encoded_len);
values.extend_from_slice(&i[1..]);
}
if options.descending {
for v in values.as_slice_mut() {
*v = !*v;
}
}
let builder = ArrayDataBuilder::new(DataType::FixedSizeBinary(size))
.len(len)
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
unsafe { builder.build_unchecked().into() }
} | impl FixedLengthEncoding for f64 {
type Encoded = [u8; 8]; | random_line_split |
fixed.rs | // Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you 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.
use crate::array::PrimitiveArray;
use crate::null_sentinel;
use arrow_array::builder::BufferBuilder;
use arrow_array::{ArrowPrimitiveType, BooleanArray, FixedSizeBinaryArray};
use arrow_buffer::{bit_util, i256, ArrowNativeType, Buffer, MutableBuffer};
use arrow_data::{ArrayData, ArrayDataBuilder};
use arrow_schema::{DataType, SortOptions};
use half::f16;
pub trait FromSlice {
fn from_slice(slice: &[u8], invert: bool) -> Self;
}
impl<const N: usize> FromSlice for [u8; N] {
#[inline]
fn from_slice(slice: &[u8], invert: bool) -> Self {
let mut t: Self = slice.try_into().unwrap();
if invert {
t.iter_mut().for_each(|o| *o = !*o);
}
t
}
}
/// Encodes a value of a particular fixed width type into bytes according to the rules
/// described on [`super::RowConverter`]
pub trait FixedLengthEncoding: Copy {
const ENCODED_LEN: usize = 1 + std::mem::size_of::<Self::Encoded>();
type Encoded: Sized + Copy + FromSlice + AsRef<[u8]> + AsMut<[u8]>;
fn encode(self) -> Self::Encoded;
fn decode(encoded: Self::Encoded) -> Self;
}
impl FixedLengthEncoding for bool {
type Encoded = [u8; 1];
fn encode(self) -> [u8; 1] {
[self as u8]
}
fn decode(encoded: Self::Encoded) -> Self {
encoded[0] != 0
}
}
macro_rules! encode_signed {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
let mut b = self.to_be_bytes();
// Toggle top "sign" bit to ensure consistent sort order
b[0] ^= 0x80;
b
}
fn decode(mut encoded: Self::Encoded) -> Self {
// Toggle top "sign" bit
encoded[0] ^= 0x80;
Self::from_be_bytes(encoded)
}
}
};
}
encode_signed!(1, i8);
encode_signed!(2, i16);
encode_signed!(4, i32);
encode_signed!(8, i64);
encode_signed!(16, i128);
encode_signed!(32, i256);
macro_rules! encode_unsigned {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
self.to_be_bytes()
}
fn decode(encoded: Self::Encoded) -> Self {
Self::from_be_bytes(encoded)
}
}
};
}
encode_unsigned!(1, u8);
encode_unsigned!(2, u16);
encode_unsigned!(4, u32);
encode_unsigned!(8, u64);
impl FixedLengthEncoding for f16 {
type Encoded = [u8; 2];
fn encode(self) -> [u8; 2] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i16;
let val = s ^ (((s >> 15) as u16) >> 1) as i16;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i16::decode(encoded);
let val = bits ^ (((bits >> 15) as u16) >> 1) as i16;
Self::from_bits(val as u16)
}
}
impl FixedLengthEncoding for f32 {
type Encoded = [u8; 4];
fn encode(self) -> [u8; 4] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i32;
let val = s ^ (((s >> 31) as u32) >> 1) as i32;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i32::decode(encoded);
let val = bits ^ (((bits >> 31) as u32) >> 1) as i32;
Self::from_bits(val as u32)
}
}
impl FixedLengthEncoding for f64 {
type Encoded = [u8; 8];
fn encode(self) -> [u8; 8] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i64;
let val = s ^ (((s >> 63) as u64) >> 1) as i64;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i64::decode(encoded);
let val = bits ^ (((bits >> 63) as u64) >> 1) as i64;
Self::from_bits(val as u64)
}
}
/// Returns the total encoded length (including null byte) for a value of type `T::Native`
pub const fn encoded_len<T>(_col: &PrimitiveArray<T>) -> usize
where
T: ArrowPrimitiveType,
T::Native: FixedLengthEncoding,
{
T::Native::ENCODED_LEN
}
/// Fixed width types are encoded as
///
/// - 1 byte `0` if null or `1` if valid
/// - bytes of [`FixedLengthEncoding`]
pub fn encode<T: FixedLengthEncoding, I: IntoIterator<Item = Option<T>>>(
data: &mut [u8],
offsets: &mut [usize],
i: I,
opts: SortOptions,
) {
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(i) {
let end_offset = *offset + T::ENCODED_LEN;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
let mut encoded = val.encode();
if opts.descending |
to_write[1..].copy_from_slice(encoded.as_ref())
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
pub fn encode_fixed_size_binary(
data: &mut [u8],
offsets: &mut [usize],
array: &FixedSizeBinaryArray,
opts: SortOptions,
) {
let len = array.value_length() as usize;
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(array.iter()) {
let end_offset = *offset + len + 1;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
to_write[1..].copy_from_slice(&val[..len]);
if opts.descending {
// Flip bits to reverse order
to_write[1..1 + len].iter_mut().for_each(|v| *v = !*v)
}
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
/// Splits `len` bytes from `src`
#[inline]
fn split_off<'a>(src: &mut &'a [u8], len: usize) -> &'a [u8] {
let v = &src[..len];
*src = &src[len..];
v
}
/// Decodes a `BooleanArray` from rows
pub fn decode_bool(rows: &mut [&[u8]], options: SortOptions) -> BooleanArray {
let true_val = match options.descending {
true => !1,
false => 1,
};
let len = rows.len();
let mut null_count = 0;
let mut nulls = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let mut values = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let chunks = len / 64;
let remainder = len % 64;
for chunk in 0..chunks {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..64 {
let i = split_off(&mut rows[bit_idx + chunk * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
if remainder != 0 {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..remainder {
let i = split_off(&mut rows[bit_idx + chunks * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
let builder = ArrayDataBuilder::new(DataType::Boolean)
.len(rows.len())
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls.into()));
// SAFETY:
// Buffers are the correct length
unsafe { BooleanArray::from(builder.build_unchecked()) }
}
/// Decodes a single byte from each row, interpreting `0x01` as a valid value
/// and all other values as a null
///
/// Returns the null count and null buffer
pub fn decode_nulls(rows: &[&[u8]]) -> (usize, Buffer) {
let mut null_count = 0;
let buffer = MutableBuffer::collect_bool(rows.len(), |idx| {
let valid = rows[idx][0] == 1;
null_count += !valid as usize;
valid
})
.into();
(null_count, buffer)
}
/// Decodes a `ArrayData` from rows based on the provided `FixedLengthEncoding` `T`
///
/// # Safety
///
/// `data_type` must be appropriate native type for `T`
unsafe fn decode_fixed<T: FixedLengthEncoding + ArrowNativeType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> ArrayData {
let len = rows.len();
let mut values = BufferBuilder::<T>::new(len);
let (null_count, nulls) = decode_nulls(rows);
for row in rows {
let i = split_off(row, T::ENCODED_LEN);
let value = T::Encoded::from_slice(&i[1..], options.descending);
values.append(T::decode(value));
}
let builder = ArrayDataBuilder::new(data_type)
.len(len)
.null_count(null_count)
.add_buffer(values.finish())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
builder.build_unchecked()
}
/// Decodes a `PrimitiveArray` from rows
pub fn decode_primitive<T: ArrowPrimitiveType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> PrimitiveArray<T>
where
T::Native: FixedLengthEncoding,
{
assert!(PrimitiveArray::<T>::is_compatible(&data_type));
// SAFETY:
// Validated data type above
unsafe { decode_fixed::<T::Native>(rows, data_type, options).into() }
}
/// Decodes a `FixedLengthBinary` from rows
pub fn decode_fixed_size_binary(
rows: &mut [&[u8]],
size: i32,
options: SortOptions,
) -> FixedSizeBinaryArray {
let len = rows.len();
let mut values = MutableBuffer::new(size as usize * rows.len());
let (null_count, nulls) = decode_nulls(rows);
let encoded_len = size as usize + 1;
for row in rows {
let i = split_off(row, encoded_len);
values.extend_from_slice(&i[1..]);
}
if options.descending {
for v in values.as_slice_mut() {
*v = !*v;
}
}
let builder = ArrayDataBuilder::new(DataType::FixedSizeBinary(size))
.len(len)
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
unsafe { builder.build_unchecked().into() }
}
| {
// Flip bits to reverse order
encoded.as_mut().iter_mut().for_each(|v| *v = !*v)
} | conditional_block |
fixed.rs | // Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you 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.
use crate::array::PrimitiveArray;
use crate::null_sentinel;
use arrow_array::builder::BufferBuilder;
use arrow_array::{ArrowPrimitiveType, BooleanArray, FixedSizeBinaryArray};
use arrow_buffer::{bit_util, i256, ArrowNativeType, Buffer, MutableBuffer};
use arrow_data::{ArrayData, ArrayDataBuilder};
use arrow_schema::{DataType, SortOptions};
use half::f16;
pub trait FromSlice {
fn from_slice(slice: &[u8], invert: bool) -> Self;
}
impl<const N: usize> FromSlice for [u8; N] {
#[inline]
fn from_slice(slice: &[u8], invert: bool) -> Self {
let mut t: Self = slice.try_into().unwrap();
if invert {
t.iter_mut().for_each(|o| *o = !*o);
}
t
}
}
/// Encodes a value of a particular fixed width type into bytes according to the rules
/// described on [`super::RowConverter`]
pub trait FixedLengthEncoding: Copy {
const ENCODED_LEN: usize = 1 + std::mem::size_of::<Self::Encoded>();
type Encoded: Sized + Copy + FromSlice + AsRef<[u8]> + AsMut<[u8]>;
fn encode(self) -> Self::Encoded;
fn decode(encoded: Self::Encoded) -> Self;
}
impl FixedLengthEncoding for bool {
type Encoded = [u8; 1];
fn encode(self) -> [u8; 1] |
fn decode(encoded: Self::Encoded) -> Self {
encoded[0] != 0
}
}
macro_rules! encode_signed {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
let mut b = self.to_be_bytes();
// Toggle top "sign" bit to ensure consistent sort order
b[0] ^= 0x80;
b
}
fn decode(mut encoded: Self::Encoded) -> Self {
// Toggle top "sign" bit
encoded[0] ^= 0x80;
Self::from_be_bytes(encoded)
}
}
};
}
encode_signed!(1, i8);
encode_signed!(2, i16);
encode_signed!(4, i32);
encode_signed!(8, i64);
encode_signed!(16, i128);
encode_signed!(32, i256);
macro_rules! encode_unsigned {
($n:expr, $t:ty) => {
impl FixedLengthEncoding for $t {
type Encoded = [u8; $n];
fn encode(self) -> [u8; $n] {
self.to_be_bytes()
}
fn decode(encoded: Self::Encoded) -> Self {
Self::from_be_bytes(encoded)
}
}
};
}
encode_unsigned!(1, u8);
encode_unsigned!(2, u16);
encode_unsigned!(4, u32);
encode_unsigned!(8, u64);
impl FixedLengthEncoding for f16 {
type Encoded = [u8; 2];
fn encode(self) -> [u8; 2] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i16;
let val = s ^ (((s >> 15) as u16) >> 1) as i16;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i16::decode(encoded);
let val = bits ^ (((bits >> 15) as u16) >> 1) as i16;
Self::from_bits(val as u16)
}
}
impl FixedLengthEncoding for f32 {
type Encoded = [u8; 4];
fn encode(self) -> [u8; 4] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i32;
let val = s ^ (((s >> 31) as u32) >> 1) as i32;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i32::decode(encoded);
let val = bits ^ (((bits >> 31) as u32) >> 1) as i32;
Self::from_bits(val as u32)
}
}
impl FixedLengthEncoding for f64 {
type Encoded = [u8; 8];
fn encode(self) -> [u8; 8] {
// https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
let s = self.to_bits() as i64;
let val = s ^ (((s >> 63) as u64) >> 1) as i64;
val.encode()
}
fn decode(encoded: Self::Encoded) -> Self {
let bits = i64::decode(encoded);
let val = bits ^ (((bits >> 63) as u64) >> 1) as i64;
Self::from_bits(val as u64)
}
}
/// Returns the total encoded length (including null byte) for a value of type `T::Native`
pub const fn encoded_len<T>(_col: &PrimitiveArray<T>) -> usize
where
T: ArrowPrimitiveType,
T::Native: FixedLengthEncoding,
{
T::Native::ENCODED_LEN
}
/// Fixed width types are encoded as
///
/// - 1 byte `0` if null or `1` if valid
/// - bytes of [`FixedLengthEncoding`]
pub fn encode<T: FixedLengthEncoding, I: IntoIterator<Item = Option<T>>>(
data: &mut [u8],
offsets: &mut [usize],
i: I,
opts: SortOptions,
) {
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(i) {
let end_offset = *offset + T::ENCODED_LEN;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
let mut encoded = val.encode();
if opts.descending {
// Flip bits to reverse order
encoded.as_mut().iter_mut().for_each(|v| *v = !*v)
}
to_write[1..].copy_from_slice(encoded.as_ref())
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
pub fn encode_fixed_size_binary(
data: &mut [u8],
offsets: &mut [usize],
array: &FixedSizeBinaryArray,
opts: SortOptions,
) {
let len = array.value_length() as usize;
for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(array.iter()) {
let end_offset = *offset + len + 1;
if let Some(val) = maybe_val {
let to_write = &mut data[*offset..end_offset];
to_write[0] = 1;
to_write[1..].copy_from_slice(&val[..len]);
if opts.descending {
// Flip bits to reverse order
to_write[1..1 + len].iter_mut().for_each(|v| *v = !*v)
}
} else {
data[*offset] = null_sentinel(opts);
}
*offset = end_offset;
}
}
/// Splits `len` bytes from `src`
#[inline]
fn split_off<'a>(src: &mut &'a [u8], len: usize) -> &'a [u8] {
let v = &src[..len];
*src = &src[len..];
v
}
/// Decodes a `BooleanArray` from rows
pub fn decode_bool(rows: &mut [&[u8]], options: SortOptions) -> BooleanArray {
let true_val = match options.descending {
true => !1,
false => 1,
};
let len = rows.len();
let mut null_count = 0;
let mut nulls = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let mut values = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
let chunks = len / 64;
let remainder = len % 64;
for chunk in 0..chunks {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..64 {
let i = split_off(&mut rows[bit_idx + chunk * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
if remainder != 0 {
let mut null_packed = 0;
let mut values_packed = 0;
for bit_idx in 0..remainder {
let i = split_off(&mut rows[bit_idx + chunks * 64], 2);
let (null, value) = (i[0] == 1, i[1] == true_val);
null_count += !null as usize;
null_packed |= (null as u64) << bit_idx;
values_packed |= (value as u64) << bit_idx;
}
nulls.push(null_packed);
values.push(values_packed);
}
let builder = ArrayDataBuilder::new(DataType::Boolean)
.len(rows.len())
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls.into()));
// SAFETY:
// Buffers are the correct length
unsafe { BooleanArray::from(builder.build_unchecked()) }
}
/// Decodes a single byte from each row, interpreting `0x01` as a valid value
/// and all other values as a null
///
/// Returns the null count and null buffer
pub fn decode_nulls(rows: &[&[u8]]) -> (usize, Buffer) {
let mut null_count = 0;
let buffer = MutableBuffer::collect_bool(rows.len(), |idx| {
let valid = rows[idx][0] == 1;
null_count += !valid as usize;
valid
})
.into();
(null_count, buffer)
}
/// Decodes a `ArrayData` from rows based on the provided `FixedLengthEncoding` `T`
///
/// # Safety
///
/// `data_type` must be appropriate native type for `T`
unsafe fn decode_fixed<T: FixedLengthEncoding + ArrowNativeType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> ArrayData {
let len = rows.len();
let mut values = BufferBuilder::<T>::new(len);
let (null_count, nulls) = decode_nulls(rows);
for row in rows {
let i = split_off(row, T::ENCODED_LEN);
let value = T::Encoded::from_slice(&i[1..], options.descending);
values.append(T::decode(value));
}
let builder = ArrayDataBuilder::new(data_type)
.len(len)
.null_count(null_count)
.add_buffer(values.finish())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
builder.build_unchecked()
}
/// Decodes a `PrimitiveArray` from rows
pub fn decode_primitive<T: ArrowPrimitiveType>(
rows: &mut [&[u8]],
data_type: DataType,
options: SortOptions,
) -> PrimitiveArray<T>
where
T::Native: FixedLengthEncoding,
{
assert!(PrimitiveArray::<T>::is_compatible(&data_type));
// SAFETY:
// Validated data type above
unsafe { decode_fixed::<T::Native>(rows, data_type, options).into() }
}
/// Decodes a `FixedLengthBinary` from rows
pub fn decode_fixed_size_binary(
rows: &mut [&[u8]],
size: i32,
options: SortOptions,
) -> FixedSizeBinaryArray {
let len = rows.len();
let mut values = MutableBuffer::new(size as usize * rows.len());
let (null_count, nulls) = decode_nulls(rows);
let encoded_len = size as usize + 1;
for row in rows {
let i = split_off(row, encoded_len);
values.extend_from_slice(&i[1..]);
}
if options.descending {
for v in values.as_slice_mut() {
*v = !*v;
}
}
let builder = ArrayDataBuilder::new(DataType::FixedSizeBinary(size))
.len(len)
.null_count(null_count)
.add_buffer(values.into())
.null_bit_buffer(Some(nulls));
// SAFETY: Buffers correct length
unsafe { builder.build_unchecked().into() }
}
| {
[self as u8]
} | identifier_body |
pop.py | import math
from historia.utils import unique_id, position_in_range
from historia.pops.models.inventory import Inventory
from historia.economy.enums.resource import Good, NaturalResource
from historia.economy.enums.order_type import OrderType
from historia.economy.models.price_range import PriceRange
from historia.economy.models.order import Order
from historia.pops.enums.pop_job import PopJob
DEBUG = False
class Pop(object):
"""
A simulated unit of population
"""
def | (self, province, pop_job, population):
"""
Creates a new Pop.
manager (Historia)
province (SecondaryDivision)
culture (Culture)
religion (Religion)
language (Language)
job (Job)
"""
self.bankrupt_times = 0
self.home = province
self.location = province
self.id = unique_id('po')
self.population = population
self.population_yesterday = 0
self.pop_job = pop_job
# ECONOMY
self.money = pop_job.start_money
self.money_yesterday = 0
self.bankrupt = False
# set inventory and ideal amounts
self.inventory = Inventory(pop_job.inventory_size)
self.give_start_inventory()
self.update_ideal_inventory()
# a dictionary of Goods to PriceRanges
# represents the price range the agent considers valid for each Good
self.price_belief = {}
# a dictionary of Goods to price list
# represents the prices of the good that the Pop has observed
# during the time they have been trading
self.observed_trading_range = {}
self.successful_trades = 0
self.failed_trades = 0
# make some fake initial data
for good in Good.all():
avg_price = self.market.avg_historial_price(good, 15)
# fake trades
self.observed_trading_range[good] = [
avg_price * 0.5,
avg_price * 1.5
]
# generate fake price belief
self.price_belief[good] = PriceRange(avg_price * 0.5, avg_price * 1.5)
# Merchant logic
self.trade_location = None # the province this Pop is traveling to
self.trade_good = None # what good we're trading in right now
self.trade_amount = 0 # amount of trade_good we should be trading
self.trading_days = 0 # number of days waiting to trade
# Generic Pop properties
@property
def social_class(self):
return self.pop_job.social_class
@property
def market(self):
"Get the market instance"
return self.location.market
@property
def profit(self):
"Determine today's profit"
return self.money - self.money_yesterday
@property
def total_trades(self):
"Total number of trades this Pop participated in"
return self.successful_trades + self.failed_trades
@property
def trade_success(self):
"Percent of trades that were successful"
if self.total_trades == 0:
return 0
return (self.successful_trades / self.total_trades) * 100
@property
def is_away(self):
"Is this Pop away from it's home?"
return self.home is not self.location
# Merchant specific logic
def go_to_province(self, province):
"Moves the Pop to another Province"
self.location = province
def decide_trade_plan(self):
"""
Decide what good to trade in and how much.
Look for the most in demand good, or the most expensive good at the home Province
Find a province near home province where its the cheapest and there's inventory
"""
self.trade_amount = 5
most_demanded_goods = self.home.market.goods_demand_ratio(day_range=1)
most_demanded_goods = sorted(most_demanded_goods.items(), key=lambda i: i[1], reverse=True)
# if we already had a trade good, refresh ideal inventory
if self.trade_good:
self.update_ideal_inventory()
if DEBUG: print("Finding a Good to trade:")
for good, demand in most_demanded_goods:
if demand > 0:
# find nearby provinces where this has inventory and the price is lower
price_at_home = self.home.market.mean_price(good)
if DEBUG: print("Good: {}, Demand: {}, Price: ${}".format(good.title, demand, price_at_home))
neighboring_markets = [p.market for p in self.location.owned_neighbors]
neighboring_markets = [m for m in neighboring_markets if m.supply_for(good) > self.trade_amount]
neighboring_markets.sort(key=lambda m: m.supply_for(good), reverse=True)
if len(neighboring_markets) > 0:
# we found places where this good is cheaper and in inventory
target = neighboring_markets[0].location
price_at_target = target.market.mean_price(good)
# only trade with prices where we can make money
if price_at_home > price_at_target:
offset = 0
if good is Good.bread:
offset = 1
self.inventory.set_ideal(good, self.trade_amount + offset)
self.trade_location = target
if DEBUG:
print("\tTarget: {}, Supply: {}, Price: ${}, Price at home: ${}".format(
self.trade_location.name,
self.trade_location.market.supply_for(good),
self.trade_location.market.mean_price(good),
price_at_home)
)
self.trade_good = good
return
else:
if DEBUG: print("\tPrice is higher at target (home: ${} target: ${})".format(price_at_home, price_at_target))
else:
if DEBUG: print("\tNo markets selling {} found".format(good))
# Generic economic logic
def update_ideal_inventory(self):
"Update ideal inventory"
# reset so that the Pop can sell the inventory it doesn't need
for good in Good.all():
self.inventory.set_ideal(good, 0)
# update ideal inventory for new Job
for item in self.pop_job.ideal_inventory:
self.inventory.set_ideal(item['good'], item['amount'])
def give_start_inventory(self):
"Give the Pop the inventory it needs to do its job"
for item in self.pop_job.start_inventory:
self.inventory.add(item['good'], item['amount'])
def change_population(self, trade_success):
"Change the population based off the trade"
self.population_yesterday = self.population
if trade_success:
self.population += round(self.population * 0.01)
else:
self.population -= round(self.population * 0.002)
def handle_bankruptcy(self, pop_job):
"Change job, create money out of thin air, update ideal inventory"
# TODO: stop creating money out of thin air
self.pop_job = pop_job
self.bankrupt_times += 1
self.money = 2
self.update_ideal_inventory()
self.give_start_inventory()
def perform_logic(self):
"Depending on PopJob, perform logic (including production)"
logic = self.pop_job.logic(self)
logic.perform()
def create_buy_order(self, good, limit):
"Create a buy order for a given Good at a determined quantity"
bid_price = self.determine_price_of(good)
ideal = self.determine_buy_quantity(good)
# can't buy more than limit
quantity_to_buy = limit if ideal > limit else ideal
if quantity_to_buy > 0:
return Order(self, OrderType.buy_order, quantity_to_buy, bid_price, good)
return False
def create_sell_order(self, good, limit):
"Create a sell order for a given Good at a determined quantity"
sell_price = self.determine_price_of(good)
ideal = self.determine_sell_quantity(good)
# can't buy more than limit
quantity_to_sell = limit if ideal < limit else ideal
if quantity_to_sell > 0:
return Order(self, OrderType.sell_order, quantity_to_sell, sell_price, good)
return False
def price_belief_for(self, good):
"Gets the price belief this agent has for a particular Good"
if good in self.price_belief:
return self.price_belief[good]
def determine_price_of(self, good):
"Determine the price of a particular good"
return self.price_belief_for(good).random()
def trading_range_extremes(self, good):
"Gets the lowest and highst price of a Good this agent has seen"
trading_range = self.observed_trading_range[good]
return PriceRange(min(trading_range), max(trading_range))
def determine_sell_quantity(self, good):
"Determine how much inventory goods to sell based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = position_in_range(mean, trading_range.low, trading_range.high)
amount_to_sell = round(favoribility * self.inventory.surplus(good))
if amount_to_sell < 1:
amount_to_sell = 1
return amount_to_sell
def determine_buy_quantity(self, good):
"Determine how much goods to buy based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = 1 - position_in_range(mean, trading_range.low, trading_range.high)
amount_to_buy = round(favoribility * self.inventory.shortage(good))
if amount_to_buy < 1:
amount_to_buy = 1
return amount_to_buy
def generate_orders(self, good):
"""
If the Pop needs a Good to perform production, buy it
If the Pop has surplus Resources, sell them
"""
surplus = self.inventory.surplus(good)
if surplus >= 1: # sell inventory
# the original only old one item here
sell_amount = surplus
order = self.create_sell_order(good, surplus)
if order:
# print('{} sells {} {}'.format(self.pop_job.title, sell_amount, good.name))
self.market.sell(order)
else: # buy more
shortage = self.inventory.shortage(good)
free_space = self.inventory.empty_space
if shortage > 0:
if shortage <= free_space:
# enough space for ideal order
limit = shortage
else:
# not enough space for ideal order
limit = math.floor(free_space / shortage)
if limit > 0:
order = self.create_buy_order(good, limit)
if order:
# print('{} buys {} {}'.format(self.pop_job.title, limit, good.name))
self.market.buy(order)
# else:
# print("{} has no shortage of {} (has shortage: {})".format(self.pop_job.title, good.title, shortage))
def update_price_model(self, good, order_type, is_successful, clearing_price=0):
"""
Update the Pop's price model for the given resource
good (Good) The Good which was orderd
order_type (OrderType) Which kind of Order this was
is_successful (bool) whether or not the Order was successful
clearing_price (float) The price per unit of the good that was ordered
as defined by the Pop which ordered it
"""
SIGNIFICANT = 0.25 # 25% more or less is "significant"
SIG_IMBALANCE = 0.33
LOW_INVENTORY = 0.1 # 10% of ideal inventory = "LOW"
HIGH_INVENTORY = 2.0 # 200% of ideal inventory = "HIGH"
MIN_PRICE = 0.01 # lowest allowed price of a Good
if is_successful:
# add this trade to the observed trading range
self.observed_trading_range[good].append(clearing_price)
public_mean_price = self.market.mean_price(good)
belief = self.price_belief[good]
mean = belief.mean()
wobble = 0.05 # the degree which the Pop should bid outside the belief
# how different the public mean price is from the price belief
delta_to_mean = mean - public_mean_price
if is_successful:
if order_type is OrderType.buy_order and delta_to_mean > SIGNIFICANT:
# this Pop overpaid, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
elif order_type is OrderType.sell_order and delta_to_mean < -SIGNIFICANT:
# this Pop underpaid!, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# increase the belief's certainty
belief.low += wobble * mean
belief.high -= wobble * mean
else:
# shift towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# check for inventory special cases
stocks = self.inventory.get_amount(good)
ideal = self.inventory.get_ideal(good)
# if we're buying and inventory is too low
# meaning we're desperate to buy
if order_type is OrderType.buy_order and stocks < LOW_INVENTORY * ideal:
wobble *= 2
# if we're selling and inventory is too high
# meaning we're desperate to sell
elif order_type is OrderType.sell_order and stocks > HIGH_INVENTORY * ideal:
wobble *= 2
# all other cases
else:
sells = self.market.history.sell_orders.average(good, 1)
buys = self.market.history.buy_orders.average(good, 1)
# TODO: figure out why this is sometimes 0
if sells + buys > 0:
supply_vs_demand = (sells - buys) / (sells + buys)
if supply_vs_demand > SIG_IMBALANCE or supply_vs_demand < -SIG_IMBALANCE:
# too much supply? lower bid lower to sell faster
# too much demand? raise price to buy faster
new_mean = public_mean_price * (1 - supply_vs_demand)
delta_to_mean = mean - new_mean
# shift the price belief to the new price mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# decrease belief's certainty since we've just changed it (we could be wrong)
belief.low -= wobble * mean
belief.high += wobble * mean
# make sure the price belief doesn't decrease below the minimum
if belief.low < MIN_PRICE:
belief.low = MIN_PRICE
elif belief.high < MIN_PRICE:
belief.high = MIN_PRICE
# Python utility methods
def __repr__(self):
return "<Pop: id={} type={}>".format(self.id, self.pop_job.title)
def __eq__(self, other):
return self.id == other.id
def __key__(self):
return self.id
def __hash__(self):
return hash(self.__key__())
def export(self):
model = {
'pop_job': self.pop_job.ref(),
'population': self.population,
'population_yesterday': self.population_yesterday,
'inventory': self.inventory.export(),
'money': self.money,
'money_yesterday': self.money_yesterday,
'successful_trades': self.successful_trades,
'failed_trades': self.failed_trades,
'bankrupt_times': self.bankrupt_times,
}
if self.pop_job is PopJob.merchant:
location_id = None
if self.trade_location:
location_id = self.trade_location.id
model.update({
'location': self.location.id,
'trade_location': location_id,
'trade_good': self.trade_good,
'trade_amount': self.trade_amount
})
return model
| __init__ | identifier_name |
pop.py | import math
from historia.utils import unique_id, position_in_range
from historia.pops.models.inventory import Inventory
from historia.economy.enums.resource import Good, NaturalResource
from historia.economy.enums.order_type import OrderType
from historia.economy.models.price_range import PriceRange
from historia.economy.models.order import Order
from historia.pops.enums.pop_job import PopJob
DEBUG = False
class Pop(object):
"""
A simulated unit of population
"""
def __init__(self, province, pop_job, population):
"""
Creates a new Pop.
manager (Historia)
province (SecondaryDivision)
culture (Culture)
religion (Religion)
language (Language)
job (Job)
"""
self.bankrupt_times = 0
self.home = province
self.location = province
self.id = unique_id('po')
self.population = population
self.population_yesterday = 0
self.pop_job = pop_job
# ECONOMY
self.money = pop_job.start_money
self.money_yesterday = 0
self.bankrupt = False
# set inventory and ideal amounts
self.inventory = Inventory(pop_job.inventory_size)
self.give_start_inventory()
self.update_ideal_inventory()
# a dictionary of Goods to PriceRanges
# represents the price range the agent considers valid for each Good
self.price_belief = {}
# a dictionary of Goods to price list
# represents the prices of the good that the Pop has observed
# during the time they have been trading
self.observed_trading_range = {}
self.successful_trades = 0
self.failed_trades = 0
# make some fake initial data
for good in Good.all():
avg_price = self.market.avg_historial_price(good, 15)
# fake trades
self.observed_trading_range[good] = [
avg_price * 0.5,
avg_price * 1.5
]
# generate fake price belief
self.price_belief[good] = PriceRange(avg_price * 0.5, avg_price * 1.5)
# Merchant logic
self.trade_location = None # the province this Pop is traveling to
self.trade_good = None # what good we're trading in right now
self.trade_amount = 0 # amount of trade_good we should be trading
self.trading_days = 0 # number of days waiting to trade
# Generic Pop properties
@property
def social_class(self):
return self.pop_job.social_class
@property
def market(self):
"Get the market instance"
return self.location.market
@property
def profit(self):
"Determine today's profit"
return self.money - self.money_yesterday
@property
def total_trades(self):
"Total number of trades this Pop participated in"
return self.successful_trades + self.failed_trades
@property
def trade_success(self):
"Percent of trades that were successful"
if self.total_trades == 0:
return 0
return (self.successful_trades / self.total_trades) * 100
@property
def is_away(self):
"Is this Pop away from it's home?"
return self.home is not self.location
# Merchant specific logic
def go_to_province(self, province):
"Moves the Pop to another Province"
self.location = province
def decide_trade_plan(self):
"""
Decide what good to trade in and how much.
Look for the most in demand good, or the most expensive good at the home Province
Find a province near home province where its the cheapest and there's inventory
"""
self.trade_amount = 5
most_demanded_goods = self.home.market.goods_demand_ratio(day_range=1)
most_demanded_goods = sorted(most_demanded_goods.items(), key=lambda i: i[1], reverse=True)
# if we already had a trade good, refresh ideal inventory
if self.trade_good:
self.update_ideal_inventory()
if DEBUG: print("Finding a Good to trade:")
for good, demand in most_demanded_goods:
if demand > 0:
# find nearby provinces where this has inventory and the price is lower
price_at_home = self.home.market.mean_price(good)
if DEBUG: print("Good: {}, Demand: {}, Price: ${}".format(good.title, demand, price_at_home))
neighboring_markets = [p.market for p in self.location.owned_neighbors]
neighboring_markets = [m for m in neighboring_markets if m.supply_for(good) > self.trade_amount]
neighboring_markets.sort(key=lambda m: m.supply_for(good), reverse=True)
if len(neighboring_markets) > 0:
# we found places where this good is cheaper and in inventory
target = neighboring_markets[0].location
price_at_target = target.market.mean_price(good)
# only trade with prices where we can make money
if price_at_home > price_at_target:
offset = 0
if good is Good.bread:
offset = 1
self.inventory.set_ideal(good, self.trade_amount + offset)
self.trade_location = target
if DEBUG:
print("\tTarget: {}, Supply: {}, Price: ${}, Price at home: ${}".format(
self.trade_location.name,
self.trade_location.market.supply_for(good),
self.trade_location.market.mean_price(good),
price_at_home)
)
self.trade_good = good
return
else:
if DEBUG: print("\tPrice is higher at target (home: ${} target: ${})".format(price_at_home, price_at_target))
else:
if DEBUG: print("\tNo markets selling {} found".format(good))
# Generic economic logic
def update_ideal_inventory(self):
"Update ideal inventory"
# reset so that the Pop can sell the inventory it doesn't need
for good in Good.all():
self.inventory.set_ideal(good, 0)
# update ideal inventory for new Job
for item in self.pop_job.ideal_inventory:
self.inventory.set_ideal(item['good'], item['amount'])
def give_start_inventory(self):
"Give the Pop the inventory it needs to do its job"
for item in self.pop_job.start_inventory:
self.inventory.add(item['good'], item['amount'])
def change_population(self, trade_success):
"Change the population based off the trade"
self.population_yesterday = self.population
if trade_success:
self.population += round(self.population * 0.01)
else:
self.population -= round(self.population * 0.002)
def handle_bankruptcy(self, pop_job):
"Change job, create money out of thin air, update ideal inventory"
# TODO: stop creating money out of thin air
self.pop_job = pop_job
self.bankrupt_times += 1
self.money = 2
self.update_ideal_inventory()
self.give_start_inventory()
def perform_logic(self):
"Depending on PopJob, perform logic (including production)"
logic = self.pop_job.logic(self)
logic.perform()
def create_buy_order(self, good, limit):
"Create a buy order for a given Good at a determined quantity"
bid_price = self.determine_price_of(good)
ideal = self.determine_buy_quantity(good)
# can't buy more than limit
quantity_to_buy = limit if ideal > limit else ideal
if quantity_to_buy > 0:
return Order(self, OrderType.buy_order, quantity_to_buy, bid_price, good)
return False
def create_sell_order(self, good, limit):
"Create a sell order for a given Good at a determined quantity"
sell_price = self.determine_price_of(good)
ideal = self.determine_sell_quantity(good)
# can't buy more than limit
quantity_to_sell = limit if ideal < limit else ideal
if quantity_to_sell > 0:
return Order(self, OrderType.sell_order, quantity_to_sell, sell_price, good)
return False
def price_belief_for(self, good):
"Gets the price belief this agent has for a particular Good"
if good in self.price_belief:
return self.price_belief[good]
def determine_price_of(self, good):
"Determine the price of a particular good"
return self.price_belief_for(good).random()
def trading_range_extremes(self, good):
"Gets the lowest and highst price of a Good this agent has seen"
trading_range = self.observed_trading_range[good]
return PriceRange(min(trading_range), max(trading_range))
def determine_sell_quantity(self, good):
"Determine how much inventory goods to sell based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = position_in_range(mean, trading_range.low, trading_range.high)
amount_to_sell = round(favoribility * self.inventory.surplus(good))
if amount_to_sell < 1:
amount_to_sell = 1
return amount_to_sell
def determine_buy_quantity(self, good):
|
def generate_orders(self, good):
"""
If the Pop needs a Good to perform production, buy it
If the Pop has surplus Resources, sell them
"""
surplus = self.inventory.surplus(good)
if surplus >= 1: # sell inventory
# the original only old one item here
sell_amount = surplus
order = self.create_sell_order(good, surplus)
if order:
# print('{} sells {} {}'.format(self.pop_job.title, sell_amount, good.name))
self.market.sell(order)
else: # buy more
shortage = self.inventory.shortage(good)
free_space = self.inventory.empty_space
if shortage > 0:
if shortage <= free_space:
# enough space for ideal order
limit = shortage
else:
# not enough space for ideal order
limit = math.floor(free_space / shortage)
if limit > 0:
order = self.create_buy_order(good, limit)
if order:
# print('{} buys {} {}'.format(self.pop_job.title, limit, good.name))
self.market.buy(order)
# else:
# print("{} has no shortage of {} (has shortage: {})".format(self.pop_job.title, good.title, shortage))
def update_price_model(self, good, order_type, is_successful, clearing_price=0):
"""
Update the Pop's price model for the given resource
good (Good) The Good which was orderd
order_type (OrderType) Which kind of Order this was
is_successful (bool) whether or not the Order was successful
clearing_price (float) The price per unit of the good that was ordered
as defined by the Pop which ordered it
"""
SIGNIFICANT = 0.25 # 25% more or less is "significant"
SIG_IMBALANCE = 0.33
LOW_INVENTORY = 0.1 # 10% of ideal inventory = "LOW"
HIGH_INVENTORY = 2.0 # 200% of ideal inventory = "HIGH"
MIN_PRICE = 0.01 # lowest allowed price of a Good
if is_successful:
# add this trade to the observed trading range
self.observed_trading_range[good].append(clearing_price)
public_mean_price = self.market.mean_price(good)
belief = self.price_belief[good]
mean = belief.mean()
wobble = 0.05 # the degree which the Pop should bid outside the belief
# how different the public mean price is from the price belief
delta_to_mean = mean - public_mean_price
if is_successful:
if order_type is OrderType.buy_order and delta_to_mean > SIGNIFICANT:
# this Pop overpaid, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
elif order_type is OrderType.sell_order and delta_to_mean < -SIGNIFICANT:
# this Pop underpaid!, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# increase the belief's certainty
belief.low += wobble * mean
belief.high -= wobble * mean
else:
# shift towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# check for inventory special cases
stocks = self.inventory.get_amount(good)
ideal = self.inventory.get_ideal(good)
# if we're buying and inventory is too low
# meaning we're desperate to buy
if order_type is OrderType.buy_order and stocks < LOW_INVENTORY * ideal:
wobble *= 2
# if we're selling and inventory is too high
# meaning we're desperate to sell
elif order_type is OrderType.sell_order and stocks > HIGH_INVENTORY * ideal:
wobble *= 2
# all other cases
else:
sells = self.market.history.sell_orders.average(good, 1)
buys = self.market.history.buy_orders.average(good, 1)
# TODO: figure out why this is sometimes 0
if sells + buys > 0:
supply_vs_demand = (sells - buys) / (sells + buys)
if supply_vs_demand > SIG_IMBALANCE or supply_vs_demand < -SIG_IMBALANCE:
# too much supply? lower bid lower to sell faster
# too much demand? raise price to buy faster
new_mean = public_mean_price * (1 - supply_vs_demand)
delta_to_mean = mean - new_mean
# shift the price belief to the new price mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# decrease belief's certainty since we've just changed it (we could be wrong)
belief.low -= wobble * mean
belief.high += wobble * mean
# make sure the price belief doesn't decrease below the minimum
if belief.low < MIN_PRICE:
belief.low = MIN_PRICE
elif belief.high < MIN_PRICE:
belief.high = MIN_PRICE
# Python utility methods
def __repr__(self):
return "<Pop: id={} type={}>".format(self.id, self.pop_job.title)
def __eq__(self, other):
return self.id == other.id
def __key__(self):
return self.id
def __hash__(self):
return hash(self.__key__())
def export(self):
model = {
'pop_job': self.pop_job.ref(),
'population': self.population,
'population_yesterday': self.population_yesterday,
'inventory': self.inventory.export(),
'money': self.money,
'money_yesterday': self.money_yesterday,
'successful_trades': self.successful_trades,
'failed_trades': self.failed_trades,
'bankrupt_times': self.bankrupt_times,
}
if self.pop_job is PopJob.merchant:
location_id = None
if self.trade_location:
location_id = self.trade_location.id
model.update({
'location': self.location.id,
'trade_location': location_id,
'trade_good': self.trade_good,
'trade_amount': self.trade_amount
})
return model
| "Determine how much goods to buy based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = 1 - position_in_range(mean, trading_range.low, trading_range.high)
amount_to_buy = round(favoribility * self.inventory.shortage(good))
if amount_to_buy < 1:
amount_to_buy = 1
return amount_to_buy | identifier_body |
pop.py | import math
from historia.utils import unique_id, position_in_range
from historia.pops.models.inventory import Inventory
from historia.economy.enums.resource import Good, NaturalResource
from historia.economy.enums.order_type import OrderType
from historia.economy.models.price_range import PriceRange
from historia.economy.models.order import Order
from historia.pops.enums.pop_job import PopJob
DEBUG = False
class Pop(object):
"""
A simulated unit of population
"""
def __init__(self, province, pop_job, population):
"""
Creates a new Pop.
manager (Historia)
province (SecondaryDivision)
culture (Culture)
religion (Religion)
language (Language)
job (Job)
"""
self.bankrupt_times = 0
self.home = province
self.location = province
self.id = unique_id('po')
self.population = population
self.population_yesterday = 0
self.pop_job = pop_job
# ECONOMY
self.money = pop_job.start_money
self.money_yesterday = 0
self.bankrupt = False
# set inventory and ideal amounts
self.inventory = Inventory(pop_job.inventory_size)
self.give_start_inventory()
self.update_ideal_inventory()
# a dictionary of Goods to PriceRanges
# represents the price range the agent considers valid for each Good
self.price_belief = {}
# a dictionary of Goods to price list
# represents the prices of the good that the Pop has observed
# during the time they have been trading
self.observed_trading_range = {}
self.successful_trades = 0
self.failed_trades = 0
# make some fake initial data
for good in Good.all():
avg_price = self.market.avg_historial_price(good, 15)
# fake trades
self.observed_trading_range[good] = [
avg_price * 0.5,
avg_price * 1.5
]
# generate fake price belief
self.price_belief[good] = PriceRange(avg_price * 0.5, avg_price * 1.5)
# Merchant logic
self.trade_location = None # the province this Pop is traveling to
self.trade_good = None # what good we're trading in right now
self.trade_amount = 0 # amount of trade_good we should be trading
self.trading_days = 0 # number of days waiting to trade
# Generic Pop properties
@property
def social_class(self):
return self.pop_job.social_class
@property
def market(self):
"Get the market instance"
return self.location.market
@property
def profit(self):
"Determine today's profit"
return self.money - self.money_yesterday
@property
def total_trades(self):
"Total number of trades this Pop participated in"
return self.successful_trades + self.failed_trades
@property
def trade_success(self):
"Percent of trades that were successful"
if self.total_trades == 0:
return 0
return (self.successful_trades / self.total_trades) * 100
@property
def is_away(self):
"Is this Pop away from it's home?"
return self.home is not self.location
# Merchant specific logic
def go_to_province(self, province):
"Moves the Pop to another Province"
self.location = province
def decide_trade_plan(self):
"""
Decide what good to trade in and how much.
Look for the most in demand good, or the most expensive good at the home Province
Find a province near home province where its the cheapest and there's inventory
"""
self.trade_amount = 5
most_demanded_goods = self.home.market.goods_demand_ratio(day_range=1)
most_demanded_goods = sorted(most_demanded_goods.items(), key=lambda i: i[1], reverse=True)
# if we already had a trade good, refresh ideal inventory
if self.trade_good:
self.update_ideal_inventory()
if DEBUG: print("Finding a Good to trade:")
for good, demand in most_demanded_goods:
if demand > 0:
# find nearby provinces where this has inventory and the price is lower
price_at_home = self.home.market.mean_price(good)
if DEBUG: |
neighboring_markets = [p.market for p in self.location.owned_neighbors]
neighboring_markets = [m for m in neighboring_markets if m.supply_for(good) > self.trade_amount]
neighboring_markets.sort(key=lambda m: m.supply_for(good), reverse=True)
if len(neighboring_markets) > 0:
# we found places where this good is cheaper and in inventory
target = neighboring_markets[0].location
price_at_target = target.market.mean_price(good)
# only trade with prices where we can make money
if price_at_home > price_at_target:
offset = 0
if good is Good.bread:
offset = 1
self.inventory.set_ideal(good, self.trade_amount + offset)
self.trade_location = target
if DEBUG:
print("\tTarget: {}, Supply: {}, Price: ${}, Price at home: ${}".format(
self.trade_location.name,
self.trade_location.market.supply_for(good),
self.trade_location.market.mean_price(good),
price_at_home)
)
self.trade_good = good
return
else:
if DEBUG: print("\tPrice is higher at target (home: ${} target: ${})".format(price_at_home, price_at_target))
else:
if DEBUG: print("\tNo markets selling {} found".format(good))
# Generic economic logic
def update_ideal_inventory(self):
"Update ideal inventory"
# reset so that the Pop can sell the inventory it doesn't need
for good in Good.all():
self.inventory.set_ideal(good, 0)
# update ideal inventory for new Job
for item in self.pop_job.ideal_inventory:
self.inventory.set_ideal(item['good'], item['amount'])
def give_start_inventory(self):
"Give the Pop the inventory it needs to do its job"
for item in self.pop_job.start_inventory:
self.inventory.add(item['good'], item['amount'])
def change_population(self, trade_success):
"Change the population based off the trade"
self.population_yesterday = self.population
if trade_success:
self.population += round(self.population * 0.01)
else:
self.population -= round(self.population * 0.002)
def handle_bankruptcy(self, pop_job):
"Change job, create money out of thin air, update ideal inventory"
# TODO: stop creating money out of thin air
self.pop_job = pop_job
self.bankrupt_times += 1
self.money = 2
self.update_ideal_inventory()
self.give_start_inventory()
def perform_logic(self):
"Depending on PopJob, perform logic (including production)"
logic = self.pop_job.logic(self)
logic.perform()
def create_buy_order(self, good, limit):
"Create a buy order for a given Good at a determined quantity"
bid_price = self.determine_price_of(good)
ideal = self.determine_buy_quantity(good)
# can't buy more than limit
quantity_to_buy = limit if ideal > limit else ideal
if quantity_to_buy > 0:
return Order(self, OrderType.buy_order, quantity_to_buy, bid_price, good)
return False
def create_sell_order(self, good, limit):
"Create a sell order for a given Good at a determined quantity"
sell_price = self.determine_price_of(good)
ideal = self.determine_sell_quantity(good)
# can't buy more than limit
quantity_to_sell = limit if ideal < limit else ideal
if quantity_to_sell > 0:
return Order(self, OrderType.sell_order, quantity_to_sell, sell_price, good)
return False
def price_belief_for(self, good):
"Gets the price belief this agent has for a particular Good"
if good in self.price_belief:
return self.price_belief[good]
def determine_price_of(self, good):
"Determine the price of a particular good"
return self.price_belief_for(good).random()
def trading_range_extremes(self, good):
"Gets the lowest and highst price of a Good this agent has seen"
trading_range = self.observed_trading_range[good]
return PriceRange(min(trading_range), max(trading_range))
def determine_sell_quantity(self, good):
"Determine how much inventory goods to sell based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = position_in_range(mean, trading_range.low, trading_range.high)
amount_to_sell = round(favoribility * self.inventory.surplus(good))
if amount_to_sell < 1:
amount_to_sell = 1
return amount_to_sell
def determine_buy_quantity(self, good):
"Determine how much goods to buy based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = 1 - position_in_range(mean, trading_range.low, trading_range.high)
amount_to_buy = round(favoribility * self.inventory.shortage(good))
if amount_to_buy < 1:
amount_to_buy = 1
return amount_to_buy
def generate_orders(self, good):
"""
If the Pop needs a Good to perform production, buy it
If the Pop has surplus Resources, sell them
"""
surplus = self.inventory.surplus(good)
if surplus >= 1: # sell inventory
# the original only old one item here
sell_amount = surplus
order = self.create_sell_order(good, surplus)
if order:
# print('{} sells {} {}'.format(self.pop_job.title, sell_amount, good.name))
self.market.sell(order)
else: # buy more
shortage = self.inventory.shortage(good)
free_space = self.inventory.empty_space
if shortage > 0:
if shortage <= free_space:
# enough space for ideal order
limit = shortage
else:
# not enough space for ideal order
limit = math.floor(free_space / shortage)
if limit > 0:
order = self.create_buy_order(good, limit)
if order:
# print('{} buys {} {}'.format(self.pop_job.title, limit, good.name))
self.market.buy(order)
# else:
# print("{} has no shortage of {} (has shortage: {})".format(self.pop_job.title, good.title, shortage))
def update_price_model(self, good, order_type, is_successful, clearing_price=0):
"""
Update the Pop's price model for the given resource
good (Good) The Good which was orderd
order_type (OrderType) Which kind of Order this was
is_successful (bool) whether or not the Order was successful
clearing_price (float) The price per unit of the good that was ordered
as defined by the Pop which ordered it
"""
SIGNIFICANT = 0.25 # 25% more or less is "significant"
SIG_IMBALANCE = 0.33
LOW_INVENTORY = 0.1 # 10% of ideal inventory = "LOW"
HIGH_INVENTORY = 2.0 # 200% of ideal inventory = "HIGH"
MIN_PRICE = 0.01 # lowest allowed price of a Good
if is_successful:
# add this trade to the observed trading range
self.observed_trading_range[good].append(clearing_price)
public_mean_price = self.market.mean_price(good)
belief = self.price_belief[good]
mean = belief.mean()
wobble = 0.05 # the degree which the Pop should bid outside the belief
# how different the public mean price is from the price belief
delta_to_mean = mean - public_mean_price
if is_successful:
if order_type is OrderType.buy_order and delta_to_mean > SIGNIFICANT:
# this Pop overpaid, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
elif order_type is OrderType.sell_order and delta_to_mean < -SIGNIFICANT:
# this Pop underpaid!, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# increase the belief's certainty
belief.low += wobble * mean
belief.high -= wobble * mean
else:
# shift towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# check for inventory special cases
stocks = self.inventory.get_amount(good)
ideal = self.inventory.get_ideal(good)
# if we're buying and inventory is too low
# meaning we're desperate to buy
if order_type is OrderType.buy_order and stocks < LOW_INVENTORY * ideal:
wobble *= 2
# if we're selling and inventory is too high
# meaning we're desperate to sell
elif order_type is OrderType.sell_order and stocks > HIGH_INVENTORY * ideal:
wobble *= 2
# all other cases
else:
sells = self.market.history.sell_orders.average(good, 1)
buys = self.market.history.buy_orders.average(good, 1)
# TODO: figure out why this is sometimes 0
if sells + buys > 0:
supply_vs_demand = (sells - buys) / (sells + buys)
if supply_vs_demand > SIG_IMBALANCE or supply_vs_demand < -SIG_IMBALANCE:
# too much supply? lower bid lower to sell faster
# too much demand? raise price to buy faster
new_mean = public_mean_price * (1 - supply_vs_demand)
delta_to_mean = mean - new_mean
# shift the price belief to the new price mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# decrease belief's certainty since we've just changed it (we could be wrong)
belief.low -= wobble * mean
belief.high += wobble * mean
# make sure the price belief doesn't decrease below the minimum
if belief.low < MIN_PRICE:
belief.low = MIN_PRICE
elif belief.high < MIN_PRICE:
belief.high = MIN_PRICE
# Python utility methods
def __repr__(self):
return "<Pop: id={} type={}>".format(self.id, self.pop_job.title)
def __eq__(self, other):
return self.id == other.id
def __key__(self):
return self.id
def __hash__(self):
return hash(self.__key__())
def export(self):
model = {
'pop_job': self.pop_job.ref(),
'population': self.population,
'population_yesterday': self.population_yesterday,
'inventory': self.inventory.export(),
'money': self.money,
'money_yesterday': self.money_yesterday,
'successful_trades': self.successful_trades,
'failed_trades': self.failed_trades,
'bankrupt_times': self.bankrupt_times,
}
if self.pop_job is PopJob.merchant:
location_id = None
if self.trade_location:
location_id = self.trade_location.id
model.update({
'location': self.location.id,
'trade_location': location_id,
'trade_good': self.trade_good,
'trade_amount': self.trade_amount
})
return model
| print("Good: {}, Demand: {}, Price: ${}".format(good.title, demand, price_at_home)) | conditional_block |
pop.py | import math
from historia.utils import unique_id, position_in_range
from historia.pops.models.inventory import Inventory
from historia.economy.enums.resource import Good, NaturalResource
from historia.economy.enums.order_type import OrderType
from historia.economy.models.price_range import PriceRange
from historia.economy.models.order import Order
from historia.pops.enums.pop_job import PopJob
DEBUG = False
class Pop(object):
"""
A simulated unit of population
"""
def __init__(self, province, pop_job, population):
"""
Creates a new Pop.
manager (Historia)
province (SecondaryDivision)
culture (Culture)
religion (Religion)
language (Language)
job (Job)
"""
self.bankrupt_times = 0
self.home = province
self.location = province
self.id = unique_id('po')
self.population = population
self.population_yesterday = 0
self.pop_job = pop_job
# ECONOMY
self.money = pop_job.start_money
self.money_yesterday = 0
self.bankrupt = False
# set inventory and ideal amounts
self.inventory = Inventory(pop_job.inventory_size)
self.give_start_inventory()
self.update_ideal_inventory()
# a dictionary of Goods to PriceRanges | self.price_belief = {}
# a dictionary of Goods to price list
# represents the prices of the good that the Pop has observed
# during the time they have been trading
self.observed_trading_range = {}
self.successful_trades = 0
self.failed_trades = 0
# make some fake initial data
for good in Good.all():
avg_price = self.market.avg_historial_price(good, 15)
# fake trades
self.observed_trading_range[good] = [
avg_price * 0.5,
avg_price * 1.5
]
# generate fake price belief
self.price_belief[good] = PriceRange(avg_price * 0.5, avg_price * 1.5)
# Merchant logic
self.trade_location = None # the province this Pop is traveling to
self.trade_good = None # what good we're trading in right now
self.trade_amount = 0 # amount of trade_good we should be trading
self.trading_days = 0 # number of days waiting to trade
# Generic Pop properties
@property
def social_class(self):
return self.pop_job.social_class
@property
def market(self):
"Get the market instance"
return self.location.market
@property
def profit(self):
"Determine today's profit"
return self.money - self.money_yesterday
@property
def total_trades(self):
"Total number of trades this Pop participated in"
return self.successful_trades + self.failed_trades
@property
def trade_success(self):
"Percent of trades that were successful"
if self.total_trades == 0:
return 0
return (self.successful_trades / self.total_trades) * 100
@property
def is_away(self):
"Is this Pop away from it's home?"
return self.home is not self.location
# Merchant specific logic
def go_to_province(self, province):
"Moves the Pop to another Province"
self.location = province
def decide_trade_plan(self):
"""
Decide what good to trade in and how much.
Look for the most in demand good, or the most expensive good at the home Province
Find a province near home province where its the cheapest and there's inventory
"""
self.trade_amount = 5
most_demanded_goods = self.home.market.goods_demand_ratio(day_range=1)
most_demanded_goods = sorted(most_demanded_goods.items(), key=lambda i: i[1], reverse=True)
# if we already had a trade good, refresh ideal inventory
if self.trade_good:
self.update_ideal_inventory()
if DEBUG: print("Finding a Good to trade:")
for good, demand in most_demanded_goods:
if demand > 0:
# find nearby provinces where this has inventory and the price is lower
price_at_home = self.home.market.mean_price(good)
if DEBUG: print("Good: {}, Demand: {}, Price: ${}".format(good.title, demand, price_at_home))
neighboring_markets = [p.market for p in self.location.owned_neighbors]
neighboring_markets = [m for m in neighboring_markets if m.supply_for(good) > self.trade_amount]
neighboring_markets.sort(key=lambda m: m.supply_for(good), reverse=True)
if len(neighboring_markets) > 0:
# we found places where this good is cheaper and in inventory
target = neighboring_markets[0].location
price_at_target = target.market.mean_price(good)
# only trade with prices where we can make money
if price_at_home > price_at_target:
offset = 0
if good is Good.bread:
offset = 1
self.inventory.set_ideal(good, self.trade_amount + offset)
self.trade_location = target
if DEBUG:
print("\tTarget: {}, Supply: {}, Price: ${}, Price at home: ${}".format(
self.trade_location.name,
self.trade_location.market.supply_for(good),
self.trade_location.market.mean_price(good),
price_at_home)
)
self.trade_good = good
return
else:
if DEBUG: print("\tPrice is higher at target (home: ${} target: ${})".format(price_at_home, price_at_target))
else:
if DEBUG: print("\tNo markets selling {} found".format(good))
# Generic economic logic
def update_ideal_inventory(self):
"Update ideal inventory"
# reset so that the Pop can sell the inventory it doesn't need
for good in Good.all():
self.inventory.set_ideal(good, 0)
# update ideal inventory for new Job
for item in self.pop_job.ideal_inventory:
self.inventory.set_ideal(item['good'], item['amount'])
def give_start_inventory(self):
"Give the Pop the inventory it needs to do its job"
for item in self.pop_job.start_inventory:
self.inventory.add(item['good'], item['amount'])
def change_population(self, trade_success):
"Change the population based off the trade"
self.population_yesterday = self.population
if trade_success:
self.population += round(self.population * 0.01)
else:
self.population -= round(self.population * 0.002)
def handle_bankruptcy(self, pop_job):
"Change job, create money out of thin air, update ideal inventory"
# TODO: stop creating money out of thin air
self.pop_job = pop_job
self.bankrupt_times += 1
self.money = 2
self.update_ideal_inventory()
self.give_start_inventory()
def perform_logic(self):
"Depending on PopJob, perform logic (including production)"
logic = self.pop_job.logic(self)
logic.perform()
def create_buy_order(self, good, limit):
"Create a buy order for a given Good at a determined quantity"
bid_price = self.determine_price_of(good)
ideal = self.determine_buy_quantity(good)
# can't buy more than limit
quantity_to_buy = limit if ideal > limit else ideal
if quantity_to_buy > 0:
return Order(self, OrderType.buy_order, quantity_to_buy, bid_price, good)
return False
def create_sell_order(self, good, limit):
"Create a sell order for a given Good at a determined quantity"
sell_price = self.determine_price_of(good)
ideal = self.determine_sell_quantity(good)
# can't buy more than limit
quantity_to_sell = limit if ideal < limit else ideal
if quantity_to_sell > 0:
return Order(self, OrderType.sell_order, quantity_to_sell, sell_price, good)
return False
def price_belief_for(self, good):
"Gets the price belief this agent has for a particular Good"
if good in self.price_belief:
return self.price_belief[good]
def determine_price_of(self, good):
"Determine the price of a particular good"
return self.price_belief_for(good).random()
def trading_range_extremes(self, good):
"Gets the lowest and highst price of a Good this agent has seen"
trading_range = self.observed_trading_range[good]
return PriceRange(min(trading_range), max(trading_range))
def determine_sell_quantity(self, good):
"Determine how much inventory goods to sell based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = position_in_range(mean, trading_range.low, trading_range.high)
amount_to_sell = round(favoribility * self.inventory.surplus(good))
if amount_to_sell < 1:
amount_to_sell = 1
return amount_to_sell
def determine_buy_quantity(self, good):
"Determine how much goods to buy based on market conditions"
mean = self.market.avg_historial_price(good, 15)
trading_range = self.trading_range_extremes(good)
favoribility = 1 - position_in_range(mean, trading_range.low, trading_range.high)
amount_to_buy = round(favoribility * self.inventory.shortage(good))
if amount_to_buy < 1:
amount_to_buy = 1
return amount_to_buy
def generate_orders(self, good):
"""
If the Pop needs a Good to perform production, buy it
If the Pop has surplus Resources, sell them
"""
surplus = self.inventory.surplus(good)
if surplus >= 1: # sell inventory
# the original only old one item here
sell_amount = surplus
order = self.create_sell_order(good, surplus)
if order:
# print('{} sells {} {}'.format(self.pop_job.title, sell_amount, good.name))
self.market.sell(order)
else: # buy more
shortage = self.inventory.shortage(good)
free_space = self.inventory.empty_space
if shortage > 0:
if shortage <= free_space:
# enough space for ideal order
limit = shortage
else:
# not enough space for ideal order
limit = math.floor(free_space / shortage)
if limit > 0:
order = self.create_buy_order(good, limit)
if order:
# print('{} buys {} {}'.format(self.pop_job.title, limit, good.name))
self.market.buy(order)
# else:
# print("{} has no shortage of {} (has shortage: {})".format(self.pop_job.title, good.title, shortage))
def update_price_model(self, good, order_type, is_successful, clearing_price=0):
"""
Update the Pop's price model for the given resource
good (Good) The Good which was orderd
order_type (OrderType) Which kind of Order this was
is_successful (bool) whether or not the Order was successful
clearing_price (float) The price per unit of the good that was ordered
as defined by the Pop which ordered it
"""
SIGNIFICANT = 0.25 # 25% more or less is "significant"
SIG_IMBALANCE = 0.33
LOW_INVENTORY = 0.1 # 10% of ideal inventory = "LOW"
HIGH_INVENTORY = 2.0 # 200% of ideal inventory = "HIGH"
MIN_PRICE = 0.01 # lowest allowed price of a Good
if is_successful:
# add this trade to the observed trading range
self.observed_trading_range[good].append(clearing_price)
public_mean_price = self.market.mean_price(good)
belief = self.price_belief[good]
mean = belief.mean()
wobble = 0.05 # the degree which the Pop should bid outside the belief
# how different the public mean price is from the price belief
delta_to_mean = mean - public_mean_price
if is_successful:
if order_type is OrderType.buy_order and delta_to_mean > SIGNIFICANT:
# this Pop overpaid, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
elif order_type is OrderType.sell_order and delta_to_mean < -SIGNIFICANT:
# this Pop underpaid!, shift belief towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# increase the belief's certainty
belief.low += wobble * mean
belief.high -= wobble * mean
else:
# shift towards mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# check for inventory special cases
stocks = self.inventory.get_amount(good)
ideal = self.inventory.get_ideal(good)
# if we're buying and inventory is too low
# meaning we're desperate to buy
if order_type is OrderType.buy_order and stocks < LOW_INVENTORY * ideal:
wobble *= 2
# if we're selling and inventory is too high
# meaning we're desperate to sell
elif order_type is OrderType.sell_order and stocks > HIGH_INVENTORY * ideal:
wobble *= 2
# all other cases
else:
sells = self.market.history.sell_orders.average(good, 1)
buys = self.market.history.buy_orders.average(good, 1)
# TODO: figure out why this is sometimes 0
if sells + buys > 0:
supply_vs_demand = (sells - buys) / (sells + buys)
if supply_vs_demand > SIG_IMBALANCE or supply_vs_demand < -SIG_IMBALANCE:
# too much supply? lower bid lower to sell faster
# too much demand? raise price to buy faster
new_mean = public_mean_price * (1 - supply_vs_demand)
delta_to_mean = mean - new_mean
# shift the price belief to the new price mean
belief.low -= delta_to_mean / 2
belief.high -= delta_to_mean / 2
# decrease belief's certainty since we've just changed it (we could be wrong)
belief.low -= wobble * mean
belief.high += wobble * mean
# make sure the price belief doesn't decrease below the minimum
if belief.low < MIN_PRICE:
belief.low = MIN_PRICE
elif belief.high < MIN_PRICE:
belief.high = MIN_PRICE
# Python utility methods
def __repr__(self):
return "<Pop: id={} type={}>".format(self.id, self.pop_job.title)
def __eq__(self, other):
return self.id == other.id
def __key__(self):
return self.id
def __hash__(self):
return hash(self.__key__())
def export(self):
model = {
'pop_job': self.pop_job.ref(),
'population': self.population,
'population_yesterday': self.population_yesterday,
'inventory': self.inventory.export(),
'money': self.money,
'money_yesterday': self.money_yesterday,
'successful_trades': self.successful_trades,
'failed_trades': self.failed_trades,
'bankrupt_times': self.bankrupt_times,
}
if self.pop_job is PopJob.merchant:
location_id = None
if self.trade_location:
location_id = self.trade_location.id
model.update({
'location': self.location.id,
'trade_location': location_id,
'trade_good': self.trade_good,
'trade_amount': self.trade_amount
})
return model | # represents the price range the agent considers valid for each Good | random_line_split |
server.go | package reflector
import (
"bufio"
"crypto/sha512"
"encoding/hex"
"encoding/json"
"io"
"net"
"time"
"github.com/lbryio/reflector.go/internal/metrics"
"github.com/lbryio/reflector.go/store"
"github.com/lbryio/lbry.go/v2/extras/errors"
"github.com/lbryio/lbry.go/v2/extras/stop"
"github.com/lbryio/lbry.go/v2/stream"
log "github.com/sirupsen/logrus"
)
const (
// DefaultPort is the port the reflector server listens on if not passed in.
DefaultPort = 5566
// DefaultTimeout is the default timeout to read or write the next message
DefaultTimeout = 5 * time.Second
network = "tcp4"
protocolVersion1 = 0
protocolVersion2 = 1
maxBlobSize = stream.MaxBlobSize
)
var ErrBlobTooBig = errors.Base("blob must be at most %d bytes", maxBlobSize)
// Server is and instance of the reflector server. It houses the blob store and listener.
type Server struct {
Timeout time.Duration // timeout to read or write next message
EnableBlocklist bool // if true, blocklist checking and blob deletion will be enabled
underlyingStore store.BlobStore
outerStore store.BlobStore
grp *stop.Group
}
// NewServer returns an initialized reflector server pointer.
func NewServer(underlying store.BlobStore, outer store.BlobStore) *Server {
return &Server{
Timeout: DefaultTimeout,
underlyingStore: underlying,
outerStore: outer,
grp: stop.New(),
}
}
// Shutdown shuts down the reflector server gracefully.
func (s *Server) Shutdown() {
log.Println("shutting down reflector server...")
s.grp.StopAndWait()
log.Println("reflector server stopped")
}
// Start starts the server to handle connections.
func (s *Server) Start(address string) error {
l, err := net.Listen(network, address)
if err != nil {
return errors.Err(err)
}
log.Println("reflector listening on " + address)
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Dec()
<-s.grp.Ch()
err := l.Close()
if err != nil {
log.Error(errors.Prefix("closing listener", err))
}
s.grp.Done()
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "start").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "start").Dec()
s.listenAndServe(l)
s.grp.Done()
}()
if s.EnableBlocklist {
if b, ok := s.underlyingStore.(store.Blocklister); ok {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Dec()
s.enableBlocklist(b)
s.grp.Done()
}()
} else {
//s.Shutdown()
return errors.Err("blocklist is enabled but blob store does not support blocklisting")
}
}
return nil
}
func (s *Server) listenAndServe(listener net.Listener) {
for {
conn, err := listener.Accept()
if err != nil {
if s.quitting() {
return
}
log.Error(err)
} else {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Dec()
s.handleConn(conn)
s.grp.Done()
}()
}
}
}
func (s *Server) handleConn(conn net.Conn) {
// all this stuff is to close the connections correctly when we're shutting down the server
connNeedsClosing := make(chan struct{})
defer func() {
close(connNeedsClosing)
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Dec()
defer s.grp.Done()
select {
case <-connNeedsClosing:
case <-s.grp.Ch():
}
err := conn.Close()
if err != nil {
log.Error(errors.Prefix("closing peer conn", err))
}
}()
err := s.doHandshake(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending handshake error", err))
}
return
}
for {
err = s.receiveBlob(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending blob receive error", err))
}
return
}
}
}
func (s *Server) doError(conn net.Conn, err error) error {
if err == nil {
return nil
}
shouldLog := metrics.TrackError(metrics.DirectionUpload, err)
if shouldLog {
log.Errorln(errors.FullTrace(err))
}
if e2, ok := err.(*json.SyntaxError); ok {
log.Errorf("syntax error at byte offset %d", e2.Offset)
}
//resp, err := json.Marshal(errorResponse{Error: err.Error()})
//if err != nil {
// return err
//}
//return s.write(conn, resp)
return nil
}
func (s *Server) receiveBlob(conn net.Conn) error {
blobSize, blobHash, isSdBlob, err := s.readBlobRequest(conn)
if err != nil {
return err
}
var wantsBlob bool
if bl, ok := s.underlyingStore.(store.Blocklister); ok {
wantsBlob, err = bl.Wants(blobHash)
if err != nil {
return err
}
} else {
blobExists, err := s.underlyingStore.Has(blobHash)
if err != nil {
return err
}
wantsBlob = !blobExists
}
var neededBlobs []string
if isSdBlob && !wantsBlob {
if nbc, ok := s.underlyingStore.(neededBlobChecker); ok {
neededBlobs, err = nbc.MissingBlobsForKnownStream(blobHash)
if err != nil {
return err
}
} else {
// if we can't check for blobs in a stream, we have to say that the sd blob is
// missing. if we say we have the sd blob, they wont try to send any content blobs
wantsBlob = true
}
}
err = s.sendBlobResponse(conn, wantsBlob, isSdBlob, neededBlobs)
if err != nil {
return err
}
if !wantsBlob {
return nil
}
blob, err := s.readRawBlob(conn, blobSize)
if err != nil {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Prefix("error reading blob "+blobHash[:8], err)
}
receivedBlobHash := BlobHash(blob)
if blobHash != receivedBlobHash {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Err("hash of received blob data does not match hash from send request")
// this can also happen if the blob size is wrong, because the server will read the wrong number of bytes from the stream
}
log.Debugln("Got blob " + blobHash[:8])
if isSdBlob {
err = s.outerStore.PutSD(blobHash, blob)
} else {
err = s.outerStore.Put(blobHash, blob)
}
if err != nil {
return err
}
metrics.MtrInBytesReflector.Add(float64(len(blob)))
metrics.BlobUploadCount.Inc()
if isSdBlob {
metrics.SDBlobUploadCount.Inc()
}
return s.sendTransferResponse(conn, true, isSdBlob)
}
func (s *Server) doHandshake(conn net.Conn) error {
var handshake handshakeRequestResponse
err := s.read(conn, &handshake)
if err != nil | else if handshake.Version == nil {
return errors.Err("handshake is missing protocol version")
} else if *handshake.Version != protocolVersion1 && *handshake.Version != protocolVersion2 {
return errors.Err("protocol version not supported")
}
resp, err := json.Marshal(handshakeRequestResponse{Version: handshake.Version})
if err != nil {
return err
}
return s.write(conn, resp)
}
func (s *Server) readBlobRequest(conn net.Conn) (int, string, bool, error) {
var sendRequest sendBlobRequest
err := s.read(conn, &sendRequest)
if err != nil {
return 0, "", false, err
}
var blobHash string
var blobSize int
isSdBlob := sendRequest.SdBlobHash != ""
if isSdBlob {
blobSize = sendRequest.SdBlobSize
blobHash = sendRequest.SdBlobHash
} else {
blobSize = sendRequest.BlobSize
blobHash = sendRequest.BlobHash
}
if blobHash == "" {
return blobSize, blobHash, isSdBlob, errors.Err("blob hash is empty")
}
if blobSize > maxBlobSize {
return blobSize, blobHash, isSdBlob, errors.Err(ErrBlobTooBig)
}
if blobSize == 0 {
return blobSize, blobHash, isSdBlob, errors.Err("0-byte blob received")
}
return blobSize, blobHash, isSdBlob, nil
}
func (s *Server) sendBlobResponse(conn net.Conn, shouldSendBlob, isSdBlob bool, neededBlobs []string) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sendSdBlobResponse{SendSdBlob: shouldSendBlob, NeededBlobs: neededBlobs})
} else {
response, err = json.Marshal(sendBlobResponse{SendBlob: shouldSendBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) sendTransferResponse(conn net.Conn, receivedBlob, isSdBlob bool) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sdBlobTransferResponse{ReceivedSdBlob: receivedBlob})
} else {
response, err = json.Marshal(blobTransferResponse{ReceivedBlob: receivedBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) read(conn net.Conn, v interface{}) error {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
dec := json.NewDecoder(conn)
err = dec.Decode(v)
if err != nil {
data, _ := io.ReadAll(dec.Buffered())
if len(data) > 0 {
return errors.Err("%s. Data: %s", err.Error(), hex.EncodeToString(data))
}
return errors.Err(err)
}
return nil
}
func (s *Server) readRawBlob(conn net.Conn, blobSize int) ([]byte, error) {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return nil, errors.Err(err)
}
blob := make([]byte, blobSize)
_, err = io.ReadFull(bufio.NewReader(conn), blob)
return blob, errors.Err(err)
}
func (s *Server) write(conn net.Conn, b []byte) error {
err := conn.SetWriteDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
n, err := conn.Write(b)
if err == nil && n != len(b) {
err = io.ErrShortWrite
}
return errors.Err(err)
}
func (s *Server) quitting() bool {
select {
case <-s.grp.Ch():
return true
default:
return false
}
}
// BlobHash returns the sha512 hash hex encoded string of the blob byte slice.
func BlobHash(blob []byte) string {
hashBytes := sha512.Sum384(blob)
return hex.EncodeToString(hashBytes[:])
}
func IsValidJSON(b []byte) bool {
var r json.RawMessage
return json.Unmarshal(b, &r) == nil
}
//type errorResponse struct {
// Error string `json:"error"`
//}
type handshakeRequestResponse struct {
Version *int `json:"version"`
}
type sendBlobRequest struct {
BlobHash string `json:"blob_hash,omitempty"`
BlobSize int `json:"blob_size,omitempty"`
SdBlobHash string `json:"sd_blob_hash,omitempty"`
SdBlobSize int `json:"sd_blob_size,omitempty"`
}
type sendBlobResponse struct {
SendBlob bool `json:"send_blob"`
}
type sendSdBlobResponse struct {
SendSdBlob bool `json:"send_sd_blob"`
NeededBlobs []string `json:"needed_blobs,omitempty"`
}
type blobTransferResponse struct {
ReceivedBlob bool `json:"received_blob"`
}
type sdBlobTransferResponse struct {
ReceivedSdBlob bool `json:"received_sd_blob"`
}
// neededBlobChecker can check which blobs from a known stream are not uploaded yet
type neededBlobChecker interface {
MissingBlobsForKnownStream(string) ([]string, error)
}
| {
return err
} | conditional_block |
server.go | package reflector
import (
"bufio"
"crypto/sha512"
"encoding/hex"
"encoding/json"
"io"
"net"
"time"
"github.com/lbryio/reflector.go/internal/metrics"
"github.com/lbryio/reflector.go/store"
"github.com/lbryio/lbry.go/v2/extras/errors"
"github.com/lbryio/lbry.go/v2/extras/stop"
"github.com/lbryio/lbry.go/v2/stream"
log "github.com/sirupsen/logrus"
)
const (
// DefaultPort is the port the reflector server listens on if not passed in.
DefaultPort = 5566
// DefaultTimeout is the default timeout to read or write the next message
DefaultTimeout = 5 * time.Second
network = "tcp4"
protocolVersion1 = 0
protocolVersion2 = 1
maxBlobSize = stream.MaxBlobSize
)
var ErrBlobTooBig = errors.Base("blob must be at most %d bytes", maxBlobSize)
// Server is and instance of the reflector server. It houses the blob store and listener.
type Server struct {
Timeout time.Duration // timeout to read or write next message
EnableBlocklist bool // if true, blocklist checking and blob deletion will be enabled
underlyingStore store.BlobStore
outerStore store.BlobStore
grp *stop.Group
}
// NewServer returns an initialized reflector server pointer.
func NewServer(underlying store.BlobStore, outer store.BlobStore) *Server {
return &Server{
Timeout: DefaultTimeout,
underlyingStore: underlying,
outerStore: outer,
grp: stop.New(),
}
}
// Shutdown shuts down the reflector server gracefully.
func (s *Server) Shutdown() {
log.Println("shutting down reflector server...")
s.grp.StopAndWait()
log.Println("reflector server stopped")
}
// Start starts the server to handle connections.
func (s *Server) Start(address string) error {
l, err := net.Listen(network, address)
if err != nil {
return errors.Err(err)
}
log.Println("reflector listening on " + address)
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Dec()
<-s.grp.Ch()
err := l.Close()
if err != nil {
log.Error(errors.Prefix("closing listener", err))
}
s.grp.Done()
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "start").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "start").Dec()
s.listenAndServe(l)
s.grp.Done()
}()
if s.EnableBlocklist {
if b, ok := s.underlyingStore.(store.Blocklister); ok {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Dec()
s.enableBlocklist(b)
s.grp.Done()
}()
} else {
//s.Shutdown()
return errors.Err("blocklist is enabled but blob store does not support blocklisting")
}
}
return nil
}
func (s *Server) listenAndServe(listener net.Listener) |
func (s *Server) handleConn(conn net.Conn) {
// all this stuff is to close the connections correctly when we're shutting down the server
connNeedsClosing := make(chan struct{})
defer func() {
close(connNeedsClosing)
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Dec()
defer s.grp.Done()
select {
case <-connNeedsClosing:
case <-s.grp.Ch():
}
err := conn.Close()
if err != nil {
log.Error(errors.Prefix("closing peer conn", err))
}
}()
err := s.doHandshake(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending handshake error", err))
}
return
}
for {
err = s.receiveBlob(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending blob receive error", err))
}
return
}
}
}
func (s *Server) doError(conn net.Conn, err error) error {
if err == nil {
return nil
}
shouldLog := metrics.TrackError(metrics.DirectionUpload, err)
if shouldLog {
log.Errorln(errors.FullTrace(err))
}
if e2, ok := err.(*json.SyntaxError); ok {
log.Errorf("syntax error at byte offset %d", e2.Offset)
}
//resp, err := json.Marshal(errorResponse{Error: err.Error()})
//if err != nil {
// return err
//}
//return s.write(conn, resp)
return nil
}
func (s *Server) receiveBlob(conn net.Conn) error {
blobSize, blobHash, isSdBlob, err := s.readBlobRequest(conn)
if err != nil {
return err
}
var wantsBlob bool
if bl, ok := s.underlyingStore.(store.Blocklister); ok {
wantsBlob, err = bl.Wants(blobHash)
if err != nil {
return err
}
} else {
blobExists, err := s.underlyingStore.Has(blobHash)
if err != nil {
return err
}
wantsBlob = !blobExists
}
var neededBlobs []string
if isSdBlob && !wantsBlob {
if nbc, ok := s.underlyingStore.(neededBlobChecker); ok {
neededBlobs, err = nbc.MissingBlobsForKnownStream(blobHash)
if err != nil {
return err
}
} else {
// if we can't check for blobs in a stream, we have to say that the sd blob is
// missing. if we say we have the sd blob, they wont try to send any content blobs
wantsBlob = true
}
}
err = s.sendBlobResponse(conn, wantsBlob, isSdBlob, neededBlobs)
if err != nil {
return err
}
if !wantsBlob {
return nil
}
blob, err := s.readRawBlob(conn, blobSize)
if err != nil {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Prefix("error reading blob "+blobHash[:8], err)
}
receivedBlobHash := BlobHash(blob)
if blobHash != receivedBlobHash {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Err("hash of received blob data does not match hash from send request")
// this can also happen if the blob size is wrong, because the server will read the wrong number of bytes from the stream
}
log.Debugln("Got blob " + blobHash[:8])
if isSdBlob {
err = s.outerStore.PutSD(blobHash, blob)
} else {
err = s.outerStore.Put(blobHash, blob)
}
if err != nil {
return err
}
metrics.MtrInBytesReflector.Add(float64(len(blob)))
metrics.BlobUploadCount.Inc()
if isSdBlob {
metrics.SDBlobUploadCount.Inc()
}
return s.sendTransferResponse(conn, true, isSdBlob)
}
func (s *Server) doHandshake(conn net.Conn) error {
var handshake handshakeRequestResponse
err := s.read(conn, &handshake)
if err != nil {
return err
} else if handshake.Version == nil {
return errors.Err("handshake is missing protocol version")
} else if *handshake.Version != protocolVersion1 && *handshake.Version != protocolVersion2 {
return errors.Err("protocol version not supported")
}
resp, err := json.Marshal(handshakeRequestResponse{Version: handshake.Version})
if err != nil {
return err
}
return s.write(conn, resp)
}
func (s *Server) readBlobRequest(conn net.Conn) (int, string, bool, error) {
var sendRequest sendBlobRequest
err := s.read(conn, &sendRequest)
if err != nil {
return 0, "", false, err
}
var blobHash string
var blobSize int
isSdBlob := sendRequest.SdBlobHash != ""
if isSdBlob {
blobSize = sendRequest.SdBlobSize
blobHash = sendRequest.SdBlobHash
} else {
blobSize = sendRequest.BlobSize
blobHash = sendRequest.BlobHash
}
if blobHash == "" {
return blobSize, blobHash, isSdBlob, errors.Err("blob hash is empty")
}
if blobSize > maxBlobSize {
return blobSize, blobHash, isSdBlob, errors.Err(ErrBlobTooBig)
}
if blobSize == 0 {
return blobSize, blobHash, isSdBlob, errors.Err("0-byte blob received")
}
return blobSize, blobHash, isSdBlob, nil
}
func (s *Server) sendBlobResponse(conn net.Conn, shouldSendBlob, isSdBlob bool, neededBlobs []string) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sendSdBlobResponse{SendSdBlob: shouldSendBlob, NeededBlobs: neededBlobs})
} else {
response, err = json.Marshal(sendBlobResponse{SendBlob: shouldSendBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) sendTransferResponse(conn net.Conn, receivedBlob, isSdBlob bool) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sdBlobTransferResponse{ReceivedSdBlob: receivedBlob})
} else {
response, err = json.Marshal(blobTransferResponse{ReceivedBlob: receivedBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) read(conn net.Conn, v interface{}) error {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
dec := json.NewDecoder(conn)
err = dec.Decode(v)
if err != nil {
data, _ := io.ReadAll(dec.Buffered())
if len(data) > 0 {
return errors.Err("%s. Data: %s", err.Error(), hex.EncodeToString(data))
}
return errors.Err(err)
}
return nil
}
func (s *Server) readRawBlob(conn net.Conn, blobSize int) ([]byte, error) {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return nil, errors.Err(err)
}
blob := make([]byte, blobSize)
_, err = io.ReadFull(bufio.NewReader(conn), blob)
return blob, errors.Err(err)
}
func (s *Server) write(conn net.Conn, b []byte) error {
err := conn.SetWriteDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
n, err := conn.Write(b)
if err == nil && n != len(b) {
err = io.ErrShortWrite
}
return errors.Err(err)
}
func (s *Server) quitting() bool {
select {
case <-s.grp.Ch():
return true
default:
return false
}
}
// BlobHash returns the sha512 hash hex encoded string of the blob byte slice.
func BlobHash(blob []byte) string {
hashBytes := sha512.Sum384(blob)
return hex.EncodeToString(hashBytes[:])
}
func IsValidJSON(b []byte) bool {
var r json.RawMessage
return json.Unmarshal(b, &r) == nil
}
//type errorResponse struct {
// Error string `json:"error"`
//}
type handshakeRequestResponse struct {
Version *int `json:"version"`
}
type sendBlobRequest struct {
BlobHash string `json:"blob_hash,omitempty"`
BlobSize int `json:"blob_size,omitempty"`
SdBlobHash string `json:"sd_blob_hash,omitempty"`
SdBlobSize int `json:"sd_blob_size,omitempty"`
}
type sendBlobResponse struct {
SendBlob bool `json:"send_blob"`
}
type sendSdBlobResponse struct {
SendSdBlob bool `json:"send_sd_blob"`
NeededBlobs []string `json:"needed_blobs,omitempty"`
}
type blobTransferResponse struct {
ReceivedBlob bool `json:"received_blob"`
}
type sdBlobTransferResponse struct {
ReceivedSdBlob bool `json:"received_sd_blob"`
}
// neededBlobChecker can check which blobs from a known stream are not uploaded yet
type neededBlobChecker interface {
MissingBlobsForKnownStream(string) ([]string, error)
}
| {
for {
conn, err := listener.Accept()
if err != nil {
if s.quitting() {
return
}
log.Error(err)
} else {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Dec()
s.handleConn(conn)
s.grp.Done()
}()
}
}
} | identifier_body |
server.go | package reflector
import (
"bufio"
"crypto/sha512"
"encoding/hex"
"encoding/json"
"io"
"net"
"time"
"github.com/lbryio/reflector.go/internal/metrics"
"github.com/lbryio/reflector.go/store"
"github.com/lbryio/lbry.go/v2/extras/errors"
"github.com/lbryio/lbry.go/v2/extras/stop"
"github.com/lbryio/lbry.go/v2/stream"
log "github.com/sirupsen/logrus"
)
const (
// DefaultPort is the port the reflector server listens on if not passed in.
DefaultPort = 5566
// DefaultTimeout is the default timeout to read or write the next message
DefaultTimeout = 5 * time.Second
network = "tcp4"
protocolVersion1 = 0
protocolVersion2 = 1
maxBlobSize = stream.MaxBlobSize
)
var ErrBlobTooBig = errors.Base("blob must be at most %d bytes", maxBlobSize)
// Server is and instance of the reflector server. It houses the blob store and listener.
type Server struct {
Timeout time.Duration // timeout to read or write next message
EnableBlocklist bool // if true, blocklist checking and blob deletion will be enabled
underlyingStore store.BlobStore
outerStore store.BlobStore
grp *stop.Group
}
// NewServer returns an initialized reflector server pointer.
func NewServer(underlying store.BlobStore, outer store.BlobStore) *Server {
return &Server{
Timeout: DefaultTimeout,
underlyingStore: underlying,
outerStore: outer,
grp: stop.New(),
}
}
// Shutdown shuts down the reflector server gracefully.
func (s *Server) Shutdown() {
log.Println("shutting down reflector server...")
s.grp.StopAndWait()
log.Println("reflector server stopped")
}
// Start starts the server to handle connections.
func (s *Server) Start(address string) error {
l, err := net.Listen(network, address)
if err != nil {
return errors.Err(err)
}
log.Println("reflector listening on " + address)
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Dec()
<-s.grp.Ch()
err := l.Close()
if err != nil {
log.Error(errors.Prefix("closing listener", err))
}
s.grp.Done()
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "start").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "start").Dec()
s.listenAndServe(l)
s.grp.Done()
}()
if s.EnableBlocklist {
if b, ok := s.underlyingStore.(store.Blocklister); ok {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Dec()
s.enableBlocklist(b)
s.grp.Done()
}()
} else {
//s.Shutdown()
return errors.Err("blocklist is enabled but blob store does not support blocklisting")
}
}
return nil
}
func (s *Server) listenAndServe(listener net.Listener) {
for {
conn, err := listener.Accept()
if err != nil {
if s.quitting() {
return
}
log.Error(err)
} else {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Dec()
s.handleConn(conn)
s.grp.Done()
}()
}
}
}
func (s *Server) handleConn(conn net.Conn) {
// all this stuff is to close the connections correctly when we're shutting down the server
connNeedsClosing := make(chan struct{})
defer func() {
close(connNeedsClosing)
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Dec()
defer s.grp.Done()
select {
case <-connNeedsClosing:
case <-s.grp.Ch():
}
err := conn.Close()
if err != nil {
log.Error(errors.Prefix("closing peer conn", err))
}
}()
err := s.doHandshake(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending handshake error", err))
}
return
}
for {
err = s.receiveBlob(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending blob receive error", err))
}
return
}
}
}
func (s *Server) doError(conn net.Conn, err error) error {
if err == nil {
return nil
}
shouldLog := metrics.TrackError(metrics.DirectionUpload, err)
if shouldLog {
log.Errorln(errors.FullTrace(err))
}
if e2, ok := err.(*json.SyntaxError); ok {
log.Errorf("syntax error at byte offset %d", e2.Offset)
}
//resp, err := json.Marshal(errorResponse{Error: err.Error()})
//if err != nil {
// return err
//}
//return s.write(conn, resp)
return nil
}
func (s *Server) receiveBlob(conn net.Conn) error {
blobSize, blobHash, isSdBlob, err := s.readBlobRequest(conn)
if err != nil {
return err
}
var wantsBlob bool
if bl, ok := s.underlyingStore.(store.Blocklister); ok {
wantsBlob, err = bl.Wants(blobHash)
if err != nil {
return err
}
} else {
blobExists, err := s.underlyingStore.Has(blobHash)
if err != nil {
return err
}
wantsBlob = !blobExists
}
var neededBlobs []string
if isSdBlob && !wantsBlob {
if nbc, ok := s.underlyingStore.(neededBlobChecker); ok {
neededBlobs, err = nbc.MissingBlobsForKnownStream(blobHash)
if err != nil {
return err
}
} else {
// if we can't check for blobs in a stream, we have to say that the sd blob is
// missing. if we say we have the sd blob, they wont try to send any content blobs
wantsBlob = true
}
}
err = s.sendBlobResponse(conn, wantsBlob, isSdBlob, neededBlobs)
if err != nil {
return err
}
if !wantsBlob {
return nil
}
blob, err := s.readRawBlob(conn, blobSize)
if err != nil {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Prefix("error reading blob "+blobHash[:8], err)
}
receivedBlobHash := BlobHash(blob)
if blobHash != receivedBlobHash {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Err("hash of received blob data does not match hash from send request")
// this can also happen if the blob size is wrong, because the server will read the wrong number of bytes from the stream
}
log.Debugln("Got blob " + blobHash[:8])
if isSdBlob {
err = s.outerStore.PutSD(blobHash, blob)
} else {
err = s.outerStore.Put(blobHash, blob)
}
if err != nil {
return err
}
metrics.MtrInBytesReflector.Add(float64(len(blob)))
metrics.BlobUploadCount.Inc()
if isSdBlob {
metrics.SDBlobUploadCount.Inc()
}
return s.sendTransferResponse(conn, true, isSdBlob)
}
func (s *Server) doHandshake(conn net.Conn) error {
var handshake handshakeRequestResponse
err := s.read(conn, &handshake)
if err != nil {
return err
} else if handshake.Version == nil {
return errors.Err("handshake is missing protocol version")
} else if *handshake.Version != protocolVersion1 && *handshake.Version != protocolVersion2 {
return errors.Err("protocol version not supported")
}
resp, err := json.Marshal(handshakeRequestResponse{Version: handshake.Version})
if err != nil {
return err
}
return s.write(conn, resp)
}
func (s *Server) readBlobRequest(conn net.Conn) (int, string, bool, error) {
var sendRequest sendBlobRequest
err := s.read(conn, &sendRequest)
if err != nil {
return 0, "", false, err
}
var blobHash string
var blobSize int
isSdBlob := sendRequest.SdBlobHash != ""
if isSdBlob {
blobSize = sendRequest.SdBlobSize
blobHash = sendRequest.SdBlobHash
} else {
blobSize = sendRequest.BlobSize
blobHash = sendRequest.BlobHash
}
if blobHash == "" {
return blobSize, blobHash, isSdBlob, errors.Err("blob hash is empty")
}
if blobSize > maxBlobSize {
return blobSize, blobHash, isSdBlob, errors.Err(ErrBlobTooBig)
}
if blobSize == 0 {
return blobSize, blobHash, isSdBlob, errors.Err("0-byte blob received")
}
return blobSize, blobHash, isSdBlob, nil
}
func (s *Server) sendBlobResponse(conn net.Conn, shouldSendBlob, isSdBlob bool, neededBlobs []string) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sendSdBlobResponse{SendSdBlob: shouldSendBlob, NeededBlobs: neededBlobs})
} else {
response, err = json.Marshal(sendBlobResponse{SendBlob: shouldSendBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) sendTransferResponse(conn net.Conn, receivedBlob, isSdBlob bool) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sdBlobTransferResponse{ReceivedSdBlob: receivedBlob})
} else {
response, err = json.Marshal(blobTransferResponse{ReceivedBlob: receivedBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) read(conn net.Conn, v interface{}) error {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
dec := json.NewDecoder(conn)
err = dec.Decode(v)
if err != nil {
data, _ := io.ReadAll(dec.Buffered())
if len(data) > 0 {
return errors.Err("%s. Data: %s", err.Error(), hex.EncodeToString(data))
}
return errors.Err(err)
}
return nil | func (s *Server) readRawBlob(conn net.Conn, blobSize int) ([]byte, error) {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return nil, errors.Err(err)
}
blob := make([]byte, blobSize)
_, err = io.ReadFull(bufio.NewReader(conn), blob)
return blob, errors.Err(err)
}
func (s *Server) write(conn net.Conn, b []byte) error {
err := conn.SetWriteDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
n, err := conn.Write(b)
if err == nil && n != len(b) {
err = io.ErrShortWrite
}
return errors.Err(err)
}
func (s *Server) quitting() bool {
select {
case <-s.grp.Ch():
return true
default:
return false
}
}
// BlobHash returns the sha512 hash hex encoded string of the blob byte slice.
func BlobHash(blob []byte) string {
hashBytes := sha512.Sum384(blob)
return hex.EncodeToString(hashBytes[:])
}
func IsValidJSON(b []byte) bool {
var r json.RawMessage
return json.Unmarshal(b, &r) == nil
}
//type errorResponse struct {
// Error string `json:"error"`
//}
type handshakeRequestResponse struct {
Version *int `json:"version"`
}
type sendBlobRequest struct {
BlobHash string `json:"blob_hash,omitempty"`
BlobSize int `json:"blob_size,omitempty"`
SdBlobHash string `json:"sd_blob_hash,omitempty"`
SdBlobSize int `json:"sd_blob_size,omitempty"`
}
type sendBlobResponse struct {
SendBlob bool `json:"send_blob"`
}
type sendSdBlobResponse struct {
SendSdBlob bool `json:"send_sd_blob"`
NeededBlobs []string `json:"needed_blobs,omitempty"`
}
type blobTransferResponse struct {
ReceivedBlob bool `json:"received_blob"`
}
type sdBlobTransferResponse struct {
ReceivedSdBlob bool `json:"received_sd_blob"`
}
// neededBlobChecker can check which blobs from a known stream are not uploaded yet
type neededBlobChecker interface {
MissingBlobsForKnownStream(string) ([]string, error)
} | }
| random_line_split |
server.go | package reflector
import (
"bufio"
"crypto/sha512"
"encoding/hex"
"encoding/json"
"io"
"net"
"time"
"github.com/lbryio/reflector.go/internal/metrics"
"github.com/lbryio/reflector.go/store"
"github.com/lbryio/lbry.go/v2/extras/errors"
"github.com/lbryio/lbry.go/v2/extras/stop"
"github.com/lbryio/lbry.go/v2/stream"
log "github.com/sirupsen/logrus"
)
const (
// DefaultPort is the port the reflector server listens on if not passed in.
DefaultPort = 5566
// DefaultTimeout is the default timeout to read or write the next message
DefaultTimeout = 5 * time.Second
network = "tcp4"
protocolVersion1 = 0
protocolVersion2 = 1
maxBlobSize = stream.MaxBlobSize
)
var ErrBlobTooBig = errors.Base("blob must be at most %d bytes", maxBlobSize)
// Server is and instance of the reflector server. It houses the blob store and listener.
type Server struct {
Timeout time.Duration // timeout to read or write next message
EnableBlocklist bool // if true, blocklist checking and blob deletion will be enabled
underlyingStore store.BlobStore
outerStore store.BlobStore
grp *stop.Group
}
// NewServer returns an initialized reflector server pointer.
func NewServer(underlying store.BlobStore, outer store.BlobStore) *Server {
return &Server{
Timeout: DefaultTimeout,
underlyingStore: underlying,
outerStore: outer,
grp: stop.New(),
}
}
// Shutdown shuts down the reflector server gracefully.
func (s *Server) Shutdown() {
log.Println("shutting down reflector server...")
s.grp.StopAndWait()
log.Println("reflector server stopped")
}
// Start starts the server to handle connections.
func (s *Server) Start(address string) error {
l, err := net.Listen(network, address)
if err != nil {
return errors.Err(err)
}
log.Println("reflector listening on " + address)
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "listener").Dec()
<-s.grp.Ch()
err := l.Close()
if err != nil {
log.Error(errors.Prefix("closing listener", err))
}
s.grp.Done()
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "start").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "start").Dec()
s.listenAndServe(l)
s.grp.Done()
}()
if s.EnableBlocklist {
if b, ok := s.underlyingStore.(store.Blocklister); ok {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "enableblocklist").Dec()
s.enableBlocklist(b)
s.grp.Done()
}()
} else {
//s.Shutdown()
return errors.Err("blocklist is enabled but blob store does not support blocklisting")
}
}
return nil
}
func (s *Server) listenAndServe(listener net.Listener) {
for {
conn, err := listener.Accept()
if err != nil {
if s.quitting() {
return
}
log.Error(err)
} else {
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-listenandserve").Dec()
s.handleConn(conn)
s.grp.Done()
}()
}
}
}
func (s *Server) handleConn(conn net.Conn) {
// all this stuff is to close the connections correctly when we're shutting down the server
connNeedsClosing := make(chan struct{})
defer func() {
close(connNeedsClosing)
}()
s.grp.Add(1)
metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Inc()
go func() {
defer metrics.RoutinesQueue.WithLabelValues("reflector", "server-handleconn").Dec()
defer s.grp.Done()
select {
case <-connNeedsClosing:
case <-s.grp.Ch():
}
err := conn.Close()
if err != nil {
log.Error(errors.Prefix("closing peer conn", err))
}
}()
err := s.doHandshake(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending handshake error", err))
}
return
}
for {
err = s.receiveBlob(conn)
if err != nil {
if errors.Is(err, io.EOF) || s.quitting() {
return
}
err := s.doError(conn, err)
if err != nil {
log.Error(errors.Prefix("sending blob receive error", err))
}
return
}
}
}
func (s *Server) doError(conn net.Conn, err error) error {
if err == nil {
return nil
}
shouldLog := metrics.TrackError(metrics.DirectionUpload, err)
if shouldLog {
log.Errorln(errors.FullTrace(err))
}
if e2, ok := err.(*json.SyntaxError); ok {
log.Errorf("syntax error at byte offset %d", e2.Offset)
}
//resp, err := json.Marshal(errorResponse{Error: err.Error()})
//if err != nil {
// return err
//}
//return s.write(conn, resp)
return nil
}
func (s *Server) receiveBlob(conn net.Conn) error {
blobSize, blobHash, isSdBlob, err := s.readBlobRequest(conn)
if err != nil {
return err
}
var wantsBlob bool
if bl, ok := s.underlyingStore.(store.Blocklister); ok {
wantsBlob, err = bl.Wants(blobHash)
if err != nil {
return err
}
} else {
blobExists, err := s.underlyingStore.Has(blobHash)
if err != nil {
return err
}
wantsBlob = !blobExists
}
var neededBlobs []string
if isSdBlob && !wantsBlob {
if nbc, ok := s.underlyingStore.(neededBlobChecker); ok {
neededBlobs, err = nbc.MissingBlobsForKnownStream(blobHash)
if err != nil {
return err
}
} else {
// if we can't check for blobs in a stream, we have to say that the sd blob is
// missing. if we say we have the sd blob, they wont try to send any content blobs
wantsBlob = true
}
}
err = s.sendBlobResponse(conn, wantsBlob, isSdBlob, neededBlobs)
if err != nil {
return err
}
if !wantsBlob {
return nil
}
blob, err := s.readRawBlob(conn, blobSize)
if err != nil {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Prefix("error reading blob "+blobHash[:8], err)
}
receivedBlobHash := BlobHash(blob)
if blobHash != receivedBlobHash {
sendErr := s.sendTransferResponse(conn, false, isSdBlob)
if sendErr != nil {
return sendErr
}
return errors.Err("hash of received blob data does not match hash from send request")
// this can also happen if the blob size is wrong, because the server will read the wrong number of bytes from the stream
}
log.Debugln("Got blob " + blobHash[:8])
if isSdBlob {
err = s.outerStore.PutSD(blobHash, blob)
} else {
err = s.outerStore.Put(blobHash, blob)
}
if err != nil {
return err
}
metrics.MtrInBytesReflector.Add(float64(len(blob)))
metrics.BlobUploadCount.Inc()
if isSdBlob {
metrics.SDBlobUploadCount.Inc()
}
return s.sendTransferResponse(conn, true, isSdBlob)
}
func (s *Server) | (conn net.Conn) error {
var handshake handshakeRequestResponse
err := s.read(conn, &handshake)
if err != nil {
return err
} else if handshake.Version == nil {
return errors.Err("handshake is missing protocol version")
} else if *handshake.Version != protocolVersion1 && *handshake.Version != protocolVersion2 {
return errors.Err("protocol version not supported")
}
resp, err := json.Marshal(handshakeRequestResponse{Version: handshake.Version})
if err != nil {
return err
}
return s.write(conn, resp)
}
func (s *Server) readBlobRequest(conn net.Conn) (int, string, bool, error) {
var sendRequest sendBlobRequest
err := s.read(conn, &sendRequest)
if err != nil {
return 0, "", false, err
}
var blobHash string
var blobSize int
isSdBlob := sendRequest.SdBlobHash != ""
if isSdBlob {
blobSize = sendRequest.SdBlobSize
blobHash = sendRequest.SdBlobHash
} else {
blobSize = sendRequest.BlobSize
blobHash = sendRequest.BlobHash
}
if blobHash == "" {
return blobSize, blobHash, isSdBlob, errors.Err("blob hash is empty")
}
if blobSize > maxBlobSize {
return blobSize, blobHash, isSdBlob, errors.Err(ErrBlobTooBig)
}
if blobSize == 0 {
return blobSize, blobHash, isSdBlob, errors.Err("0-byte blob received")
}
return blobSize, blobHash, isSdBlob, nil
}
func (s *Server) sendBlobResponse(conn net.Conn, shouldSendBlob, isSdBlob bool, neededBlobs []string) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sendSdBlobResponse{SendSdBlob: shouldSendBlob, NeededBlobs: neededBlobs})
} else {
response, err = json.Marshal(sendBlobResponse{SendBlob: shouldSendBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) sendTransferResponse(conn net.Conn, receivedBlob, isSdBlob bool) error {
var response []byte
var err error
if isSdBlob {
response, err = json.Marshal(sdBlobTransferResponse{ReceivedSdBlob: receivedBlob})
} else {
response, err = json.Marshal(blobTransferResponse{ReceivedBlob: receivedBlob})
}
if err != nil {
return err
}
return s.write(conn, response)
}
func (s *Server) read(conn net.Conn, v interface{}) error {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
dec := json.NewDecoder(conn)
err = dec.Decode(v)
if err != nil {
data, _ := io.ReadAll(dec.Buffered())
if len(data) > 0 {
return errors.Err("%s. Data: %s", err.Error(), hex.EncodeToString(data))
}
return errors.Err(err)
}
return nil
}
func (s *Server) readRawBlob(conn net.Conn, blobSize int) ([]byte, error) {
err := conn.SetReadDeadline(time.Now().Add(s.Timeout))
if err != nil {
return nil, errors.Err(err)
}
blob := make([]byte, blobSize)
_, err = io.ReadFull(bufio.NewReader(conn), blob)
return blob, errors.Err(err)
}
func (s *Server) write(conn net.Conn, b []byte) error {
err := conn.SetWriteDeadline(time.Now().Add(s.Timeout))
if err != nil {
return errors.Err(err)
}
n, err := conn.Write(b)
if err == nil && n != len(b) {
err = io.ErrShortWrite
}
return errors.Err(err)
}
func (s *Server) quitting() bool {
select {
case <-s.grp.Ch():
return true
default:
return false
}
}
// BlobHash returns the sha512 hash hex encoded string of the blob byte slice.
func BlobHash(blob []byte) string {
hashBytes := sha512.Sum384(blob)
return hex.EncodeToString(hashBytes[:])
}
func IsValidJSON(b []byte) bool {
var r json.RawMessage
return json.Unmarshal(b, &r) == nil
}
//type errorResponse struct {
// Error string `json:"error"`
//}
type handshakeRequestResponse struct {
Version *int `json:"version"`
}
type sendBlobRequest struct {
BlobHash string `json:"blob_hash,omitempty"`
BlobSize int `json:"blob_size,omitempty"`
SdBlobHash string `json:"sd_blob_hash,omitempty"`
SdBlobSize int `json:"sd_blob_size,omitempty"`
}
type sendBlobResponse struct {
SendBlob bool `json:"send_blob"`
}
type sendSdBlobResponse struct {
SendSdBlob bool `json:"send_sd_blob"`
NeededBlobs []string `json:"needed_blobs,omitempty"`
}
type blobTransferResponse struct {
ReceivedBlob bool `json:"received_blob"`
}
type sdBlobTransferResponse struct {
ReceivedSdBlob bool `json:"received_sd_blob"`
}
// neededBlobChecker can check which blobs from a known stream are not uploaded yet
type neededBlobChecker interface {
MissingBlobsForKnownStream(string) ([]string, error)
}
| doHandshake | identifier_name |
mod.rs | // Copyright (c) The Starcoin Core Contributors
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) The Libra Core Contributors
// SPDX-License-Identifier: Apache-2.0
use crate::{
account_address::AccountAddress,
account_config::stc_type_tag,
block_metadata::BlockMetadata,
contract_event::ContractEvent,
vm_error::{StatusCode, StatusType, VMStatus},
write_set::WriteSet,
};
use anyhow::{format_err, Error, Result};
use serde::{de, ser, Deserialize, Serialize};
use starcoin_crypto::keygen::KeyGen;
use starcoin_crypto::{
ed25519::*,
hash::{CryptoHash, CryptoHasher, PlainCryptoHash},
traits::*,
HashValue,
};
use std::ops::Deref;
use std::{convert::TryFrom, fmt, time::Duration};
pub mod authenticator {
pub use libra_types::transaction::authenticator::{
AuthenticationKey, AuthenticationKeyPreimage, Scheme, TransactionAuthenticator,
};
}
mod error;
pub mod helpers;
mod pending_transaction;
mod transaction_argument;
mod upgrade;
use crate::transaction::authenticator::TransactionAuthenticator;
pub use error::CallError;
pub use error::Error as TransactionError;
pub use libra_types::transaction::{ChangeSet, Module, Script};
pub use pending_transaction::{Condition, PendingTransaction};
use starcoin_crypto::multi_ed25519::{MultiEd25519PublicKey, MultiEd25519Signature};
pub use transaction_argument::{
parse_transaction_argument, parse_transaction_arguments, TransactionArgument,
};
pub use upgrade::{InitScript, UpgradePackage};
pub type Version = u64; // Height - also used for MVCC in StateDB
pub const MAX_TRANSACTION_SIZE_IN_BYTES: usize = 4096;
/// RawUserTransaction is the portion of a transaction that a client signs
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct RawUserTransaction {
/// Sender's address.
sender: AccountAddress,
// Sequence number of this transaction corresponding to sender's account.
sequence_number: u64,
// The transaction script to execute.
payload: TransactionPayload,
// Maximal total gas specified by wallet to spend for this transaction.
max_gas_amount: u64,
// Maximal price can be paid per gas.
gas_unit_price: u64,
// Expiration time for this transaction. If storage is queried and
// the time returned is greater than or equal to this time and this
// transaction has not been included, you can be certain that it will
// never be included.
// A transaction that doesn't expire is represented by a very large value like
// u64::max_value().
#[serde(serialize_with = "serialize_duration")]
#[serde(deserialize_with = "deserialize_duration")]
expiration_time: Duration,
}
// TODO(#1307)
fn serialize_duration<S>(d: &Duration, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serializer.serialize_u64(d.as_secs())
}
fn deserialize_duration<'de, D>(deserializer: D) -> std::result::Result<Duration, D::Error>
where
D: de::Deserializer<'de>,
{
struct DurationVisitor;
impl<'de> de::Visitor<'de> for DurationVisitor {
type Value = Duration;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("Duration as u64")
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: de::Error,
{
Ok(Duration::from_secs(v))
}
}
deserializer.deserialize_u64(DurationVisitor)
}
impl RawUserTransaction {
/// Create a new `RawUserTransaction` with a payload.
///
/// It can be either to publish a module, to execute a script, or to issue a writeset
/// transaction.
pub fn new(
sender: AccountAddress,
sequence_number: u64,
payload: TransactionPayload,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload,
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Create a new `RawUserTransaction` with a script.
///
/// A script transaction contains only code to execute. No publishing is allowed in scripts.
pub fn | (
sender: AccountAddress,
sequence_number: u64,
script: Script,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload: TransactionPayload::Script(script),
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Create a new `RawUserTransaction` with a module to publish.
///
/// A module transaction is the only way to publish code. Only one module per transaction
/// can be published.
pub fn new_module(
sender: AccountAddress,
sequence_number: u64,
module: Module,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload: TransactionPayload::Module(module),
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Signs the given `RawUserTransaction`. Note that this consumes the `RawUserTransaction` and turns it
/// into a `SignatureCheckedTransaction`.
///
/// For a transaction that has just been signed, its signature is expected to be valid.
pub fn sign(
self,
private_key: &Ed25519PrivateKey,
public_key: Ed25519PublicKey,
) -> Result<SignatureCheckedTransaction> {
let signature = private_key.sign_message(&self.crypto_hash());
Ok(SignatureCheckedTransaction(SignedUserTransaction::new(
self, public_key, signature,
)))
}
pub fn into_payload(self) -> TransactionPayload {
self.payload
}
/// Return the sender of this transaction.
pub fn sender(&self) -> AccountAddress {
self.sender
}
pub fn mock() -> Self {
Self::mock_by_sender(AccountAddress::random())
}
pub fn mock_by_sender(sender: AccountAddress) -> Self {
Self::new(
sender,
0,
TransactionPayload::Script(Script::new(vec![], vec![], vec![])),
0,
0,
Duration::new(0, 0),
)
}
pub fn mock_from(compiled_script: Vec<u8>) -> Self {
Self::new(
AccountAddress::default(),
0,
TransactionPayload::Script(Script::new(compiled_script, vec![stc_type_tag()], vec![])),
600,
0,
Duration::new(0, 0),
)
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub enum TransactionPayload {
/// A transaction that executes code.
Script(Script),
/// A transaction that publishes code.
Module(Module),
/// A transaction that publish or update module code by a package.
Package(UpgradePackage),
}
/// A transaction that has been signed.
///
/// A `SignedUserTransaction` is a single transaction that can be atomically executed. Clients submit
/// these to validator nodes, and the validator and executor submits these to the VM.
///
/// **IMPORTANT:** The signature of a `SignedUserTransaction` is not guaranteed to be verified. For a
/// transaction whose signature is statically guaranteed to be verified, see
/// [`SignatureCheckedTransaction`].
#[derive(Clone, Eq, PartialEq, Hash, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct SignedUserTransaction {
/// The raw transaction
raw_txn: RawUserTransaction,
/// Public key and signature to authenticate
authenticator: TransactionAuthenticator,
}
/// A transaction for which the signature has been verified. Created by
/// [`SignedUserTransaction::check_signature`] and [`RawUserTransaction::sign`].
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub struct SignatureCheckedTransaction(SignedUserTransaction);
impl SignatureCheckedTransaction {
/// Returns the `SignedUserTransaction` within.
pub fn into_inner(self) -> SignedUserTransaction {
self.0
}
/// Returns the `RawUserTransaction` within.
pub fn into_raw_transaction(self) -> RawUserTransaction {
self.0.into_raw_transaction()
}
}
impl Deref for SignatureCheckedTransaction {
type Target = SignedUserTransaction;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl fmt::Debug for SignedUserTransaction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"SignedTransaction {{ \n \
{{ raw_txn: {:#?}, \n \
authenticator: {:#?}, \n \
}} \n \
}}",
self.raw_txn, self.authenticator
)
}
}
impl SignedUserTransaction {
pub fn new(
raw_txn: RawUserTransaction,
public_key: Ed25519PublicKey,
signature: Ed25519Signature,
) -> SignedUserTransaction {
let authenticator = TransactionAuthenticator::ed25519(public_key, signature);
SignedUserTransaction {
raw_txn,
authenticator,
}
}
pub fn multi_ed25519(
raw_txn: RawUserTransaction,
public_key: MultiEd25519PublicKey,
signature: MultiEd25519Signature,
) -> SignedUserTransaction {
let authenticator = TransactionAuthenticator::multi_ed25519(public_key, signature);
SignedUserTransaction {
raw_txn,
authenticator,
}
}
pub fn authenticator(&self) -> TransactionAuthenticator {
self.authenticator.clone()
}
pub fn raw_txn(&self) -> &RawUserTransaction {
&self.raw_txn
}
pub fn sender(&self) -> AccountAddress {
self.raw_txn.sender
}
pub fn into_raw_transaction(self) -> RawUserTransaction {
self.raw_txn
}
pub fn sequence_number(&self) -> u64 {
self.raw_txn.sequence_number
}
pub fn payload(&self) -> &TransactionPayload {
&self.raw_txn.payload
}
pub fn max_gas_amount(&self) -> u64 {
self.raw_txn.max_gas_amount
}
pub fn gas_unit_price(&self) -> u64 {
self.raw_txn.gas_unit_price
}
pub fn expiration_time(&self) -> Duration {
self.raw_txn.expiration_time
}
pub fn raw_txn_bytes_len(&self) -> usize {
scs::to_bytes(&self.raw_txn)
.expect("Unable to serialize RawUserTransaction")
.len()
}
/// Checks that the signature of given transaction. Returns `Ok(SignatureCheckedTransaction)` if
/// the signature is valid.
pub fn check_signature(self) -> Result<SignatureCheckedTransaction> {
self.authenticator
.verify_signature(&self.raw_txn.crypto_hash())?;
Ok(SignatureCheckedTransaction(self))
}
//TODO
pub fn mock() -> Self {
let mut gen = KeyGen::from_os_rng();
let (private_key, public_key) = gen.generate_keypair();
let raw_txn = RawUserTransaction::mock();
raw_txn.sign(&private_key, public_key).unwrap().into_inner()
}
pub fn mock_from(compiled_script: Vec<u8>) -> Self {
let mut gen = KeyGen::from_os_rng();
let (private_key, public_key) = gen.generate_keypair();
let raw_txn = RawUserTransaction::mock_from(compiled_script);
raw_txn.sign(&private_key, public_key).unwrap().into_inner()
}
}
/// The status of executing a transaction. The VM decides whether or not we should `Keep` the
/// transaction output or `Discard` it based upon the execution of the transaction. We wrap these
/// decisions around a `VMStatus` that provides more detail on the final execution state of the VM.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum TransactionStatus {
/// Discard the transaction output
Discard(VMStatus),
/// Keep the transaction output
Keep(VMStatus),
}
impl TransactionStatus {
pub fn vm_status(&self) -> &VMStatus {
match self {
TransactionStatus::Discard(vm_status) | TransactionStatus::Keep(vm_status) => vm_status,
}
}
}
impl From<VMStatus> for TransactionStatus {
fn from(vm_status: VMStatus) -> Self {
let should_discard = match vm_status.status_type() {
// Any unknown error should be discarded
StatusType::Unknown => true,
// Any error that is a validation status (i.e. an error arising from the prologue)
// causes the transaction to not be included.
StatusType::Validation => true,
// If the VM encountered an invalid internal state, we should discard the transaction.
StatusType::InvariantViolation => true,
// A transaction that publishes code that cannot be verified will be charged.
StatusType::Verification => false,
// Even if we are unable to decode the transaction, there should be a charge made to
// that user's account for the gas fees related to decoding, running the prologue etc.
StatusType::Deserialization => false,
// Any error encountered during the execution of the transaction will charge gas.
StatusType::Execution => false,
};
if should_discard {
TransactionStatus::Discard(vm_status)
} else {
TransactionStatus::Keep(vm_status)
}
}
}
/// The output of executing a transaction.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TransactionOutput {
write_set: WriteSet,
/// The list of events emitted during this transaction.
events: Vec<ContractEvent>,
/// The amount of gas used during execution.
gas_used: u64,
/// The resource increment size
delta_size: i64,
/// The execution status.
status: TransactionStatus,
}
impl TransactionOutput {
pub fn new(
write_set: WriteSet,
events: Vec<ContractEvent>,
gas_used: u64,
delta_size: i64,
status: TransactionStatus,
) -> Self {
TransactionOutput {
write_set,
events,
gas_used,
delta_size,
status,
}
}
pub fn write_set(&self) -> &WriteSet {
&self.write_set
}
pub fn events(&self) -> &[ContractEvent] {
&self.events
}
pub fn gas_used(&self) -> u64 {
self.gas_used
}
pub fn status(&self) -> &TransactionStatus {
&self.status
}
pub fn delta_size(&self) -> i64 {
self.delta_size
}
pub fn into_inner(self) -> (WriteSet, Vec<ContractEvent>, u64, TransactionStatus) {
(self.write_set, self.events, self.gas_used, self.status)
}
}
/// `TransactionInfo` is the object we store in the transaction accumulator. It consists of the
/// transaction as well as the execution result of this transaction.
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct TransactionInfo {
/// The hash of this transaction.
transaction_hash: HashValue,
/// The root hash of Sparse Merkle Tree describing the world state at the end of this
/// transaction.
state_root_hash: HashValue,
/// The root hash of Merkle Accumulator storing all events emitted during this transaction.
event_root_hash: HashValue,
events: Vec<ContractEvent>,
/// The amount of gas used.
gas_used: u64,
/// The major status. This will provide the general error class. Note that this is not
/// particularly high fidelity in the presence of sub statuses but, the major status does
/// determine whether or not the transaction is applied to the global state or not.
major_status: StatusCode,
}
impl TransactionInfo {
/// Constructs a new `TransactionInfo` object using transaction hash, state root hash and event
/// root hash.
pub fn new(
transaction_hash: HashValue,
state_root_hash: HashValue,
event_root_hash: HashValue,
events: Vec<ContractEvent>,
gas_used: u64,
major_status: StatusCode,
) -> TransactionInfo {
TransactionInfo {
transaction_hash,
state_root_hash,
event_root_hash,
events,
gas_used,
major_status,
}
}
pub fn id(&self) -> HashValue {
self.crypto_hash()
}
/// Returns the hash of this transaction.
pub fn transaction_hash(&self) -> HashValue {
self.transaction_hash
}
/// Returns root hash of Sparse Merkle Tree describing the world state at the end of this
/// transaction.
pub fn state_root_hash(&self) -> HashValue {
self.state_root_hash
}
/// Returns the root hash of Merkle Accumulator storing all events emitted during this
/// transaction.
pub fn event_root_hash(&self) -> HashValue {
self.event_root_hash
}
pub fn events(&self) -> &[ContractEvent] {
&self.events
}
/// Returns the amount of gas used by this transaction.
pub fn gas_used(&self) -> u64 {
self.gas_used
}
pub fn major_status(&self) -> StatusCode {
self.major_status
}
}
/// `Transaction` will be the transaction type used internally in the libra node to represent the
/// transaction to be processed and persisted.
///
/// We suppress the clippy warning here as we would expect most of the transaction to be user
/// transaction.
#[allow(clippy::large_enum_variant)]
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub enum Transaction {
/// Transaction submitted by the user. e.g: P2P payment transaction, publishing module
/// transaction, etc.
UserTransaction(SignedUserTransaction),
/// Transaction that applies a ChangeSet to the current ChainState. This should be used for ONLY for
/// genesis right now.
ChangeSet(ChangeSet),
/// Transaction to update the block metadata resource at the beginning of a block.
BlockMetadata(BlockMetadata),
}
impl Transaction {
pub fn as_signed_user_txn(&self) -> Result<&SignedUserTransaction> {
match self {
Transaction::UserTransaction(txn) => Ok(txn),
_ => Err(format_err!("Not a user transaction.")),
}
}
pub fn id(&self) -> HashValue {
//TODO rethink txn id's represent.
self.crypto_hash()
}
}
impl TryFrom<Transaction> for SignedUserTransaction {
type Error = Error;
fn try_from(txn: Transaction) -> Result<Self> {
match txn {
Transaction::UserTransaction(txn) => Ok(txn),
_ => Err(format_err!("Not a user transaction.")),
}
}
}
/// Pool transactions status
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum TxStatus {
/// Added transaction
Added,
/// Rejected transaction
Rejected,
/// Dropped transaction
Dropped,
/// Invalid transaction
Invalid,
/// Canceled transaction
Canceled,
/// Culled transaction
Culled,
}
impl std::fmt::Display for TxStatus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let s = match self {
TxStatus::Added => "added",
TxStatus::Rejected => "rejected",
TxStatus::Dropped => "dropped",
TxStatus::Invalid => "invalid",
TxStatus::Canceled => "canceled",
TxStatus::Culled => "culled",
};
write!(f, "{}", s)
}
}
| new_script | identifier_name |
mod.rs | // Copyright (c) The Starcoin Core Contributors
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) The Libra Core Contributors
// SPDX-License-Identifier: Apache-2.0
use crate::{
account_address::AccountAddress,
account_config::stc_type_tag,
block_metadata::BlockMetadata,
contract_event::ContractEvent,
vm_error::{StatusCode, StatusType, VMStatus},
write_set::WriteSet,
};
use anyhow::{format_err, Error, Result};
use serde::{de, ser, Deserialize, Serialize};
use starcoin_crypto::keygen::KeyGen;
use starcoin_crypto::{
ed25519::*,
hash::{CryptoHash, CryptoHasher, PlainCryptoHash},
traits::*,
HashValue,
};
use std::ops::Deref;
use std::{convert::TryFrom, fmt, time::Duration};
pub mod authenticator {
pub use libra_types::transaction::authenticator::{
AuthenticationKey, AuthenticationKeyPreimage, Scheme, TransactionAuthenticator,
};
}
mod error;
pub mod helpers;
mod pending_transaction;
mod transaction_argument;
mod upgrade;
use crate::transaction::authenticator::TransactionAuthenticator;
pub use error::CallError;
pub use error::Error as TransactionError;
pub use libra_types::transaction::{ChangeSet, Module, Script};
pub use pending_transaction::{Condition, PendingTransaction};
use starcoin_crypto::multi_ed25519::{MultiEd25519PublicKey, MultiEd25519Signature};
pub use transaction_argument::{
parse_transaction_argument, parse_transaction_arguments, TransactionArgument,
};
pub use upgrade::{InitScript, UpgradePackage};
pub type Version = u64; // Height - also used for MVCC in StateDB
pub const MAX_TRANSACTION_SIZE_IN_BYTES: usize = 4096;
/// RawUserTransaction is the portion of a transaction that a client signs
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct RawUserTransaction {
/// Sender's address.
sender: AccountAddress,
// Sequence number of this transaction corresponding to sender's account.
sequence_number: u64,
// The transaction script to execute.
payload: TransactionPayload,
// Maximal total gas specified by wallet to spend for this transaction.
max_gas_amount: u64,
// Maximal price can be paid per gas.
gas_unit_price: u64,
// Expiration time for this transaction. If storage is queried and
// the time returned is greater than or equal to this time and this
// transaction has not been included, you can be certain that it will
// never be included. | expiration_time: Duration,
}
// TODO(#1307)
fn serialize_duration<S>(d: &Duration, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serializer.serialize_u64(d.as_secs())
}
fn deserialize_duration<'de, D>(deserializer: D) -> std::result::Result<Duration, D::Error>
where
D: de::Deserializer<'de>,
{
struct DurationVisitor;
impl<'de> de::Visitor<'de> for DurationVisitor {
type Value = Duration;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("Duration as u64")
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: de::Error,
{
Ok(Duration::from_secs(v))
}
}
deserializer.deserialize_u64(DurationVisitor)
}
impl RawUserTransaction {
/// Create a new `RawUserTransaction` with a payload.
///
/// It can be either to publish a module, to execute a script, or to issue a writeset
/// transaction.
pub fn new(
sender: AccountAddress,
sequence_number: u64,
payload: TransactionPayload,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload,
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Create a new `RawUserTransaction` with a script.
///
/// A script transaction contains only code to execute. No publishing is allowed in scripts.
pub fn new_script(
sender: AccountAddress,
sequence_number: u64,
script: Script,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload: TransactionPayload::Script(script),
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Create a new `RawUserTransaction` with a module to publish.
///
/// A module transaction is the only way to publish code. Only one module per transaction
/// can be published.
pub fn new_module(
sender: AccountAddress,
sequence_number: u64,
module: Module,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload: TransactionPayload::Module(module),
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Signs the given `RawUserTransaction`. Note that this consumes the `RawUserTransaction` and turns it
/// into a `SignatureCheckedTransaction`.
///
/// For a transaction that has just been signed, its signature is expected to be valid.
pub fn sign(
self,
private_key: &Ed25519PrivateKey,
public_key: Ed25519PublicKey,
) -> Result<SignatureCheckedTransaction> {
let signature = private_key.sign_message(&self.crypto_hash());
Ok(SignatureCheckedTransaction(SignedUserTransaction::new(
self, public_key, signature,
)))
}
pub fn into_payload(self) -> TransactionPayload {
self.payload
}
/// Return the sender of this transaction.
pub fn sender(&self) -> AccountAddress {
self.sender
}
pub fn mock() -> Self {
Self::mock_by_sender(AccountAddress::random())
}
pub fn mock_by_sender(sender: AccountAddress) -> Self {
Self::new(
sender,
0,
TransactionPayload::Script(Script::new(vec![], vec![], vec![])),
0,
0,
Duration::new(0, 0),
)
}
pub fn mock_from(compiled_script: Vec<u8>) -> Self {
Self::new(
AccountAddress::default(),
0,
TransactionPayload::Script(Script::new(compiled_script, vec![stc_type_tag()], vec![])),
600,
0,
Duration::new(0, 0),
)
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub enum TransactionPayload {
/// A transaction that executes code.
Script(Script),
/// A transaction that publishes code.
Module(Module),
/// A transaction that publish or update module code by a package.
Package(UpgradePackage),
}
/// A transaction that has been signed.
///
/// A `SignedUserTransaction` is a single transaction that can be atomically executed. Clients submit
/// these to validator nodes, and the validator and executor submits these to the VM.
///
/// **IMPORTANT:** The signature of a `SignedUserTransaction` is not guaranteed to be verified. For a
/// transaction whose signature is statically guaranteed to be verified, see
/// [`SignatureCheckedTransaction`].
#[derive(Clone, Eq, PartialEq, Hash, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct SignedUserTransaction {
/// The raw transaction
raw_txn: RawUserTransaction,
/// Public key and signature to authenticate
authenticator: TransactionAuthenticator,
}
/// A transaction for which the signature has been verified. Created by
/// [`SignedUserTransaction::check_signature`] and [`RawUserTransaction::sign`].
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub struct SignatureCheckedTransaction(SignedUserTransaction);
impl SignatureCheckedTransaction {
/// Returns the `SignedUserTransaction` within.
pub fn into_inner(self) -> SignedUserTransaction {
self.0
}
/// Returns the `RawUserTransaction` within.
pub fn into_raw_transaction(self) -> RawUserTransaction {
self.0.into_raw_transaction()
}
}
impl Deref for SignatureCheckedTransaction {
type Target = SignedUserTransaction;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl fmt::Debug for SignedUserTransaction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"SignedTransaction {{ \n \
{{ raw_txn: {:#?}, \n \
authenticator: {:#?}, \n \
}} \n \
}}",
self.raw_txn, self.authenticator
)
}
}
impl SignedUserTransaction {
pub fn new(
raw_txn: RawUserTransaction,
public_key: Ed25519PublicKey,
signature: Ed25519Signature,
) -> SignedUserTransaction {
let authenticator = TransactionAuthenticator::ed25519(public_key, signature);
SignedUserTransaction {
raw_txn,
authenticator,
}
}
pub fn multi_ed25519(
raw_txn: RawUserTransaction,
public_key: MultiEd25519PublicKey,
signature: MultiEd25519Signature,
) -> SignedUserTransaction {
let authenticator = TransactionAuthenticator::multi_ed25519(public_key, signature);
SignedUserTransaction {
raw_txn,
authenticator,
}
}
pub fn authenticator(&self) -> TransactionAuthenticator {
self.authenticator.clone()
}
pub fn raw_txn(&self) -> &RawUserTransaction {
&self.raw_txn
}
pub fn sender(&self) -> AccountAddress {
self.raw_txn.sender
}
pub fn into_raw_transaction(self) -> RawUserTransaction {
self.raw_txn
}
pub fn sequence_number(&self) -> u64 {
self.raw_txn.sequence_number
}
pub fn payload(&self) -> &TransactionPayload {
&self.raw_txn.payload
}
pub fn max_gas_amount(&self) -> u64 {
self.raw_txn.max_gas_amount
}
pub fn gas_unit_price(&self) -> u64 {
self.raw_txn.gas_unit_price
}
pub fn expiration_time(&self) -> Duration {
self.raw_txn.expiration_time
}
pub fn raw_txn_bytes_len(&self) -> usize {
scs::to_bytes(&self.raw_txn)
.expect("Unable to serialize RawUserTransaction")
.len()
}
/// Checks that the signature of given transaction. Returns `Ok(SignatureCheckedTransaction)` if
/// the signature is valid.
pub fn check_signature(self) -> Result<SignatureCheckedTransaction> {
self.authenticator
.verify_signature(&self.raw_txn.crypto_hash())?;
Ok(SignatureCheckedTransaction(self))
}
//TODO
pub fn mock() -> Self {
let mut gen = KeyGen::from_os_rng();
let (private_key, public_key) = gen.generate_keypair();
let raw_txn = RawUserTransaction::mock();
raw_txn.sign(&private_key, public_key).unwrap().into_inner()
}
pub fn mock_from(compiled_script: Vec<u8>) -> Self {
let mut gen = KeyGen::from_os_rng();
let (private_key, public_key) = gen.generate_keypair();
let raw_txn = RawUserTransaction::mock_from(compiled_script);
raw_txn.sign(&private_key, public_key).unwrap().into_inner()
}
}
/// The status of executing a transaction. The VM decides whether or not we should `Keep` the
/// transaction output or `Discard` it based upon the execution of the transaction. We wrap these
/// decisions around a `VMStatus` that provides more detail on the final execution state of the VM.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum TransactionStatus {
/// Discard the transaction output
Discard(VMStatus),
/// Keep the transaction output
Keep(VMStatus),
}
impl TransactionStatus {
pub fn vm_status(&self) -> &VMStatus {
match self {
TransactionStatus::Discard(vm_status) | TransactionStatus::Keep(vm_status) => vm_status,
}
}
}
impl From<VMStatus> for TransactionStatus {
fn from(vm_status: VMStatus) -> Self {
let should_discard = match vm_status.status_type() {
// Any unknown error should be discarded
StatusType::Unknown => true,
// Any error that is a validation status (i.e. an error arising from the prologue)
// causes the transaction to not be included.
StatusType::Validation => true,
// If the VM encountered an invalid internal state, we should discard the transaction.
StatusType::InvariantViolation => true,
// A transaction that publishes code that cannot be verified will be charged.
StatusType::Verification => false,
// Even if we are unable to decode the transaction, there should be a charge made to
// that user's account for the gas fees related to decoding, running the prologue etc.
StatusType::Deserialization => false,
// Any error encountered during the execution of the transaction will charge gas.
StatusType::Execution => false,
};
if should_discard {
TransactionStatus::Discard(vm_status)
} else {
TransactionStatus::Keep(vm_status)
}
}
}
/// The output of executing a transaction.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TransactionOutput {
write_set: WriteSet,
/// The list of events emitted during this transaction.
events: Vec<ContractEvent>,
/// The amount of gas used during execution.
gas_used: u64,
/// The resource increment size
delta_size: i64,
/// The execution status.
status: TransactionStatus,
}
impl TransactionOutput {
pub fn new(
write_set: WriteSet,
events: Vec<ContractEvent>,
gas_used: u64,
delta_size: i64,
status: TransactionStatus,
) -> Self {
TransactionOutput {
write_set,
events,
gas_used,
delta_size,
status,
}
}
pub fn write_set(&self) -> &WriteSet {
&self.write_set
}
pub fn events(&self) -> &[ContractEvent] {
&self.events
}
pub fn gas_used(&self) -> u64 {
self.gas_used
}
pub fn status(&self) -> &TransactionStatus {
&self.status
}
pub fn delta_size(&self) -> i64 {
self.delta_size
}
pub fn into_inner(self) -> (WriteSet, Vec<ContractEvent>, u64, TransactionStatus) {
(self.write_set, self.events, self.gas_used, self.status)
}
}
/// `TransactionInfo` is the object we store in the transaction accumulator. It consists of the
/// transaction as well as the execution result of this transaction.
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct TransactionInfo {
/// The hash of this transaction.
transaction_hash: HashValue,
/// The root hash of Sparse Merkle Tree describing the world state at the end of this
/// transaction.
state_root_hash: HashValue,
/// The root hash of Merkle Accumulator storing all events emitted during this transaction.
event_root_hash: HashValue,
events: Vec<ContractEvent>,
/// The amount of gas used.
gas_used: u64,
/// The major status. This will provide the general error class. Note that this is not
/// particularly high fidelity in the presence of sub statuses but, the major status does
/// determine whether or not the transaction is applied to the global state or not.
major_status: StatusCode,
}
impl TransactionInfo {
/// Constructs a new `TransactionInfo` object using transaction hash, state root hash and event
/// root hash.
pub fn new(
transaction_hash: HashValue,
state_root_hash: HashValue,
event_root_hash: HashValue,
events: Vec<ContractEvent>,
gas_used: u64,
major_status: StatusCode,
) -> TransactionInfo {
TransactionInfo {
transaction_hash,
state_root_hash,
event_root_hash,
events,
gas_used,
major_status,
}
}
pub fn id(&self) -> HashValue {
self.crypto_hash()
}
/// Returns the hash of this transaction.
pub fn transaction_hash(&self) -> HashValue {
self.transaction_hash
}
/// Returns root hash of Sparse Merkle Tree describing the world state at the end of this
/// transaction.
pub fn state_root_hash(&self) -> HashValue {
self.state_root_hash
}
/// Returns the root hash of Merkle Accumulator storing all events emitted during this
/// transaction.
pub fn event_root_hash(&self) -> HashValue {
self.event_root_hash
}
pub fn events(&self) -> &[ContractEvent] {
&self.events
}
/// Returns the amount of gas used by this transaction.
pub fn gas_used(&self) -> u64 {
self.gas_used
}
pub fn major_status(&self) -> StatusCode {
self.major_status
}
}
/// `Transaction` will be the transaction type used internally in the libra node to represent the
/// transaction to be processed and persisted.
///
/// We suppress the clippy warning here as we would expect most of the transaction to be user
/// transaction.
#[allow(clippy::large_enum_variant)]
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub enum Transaction {
/// Transaction submitted by the user. e.g: P2P payment transaction, publishing module
/// transaction, etc.
UserTransaction(SignedUserTransaction),
/// Transaction that applies a ChangeSet to the current ChainState. This should be used for ONLY for
/// genesis right now.
ChangeSet(ChangeSet),
/// Transaction to update the block metadata resource at the beginning of a block.
BlockMetadata(BlockMetadata),
}
impl Transaction {
pub fn as_signed_user_txn(&self) -> Result<&SignedUserTransaction> {
match self {
Transaction::UserTransaction(txn) => Ok(txn),
_ => Err(format_err!("Not a user transaction.")),
}
}
pub fn id(&self) -> HashValue {
//TODO rethink txn id's represent.
self.crypto_hash()
}
}
impl TryFrom<Transaction> for SignedUserTransaction {
type Error = Error;
fn try_from(txn: Transaction) -> Result<Self> {
match txn {
Transaction::UserTransaction(txn) => Ok(txn),
_ => Err(format_err!("Not a user transaction.")),
}
}
}
/// Pool transactions status
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum TxStatus {
/// Added transaction
Added,
/// Rejected transaction
Rejected,
/// Dropped transaction
Dropped,
/// Invalid transaction
Invalid,
/// Canceled transaction
Canceled,
/// Culled transaction
Culled,
}
impl std::fmt::Display for TxStatus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let s = match self {
TxStatus::Added => "added",
TxStatus::Rejected => "rejected",
TxStatus::Dropped => "dropped",
TxStatus::Invalid => "invalid",
TxStatus::Canceled => "canceled",
TxStatus::Culled => "culled",
};
write!(f, "{}", s)
}
} | // A transaction that doesn't expire is represented by a very large value like
// u64::max_value().
#[serde(serialize_with = "serialize_duration")]
#[serde(deserialize_with = "deserialize_duration")] | random_line_split |
mod.rs | // Copyright (c) The Starcoin Core Contributors
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) The Libra Core Contributors
// SPDX-License-Identifier: Apache-2.0
use crate::{
account_address::AccountAddress,
account_config::stc_type_tag,
block_metadata::BlockMetadata,
contract_event::ContractEvent,
vm_error::{StatusCode, StatusType, VMStatus},
write_set::WriteSet,
};
use anyhow::{format_err, Error, Result};
use serde::{de, ser, Deserialize, Serialize};
use starcoin_crypto::keygen::KeyGen;
use starcoin_crypto::{
ed25519::*,
hash::{CryptoHash, CryptoHasher, PlainCryptoHash},
traits::*,
HashValue,
};
use std::ops::Deref;
use std::{convert::TryFrom, fmt, time::Duration};
pub mod authenticator {
pub use libra_types::transaction::authenticator::{
AuthenticationKey, AuthenticationKeyPreimage, Scheme, TransactionAuthenticator,
};
}
mod error;
pub mod helpers;
mod pending_transaction;
mod transaction_argument;
mod upgrade;
use crate::transaction::authenticator::TransactionAuthenticator;
pub use error::CallError;
pub use error::Error as TransactionError;
pub use libra_types::transaction::{ChangeSet, Module, Script};
pub use pending_transaction::{Condition, PendingTransaction};
use starcoin_crypto::multi_ed25519::{MultiEd25519PublicKey, MultiEd25519Signature};
pub use transaction_argument::{
parse_transaction_argument, parse_transaction_arguments, TransactionArgument,
};
pub use upgrade::{InitScript, UpgradePackage};
pub type Version = u64; // Height - also used for MVCC in StateDB
pub const MAX_TRANSACTION_SIZE_IN_BYTES: usize = 4096;
/// RawUserTransaction is the portion of a transaction that a client signs
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct RawUserTransaction {
/// Sender's address.
sender: AccountAddress,
// Sequence number of this transaction corresponding to sender's account.
sequence_number: u64,
// The transaction script to execute.
payload: TransactionPayload,
// Maximal total gas specified by wallet to spend for this transaction.
max_gas_amount: u64,
// Maximal price can be paid per gas.
gas_unit_price: u64,
// Expiration time for this transaction. If storage is queried and
// the time returned is greater than or equal to this time and this
// transaction has not been included, you can be certain that it will
// never be included.
// A transaction that doesn't expire is represented by a very large value like
// u64::max_value().
#[serde(serialize_with = "serialize_duration")]
#[serde(deserialize_with = "deserialize_duration")]
expiration_time: Duration,
}
// TODO(#1307)
fn serialize_duration<S>(d: &Duration, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serializer.serialize_u64(d.as_secs())
}
fn deserialize_duration<'de, D>(deserializer: D) -> std::result::Result<Duration, D::Error>
where
D: de::Deserializer<'de>,
{
struct DurationVisitor;
impl<'de> de::Visitor<'de> for DurationVisitor {
type Value = Duration;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("Duration as u64")
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: de::Error,
{
Ok(Duration::from_secs(v))
}
}
deserializer.deserialize_u64(DurationVisitor)
}
impl RawUserTransaction {
/// Create a new `RawUserTransaction` with a payload.
///
/// It can be either to publish a module, to execute a script, or to issue a writeset
/// transaction.
pub fn new(
sender: AccountAddress,
sequence_number: u64,
payload: TransactionPayload,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload,
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Create a new `RawUserTransaction` with a script.
///
/// A script transaction contains only code to execute. No publishing is allowed in scripts.
pub fn new_script(
sender: AccountAddress,
sequence_number: u64,
script: Script,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload: TransactionPayload::Script(script),
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Create a new `RawUserTransaction` with a module to publish.
///
/// A module transaction is the only way to publish code. Only one module per transaction
/// can be published.
pub fn new_module(
sender: AccountAddress,
sequence_number: u64,
module: Module,
max_gas_amount: u64,
gas_unit_price: u64,
expiration_time: Duration,
) -> Self {
RawUserTransaction {
sender,
sequence_number,
payload: TransactionPayload::Module(module),
max_gas_amount,
gas_unit_price,
expiration_time,
}
}
/// Signs the given `RawUserTransaction`. Note that this consumes the `RawUserTransaction` and turns it
/// into a `SignatureCheckedTransaction`.
///
/// For a transaction that has just been signed, its signature is expected to be valid.
pub fn sign(
self,
private_key: &Ed25519PrivateKey,
public_key: Ed25519PublicKey,
) -> Result<SignatureCheckedTransaction> {
let signature = private_key.sign_message(&self.crypto_hash());
Ok(SignatureCheckedTransaction(SignedUserTransaction::new(
self, public_key, signature,
)))
}
pub fn into_payload(self) -> TransactionPayload {
self.payload
}
/// Return the sender of this transaction.
pub fn sender(&self) -> AccountAddress {
self.sender
}
pub fn mock() -> Self {
Self::mock_by_sender(AccountAddress::random())
}
pub fn mock_by_sender(sender: AccountAddress) -> Self {
Self::new(
sender,
0,
TransactionPayload::Script(Script::new(vec![], vec![], vec![])),
0,
0,
Duration::new(0, 0),
)
}
pub fn mock_from(compiled_script: Vec<u8>) -> Self {
Self::new(
AccountAddress::default(),
0,
TransactionPayload::Script(Script::new(compiled_script, vec![stc_type_tag()], vec![])),
600,
0,
Duration::new(0, 0),
)
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub enum TransactionPayload {
/// A transaction that executes code.
Script(Script),
/// A transaction that publishes code.
Module(Module),
/// A transaction that publish or update module code by a package.
Package(UpgradePackage),
}
/// A transaction that has been signed.
///
/// A `SignedUserTransaction` is a single transaction that can be atomically executed. Clients submit
/// these to validator nodes, and the validator and executor submits these to the VM.
///
/// **IMPORTANT:** The signature of a `SignedUserTransaction` is not guaranteed to be verified. For a
/// transaction whose signature is statically guaranteed to be verified, see
/// [`SignatureCheckedTransaction`].
#[derive(Clone, Eq, PartialEq, Hash, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct SignedUserTransaction {
/// The raw transaction
raw_txn: RawUserTransaction,
/// Public key and signature to authenticate
authenticator: TransactionAuthenticator,
}
/// A transaction for which the signature has been verified. Created by
/// [`SignedUserTransaction::check_signature`] and [`RawUserTransaction::sign`].
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub struct SignatureCheckedTransaction(SignedUserTransaction);
impl SignatureCheckedTransaction {
/// Returns the `SignedUserTransaction` within.
pub fn into_inner(self) -> SignedUserTransaction {
self.0
}
/// Returns the `RawUserTransaction` within.
pub fn into_raw_transaction(self) -> RawUserTransaction {
self.0.into_raw_transaction()
}
}
impl Deref for SignatureCheckedTransaction {
type Target = SignedUserTransaction;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl fmt::Debug for SignedUserTransaction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"SignedTransaction {{ \n \
{{ raw_txn: {:#?}, \n \
authenticator: {:#?}, \n \
}} \n \
}}",
self.raw_txn, self.authenticator
)
}
}
impl SignedUserTransaction {
pub fn new(
raw_txn: RawUserTransaction,
public_key: Ed25519PublicKey,
signature: Ed25519Signature,
) -> SignedUserTransaction {
let authenticator = TransactionAuthenticator::ed25519(public_key, signature);
SignedUserTransaction {
raw_txn,
authenticator,
}
}
pub fn multi_ed25519(
raw_txn: RawUserTransaction,
public_key: MultiEd25519PublicKey,
signature: MultiEd25519Signature,
) -> SignedUserTransaction {
let authenticator = TransactionAuthenticator::multi_ed25519(public_key, signature);
SignedUserTransaction {
raw_txn,
authenticator,
}
}
pub fn authenticator(&self) -> TransactionAuthenticator {
self.authenticator.clone()
}
pub fn raw_txn(&self) -> &RawUserTransaction |
pub fn sender(&self) -> AccountAddress {
self.raw_txn.sender
}
pub fn into_raw_transaction(self) -> RawUserTransaction {
self.raw_txn
}
pub fn sequence_number(&self) -> u64 {
self.raw_txn.sequence_number
}
pub fn payload(&self) -> &TransactionPayload {
&self.raw_txn.payload
}
pub fn max_gas_amount(&self) -> u64 {
self.raw_txn.max_gas_amount
}
pub fn gas_unit_price(&self) -> u64 {
self.raw_txn.gas_unit_price
}
pub fn expiration_time(&self) -> Duration {
self.raw_txn.expiration_time
}
pub fn raw_txn_bytes_len(&self) -> usize {
scs::to_bytes(&self.raw_txn)
.expect("Unable to serialize RawUserTransaction")
.len()
}
/// Checks that the signature of given transaction. Returns `Ok(SignatureCheckedTransaction)` if
/// the signature is valid.
pub fn check_signature(self) -> Result<SignatureCheckedTransaction> {
self.authenticator
.verify_signature(&self.raw_txn.crypto_hash())?;
Ok(SignatureCheckedTransaction(self))
}
//TODO
pub fn mock() -> Self {
let mut gen = KeyGen::from_os_rng();
let (private_key, public_key) = gen.generate_keypair();
let raw_txn = RawUserTransaction::mock();
raw_txn.sign(&private_key, public_key).unwrap().into_inner()
}
pub fn mock_from(compiled_script: Vec<u8>) -> Self {
let mut gen = KeyGen::from_os_rng();
let (private_key, public_key) = gen.generate_keypair();
let raw_txn = RawUserTransaction::mock_from(compiled_script);
raw_txn.sign(&private_key, public_key).unwrap().into_inner()
}
}
/// The status of executing a transaction. The VM decides whether or not we should `Keep` the
/// transaction output or `Discard` it based upon the execution of the transaction. We wrap these
/// decisions around a `VMStatus` that provides more detail on the final execution state of the VM.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum TransactionStatus {
/// Discard the transaction output
Discard(VMStatus),
/// Keep the transaction output
Keep(VMStatus),
}
impl TransactionStatus {
pub fn vm_status(&self) -> &VMStatus {
match self {
TransactionStatus::Discard(vm_status) | TransactionStatus::Keep(vm_status) => vm_status,
}
}
}
impl From<VMStatus> for TransactionStatus {
fn from(vm_status: VMStatus) -> Self {
let should_discard = match vm_status.status_type() {
// Any unknown error should be discarded
StatusType::Unknown => true,
// Any error that is a validation status (i.e. an error arising from the prologue)
// causes the transaction to not be included.
StatusType::Validation => true,
// If the VM encountered an invalid internal state, we should discard the transaction.
StatusType::InvariantViolation => true,
// A transaction that publishes code that cannot be verified will be charged.
StatusType::Verification => false,
// Even if we are unable to decode the transaction, there should be a charge made to
// that user's account for the gas fees related to decoding, running the prologue etc.
StatusType::Deserialization => false,
// Any error encountered during the execution of the transaction will charge gas.
StatusType::Execution => false,
};
if should_discard {
TransactionStatus::Discard(vm_status)
} else {
TransactionStatus::Keep(vm_status)
}
}
}
/// The output of executing a transaction.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TransactionOutput {
write_set: WriteSet,
/// The list of events emitted during this transaction.
events: Vec<ContractEvent>,
/// The amount of gas used during execution.
gas_used: u64,
/// The resource increment size
delta_size: i64,
/// The execution status.
status: TransactionStatus,
}
impl TransactionOutput {
pub fn new(
write_set: WriteSet,
events: Vec<ContractEvent>,
gas_used: u64,
delta_size: i64,
status: TransactionStatus,
) -> Self {
TransactionOutput {
write_set,
events,
gas_used,
delta_size,
status,
}
}
pub fn write_set(&self) -> &WriteSet {
&self.write_set
}
pub fn events(&self) -> &[ContractEvent] {
&self.events
}
pub fn gas_used(&self) -> u64 {
self.gas_used
}
pub fn status(&self) -> &TransactionStatus {
&self.status
}
pub fn delta_size(&self) -> i64 {
self.delta_size
}
pub fn into_inner(self) -> (WriteSet, Vec<ContractEvent>, u64, TransactionStatus) {
(self.write_set, self.events, self.gas_used, self.status)
}
}
/// `TransactionInfo` is the object we store in the transaction accumulator. It consists of the
/// transaction as well as the execution result of this transaction.
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub struct TransactionInfo {
/// The hash of this transaction.
transaction_hash: HashValue,
/// The root hash of Sparse Merkle Tree describing the world state at the end of this
/// transaction.
state_root_hash: HashValue,
/// The root hash of Merkle Accumulator storing all events emitted during this transaction.
event_root_hash: HashValue,
events: Vec<ContractEvent>,
/// The amount of gas used.
gas_used: u64,
/// The major status. This will provide the general error class. Note that this is not
/// particularly high fidelity in the presence of sub statuses but, the major status does
/// determine whether or not the transaction is applied to the global state or not.
major_status: StatusCode,
}
impl TransactionInfo {
/// Constructs a new `TransactionInfo` object using transaction hash, state root hash and event
/// root hash.
pub fn new(
transaction_hash: HashValue,
state_root_hash: HashValue,
event_root_hash: HashValue,
events: Vec<ContractEvent>,
gas_used: u64,
major_status: StatusCode,
) -> TransactionInfo {
TransactionInfo {
transaction_hash,
state_root_hash,
event_root_hash,
events,
gas_used,
major_status,
}
}
pub fn id(&self) -> HashValue {
self.crypto_hash()
}
/// Returns the hash of this transaction.
pub fn transaction_hash(&self) -> HashValue {
self.transaction_hash
}
/// Returns root hash of Sparse Merkle Tree describing the world state at the end of this
/// transaction.
pub fn state_root_hash(&self) -> HashValue {
self.state_root_hash
}
/// Returns the root hash of Merkle Accumulator storing all events emitted during this
/// transaction.
pub fn event_root_hash(&self) -> HashValue {
self.event_root_hash
}
pub fn events(&self) -> &[ContractEvent] {
&self.events
}
/// Returns the amount of gas used by this transaction.
pub fn gas_used(&self) -> u64 {
self.gas_used
}
pub fn major_status(&self) -> StatusCode {
self.major_status
}
}
/// `Transaction` will be the transaction type used internally in the libra node to represent the
/// transaction to be processed and persisted.
///
/// We suppress the clippy warning here as we would expect most of the transaction to be user
/// transaction.
#[allow(clippy::large_enum_variant)]
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, CryptoHasher, CryptoHash)]
pub enum Transaction {
/// Transaction submitted by the user. e.g: P2P payment transaction, publishing module
/// transaction, etc.
UserTransaction(SignedUserTransaction),
/// Transaction that applies a ChangeSet to the current ChainState. This should be used for ONLY for
/// genesis right now.
ChangeSet(ChangeSet),
/// Transaction to update the block metadata resource at the beginning of a block.
BlockMetadata(BlockMetadata),
}
impl Transaction {
pub fn as_signed_user_txn(&self) -> Result<&SignedUserTransaction> {
match self {
Transaction::UserTransaction(txn) => Ok(txn),
_ => Err(format_err!("Not a user transaction.")),
}
}
pub fn id(&self) -> HashValue {
//TODO rethink txn id's represent.
self.crypto_hash()
}
}
impl TryFrom<Transaction> for SignedUserTransaction {
type Error = Error;
fn try_from(txn: Transaction) -> Result<Self> {
match txn {
Transaction::UserTransaction(txn) => Ok(txn),
_ => Err(format_err!("Not a user transaction.")),
}
}
}
/// Pool transactions status
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum TxStatus {
/// Added transaction
Added,
/// Rejected transaction
Rejected,
/// Dropped transaction
Dropped,
/// Invalid transaction
Invalid,
/// Canceled transaction
Canceled,
/// Culled transaction
Culled,
}
impl std::fmt::Display for TxStatus {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let s = match self {
TxStatus::Added => "added",
TxStatus::Rejected => "rejected",
TxStatus::Dropped => "dropped",
TxStatus::Invalid => "invalid",
TxStatus::Canceled => "canceled",
TxStatus::Culled => "culled",
};
write!(f, "{}", s)
}
}
| {
&self.raw_txn
} | identifier_body |
sorting.go | package rivescript
// Data sorting functions
import (
"errors"
"sort"
"strconv"
"strings"
)
// Sort buffer data, for RiveScript.SortReplies()
type sortBuffer struct {
topics map[string][]sortedTriggerEntry // Topic name -> array of triggers
thats map[string][]sortedTriggerEntry
sub []string // Substitutions
person []string // Person substitutions
}
// Holds a sorted trigger and the pointer to that trigger's data
type sortedTriggerEntry struct {
trigger string
pointer *astTrigger
}
// Temporary categorization of triggers while sorting
type sortTrack struct {
atomic map[int][]sortedTriggerEntry // Sort by number of whole words
option map[int][]sortedTriggerEntry // Sort optionals by number of words
alpha map[int][]sortedTriggerEntry // Sort alpha wildcards by no. of words
number map[int][]sortedTriggerEntry // Sort numeric wildcards by no. of words
wild map[int][]sortedTriggerEntry // Sort wildcards by no. of words
pound []sortedTriggerEntry // Triggers of just '#'
under []sortedTriggerEntry // Triggers of just '_'
star []sortedTriggerEntry // Triggers of just '*'
}
/*
SortReplies sorts the reply structures in memory for optimal matching.
After you have finished loading your RiveScript code, call this method to
populate the various sort buffers. This is absolutely necessary for reply
matching to work efficiently!
If the bot has loaded no topics, or if it ends up with no sorted triggers at
the end, it will return an error saying such. This usually means the bot didn't
load any RiveScript code, for example because it looked in the wrong directory.
*/
func (rs *RiveScript) SortReplies() error {
// (Re)initialize the sort cache.
rs.sorted.topics = map[string][]sortedTriggerEntry{}
rs.sorted.thats = map[string][]sortedTriggerEntry{}
rs.say("Sorting triggers...")
// If there are no topics, give an error.
if len(rs.topics) == 0 {
return errors.New("SortReplies: no topics were found; did you load any RiveScript code?")
}
// Loop through all the topics.
for topic := range rs.topics {
rs.say("Analyzing topic %s", topic)
// Collect a list of all the triggers we're going to worry about. If this
// topic inherits another topic, we need to recursively add those to the
// list as well.
allTriggers := rs.getTopicTriggers(topic, false)
// Sort these triggers.
rs.sorted.topics[topic] = rs.sortTriggerSet(allTriggers, true)
// Get all of the %Previous triggers for this topic.
thatTriggers := rs.getTopicTriggers(topic, true)
// And sort them, too.
rs.sorted.thats[topic] = rs.sortTriggerSet(thatTriggers, false)
}
// Sort the substitution lists.
rs.sorted.sub = sortList(rs.sub)
rs.sorted.person = sortList(rs.person)
// Did we sort anything at all?
if len(rs.sorted.topics) == 0 && len(rs.sorted.thats) == 0 {
return errors.New("SortReplies: ended up with empty trigger lists; did you load any RiveScript code?")
}
return nil
}
/*
sortTriggerSet sorts a group of triggers in an optimal sorting order.
This function has two use cases:
1. Create a sort buffer for "normal" (matchable) triggers, which are triggers
that are NOT accompanied by a %Previous tag.
2. Create a sort buffer for triggers that had %Previous tags.
Use the `excludePrevious` parameter to control which one is being done. This
function will return a list of sortedTriggerEntry items, and it's intended to
have no duplicate trigger patterns (unless the source RiveScript code explicitly
uses the same duplicate pattern twice, which is a user error).
*/
func (rs *RiveScript) sortTriggerSet(triggers []sortedTriggerEntry, excludePrevious bool) []sortedTriggerEntry {
// Create a priority map, of priority numbers -> their triggers.
prior := map[int][]sortedTriggerEntry{}
// Go through and bucket each trigger by weight (priority).
for _, trig := range triggers {
if excludePrevious && trig.pointer.previous != "" {
continue
}
// Check the trigger text for any {weight} tags, default being 0
match := reWeight.FindStringSubmatch(trig.trigger)
weight := 0
if len(match) > 0 {
weight, _ = strconv.Atoi(match[1])
}
// First trigger of this priority? Initialize the weight map.
if _, ok := prior[weight]; !ok {
prior[weight] = []sortedTriggerEntry{}
}
prior[weight] = append(prior[weight], trig)
}
// Keep a running list of sorted triggers for this topic.
running := []sortedTriggerEntry{}
// Sort the priorities with the highest number first.
var sortedPriorities []int
for k := range prior {
sortedPriorities = append(sortedPriorities, k)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedPriorities)))
// Go through each priority set.
for _, p := range sortedPriorities {
rs.say("Sorting triggers with priority %d", p)
// So, some of these triggers may include an {inherits} tag, if they
// came from a topic which inherits another topic. Lower inherits values
// mean higher priority on the stack. Triggers that have NO inherits
// value at all (which will default to -1), will be moved to the END of
// the stack at the end (have the highest number/lowest priority).
inherits := -1 // -1 means no {inherits} tag
highestInherits := -1 // Highest number seen so far
// Loop through and categorize these triggers.
track := map[int]*sortTrack{}
track[inherits] = initSortTrack()
// Loop through all the triggers.
for _, trig := range prior[p] {
pattern := trig.trigger
rs.say("Looking at trigger: %s", pattern)
// See if the trigger has an {inherits} tag.
match := reInherits.FindStringSubmatch(pattern)
if len(match) > 0 {
inherits, _ = strconv.Atoi(match[1])
if inherits > highestInherits {
highestInherits = inherits
}
rs.say("Trigger belongs to a topic that inherits other topics. "+
"Level=%d", inherits)
pattern = reInherits.ReplaceAllString(pattern, "")
} else {
inherits = -1
}
// If this is the first time we've seen this inheritance level,
// initialize its sort track structure.
if _, ok := track[inherits]; !ok {
track[inherits] = initSortTrack()
}
// Start inspecting the trigger's contents.
if strings.Contains(pattern, "_") {
// Alphabetic wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a _ wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].alpha[cnt]; !ok {
track[inherits].alpha[cnt] = []sortedTriggerEntry{}
}
track[inherits].alpha[cnt] = append(track[inherits].alpha[cnt], trig)
} else {
track[inherits].under = append(track[inherits].under, trig)
}
} else if strings.Contains(pattern, "#") {
// Numeric wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a # wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].number[cnt]; !ok {
track[inherits].number[cnt] = []sortedTriggerEntry{}
}
track[inherits].number[cnt] = append(track[inherits].number[cnt], trig)
} else {
track[inherits].pound = append(track[inherits].pound, trig)
}
} else if strings.Contains(pattern, "*") {
// Wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a * wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].wild[cnt]; !ok {
track[inherits].wild[cnt] = []sortedTriggerEntry{}
}
track[inherits].wild[cnt] = append(track[inherits].wild[cnt], trig)
} else {
track[inherits].star = append(track[inherits].star, trig)
}
} else if strings.Contains(pattern, "[") {
// Optionals included.
cnt := wordCount(pattern, false)
rs.say("Has optionals with %d words", cnt)
if _, ok := track[inherits].option[cnt]; !ok {
track[inherits].option[cnt] = []sortedTriggerEntry{}
}
track[inherits].option[cnt] = append(track[inherits].option[cnt], trig)
} else {
// Totally atomic.
cnt := wordCount(pattern, false)
rs.say("Totally atomic trigger with %d words", cnt)
if _, ok := track[inherits].atomic[cnt]; !ok {
track[inherits].atomic[cnt] = []sortedTriggerEntry{}
}
track[inherits].atomic[cnt] = append(track[inherits].atomic[cnt], trig)
}
}
// Move the no-{inherits} triggers to the bottom of the stack.
track[highestInherits+1] = track[-1]
delete(track, -1)
// Sort the track from the lowest to the highest.
var trackSorted []int
for k := range track {
trackSorted = append(trackSorted, k)
}
sort.Ints(trackSorted)
// Go through each priority level from greatest to smallest.
for _, ip := range trackSorted {
rs.say("ip=%d", ip)
// Sort each of the main kinds of triggers by their word counts.
running = sortByWords(running, track[ip].atomic)
running = sortByWords(running, track[ip].option)
running = sortByWords(running, track[ip].alpha)
running = sortByWords(running, track[ip].number)
running = sortByWords(running, track[ip].wild)
// Add the single wildcard triggers, sorted by length.
running = sortByLength(running, track[ip].under)
running = sortByLength(running, track[ip].pound)
running = sortByLength(running, track[ip].star)
}
}
return running
}
// sortList sorts lists (like substitutions) from a string:string map.
func | (dict map[string]string) []string {
output := []string{}
// Track by number of words.
track := map[int][]string{}
// Loop through each item.
for item := range dict {
cnt := wordCount(item, true)
if _, ok := track[cnt]; !ok {
track[cnt] = []string{}
}
track[cnt] = append(track[cnt], item)
}
// Sort them by word count, descending.
sortedCounts := []int{}
for cnt := range track {
sortedCounts = append(sortedCounts, cnt)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedCounts)))
for _, cnt := range sortedCounts {
// Sort the strings of this word-count by their lengths.
sortedLengths := track[cnt]
sort.Sort(sort.Reverse(byLength(sortedLengths)))
output = append(output, sortedLengths...)
}
return output
}
/*
sortByWords sorts a set of triggers by word count and overall length.
This is a helper function for sorting the `atomic`, `option`, `alpha`, `number`
and `wild` attributes of the sortTrack and adding them to the running sort
buffer in that specific order. Since attribute lookup by reflection is expensive
in Go, this function is given the relevant sort buffer directly, and the current
running sort buffer to add the results to.
The `triggers` parameter is a map between word counts and the triggers that
fit that number of words.
*/
func sortByWords(running []sortedTriggerEntry, triggers map[int][]sortedTriggerEntry) []sortedTriggerEntry {
// Sort the triggers by their word counts from greatest to smallest.
var sortedWords []int
for wc := range triggers {
sortedWords = append(sortedWords, wc)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedWords)))
for _, wc := range sortedWords {
// Triggers with equal word lengths should be sorted by overall trigger length.
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers[wc] {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Add the triggers to the running triggers bucket.
for _, pattern := range sortedPatterns {
running = append(running, patternMap[pattern]...)
}
}
return running
}
/*
sortByLength sorts a set of triggers purely by character length.
This is like `sortByWords`, but it's intended for triggers that consist solely
of wildcard-like symbols with no real words. For example a trigger of `* * *`
qualifies for this, and it has no words, so we sort by length so it gets a
higher priority than simply `*`.
*/
func sortByLength(running []sortedTriggerEntry, triggers []sortedTriggerEntry) []sortedTriggerEntry {
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Only loop through unique patterns.
patternSet := map[string]bool{}
// Add them to the running triggers bucket.
for _, pattern := range sortedPatterns {
if _, ok := patternSet[pattern]; ok {
continue
}
patternSet[pattern] = true
running = append(running, patternMap[pattern]...)
}
return running
}
// initSortTrack initializes a new, empty sortTrack object.
func initSortTrack() *sortTrack {
return &sortTrack{
atomic: map[int][]sortedTriggerEntry{},
option: map[int][]sortedTriggerEntry{},
alpha: map[int][]sortedTriggerEntry{},
number: map[int][]sortedTriggerEntry{},
wild: map[int][]sortedTriggerEntry{},
pound: []sortedTriggerEntry{},
under: []sortedTriggerEntry{},
star: []sortedTriggerEntry{},
}
}
| sortList | identifier_name |
sorting.go | package rivescript
// Data sorting functions
import (
"errors"
"sort"
"strconv"
"strings"
)
// Sort buffer data, for RiveScript.SortReplies()
type sortBuffer struct {
topics map[string][]sortedTriggerEntry // Topic name -> array of triggers
thats map[string][]sortedTriggerEntry
sub []string // Substitutions
person []string // Person substitutions
}
// Holds a sorted trigger and the pointer to that trigger's data
type sortedTriggerEntry struct {
trigger string
pointer *astTrigger
}
// Temporary categorization of triggers while sorting
type sortTrack struct {
atomic map[int][]sortedTriggerEntry // Sort by number of whole words
option map[int][]sortedTriggerEntry // Sort optionals by number of words
alpha map[int][]sortedTriggerEntry // Sort alpha wildcards by no. of words
number map[int][]sortedTriggerEntry // Sort numeric wildcards by no. of words
wild map[int][]sortedTriggerEntry // Sort wildcards by no. of words
pound []sortedTriggerEntry // Triggers of just '#'
under []sortedTriggerEntry // Triggers of just '_'
star []sortedTriggerEntry // Triggers of just '*'
}
/*
SortReplies sorts the reply structures in memory for optimal matching.
After you have finished loading your RiveScript code, call this method to
populate the various sort buffers. This is absolutely necessary for reply
matching to work efficiently!
If the bot has loaded no topics, or if it ends up with no sorted triggers at
the end, it will return an error saying such. This usually means the bot didn't
load any RiveScript code, for example because it looked in the wrong directory.
*/
func (rs *RiveScript) SortReplies() error {
// (Re)initialize the sort cache.
rs.sorted.topics = map[string][]sortedTriggerEntry{}
rs.sorted.thats = map[string][]sortedTriggerEntry{}
rs.say("Sorting triggers...")
// If there are no topics, give an error.
if len(rs.topics) == 0 {
return errors.New("SortReplies: no topics were found; did you load any RiveScript code?")
}
// Loop through all the topics.
for topic := range rs.topics {
rs.say("Analyzing topic %s", topic)
// Collect a list of all the triggers we're going to worry about. If this
// topic inherits another topic, we need to recursively add those to the
// list as well.
allTriggers := rs.getTopicTriggers(topic, false)
// Sort these triggers.
rs.sorted.topics[topic] = rs.sortTriggerSet(allTriggers, true)
// Get all of the %Previous triggers for this topic.
thatTriggers := rs.getTopicTriggers(topic, true)
// And sort them, too.
rs.sorted.thats[topic] = rs.sortTriggerSet(thatTriggers, false)
}
// Sort the substitution lists.
rs.sorted.sub = sortList(rs.sub)
rs.sorted.person = sortList(rs.person)
// Did we sort anything at all?
if len(rs.sorted.topics) == 0 && len(rs.sorted.thats) == 0 {
return errors.New("SortReplies: ended up with empty trigger lists; did you load any RiveScript code?")
}
return nil
}
/*
sortTriggerSet sorts a group of triggers in an optimal sorting order.
This function has two use cases:
1. Create a sort buffer for "normal" (matchable) triggers, which are triggers
that are NOT accompanied by a %Previous tag.
2. Create a sort buffer for triggers that had %Previous tags.
Use the `excludePrevious` parameter to control which one is being done. This
function will return a list of sortedTriggerEntry items, and it's intended to
have no duplicate trigger patterns (unless the source RiveScript code explicitly
uses the same duplicate pattern twice, which is a user error).
*/
func (rs *RiveScript) sortTriggerSet(triggers []sortedTriggerEntry, excludePrevious bool) []sortedTriggerEntry {
// Create a priority map, of priority numbers -> their triggers.
prior := map[int][]sortedTriggerEntry{}
// Go through and bucket each trigger by weight (priority).
for _, trig := range triggers {
if excludePrevious && trig.pointer.previous != "" {
continue
}
// Check the trigger text for any {weight} tags, default being 0
match := reWeight.FindStringSubmatch(trig.trigger)
weight := 0
if len(match) > 0 {
weight, _ = strconv.Atoi(match[1])
}
// First trigger of this priority? Initialize the weight map.
if _, ok := prior[weight]; !ok {
prior[weight] = []sortedTriggerEntry{}
}
prior[weight] = append(prior[weight], trig)
}
// Keep a running list of sorted triggers for this topic.
running := []sortedTriggerEntry{}
// Sort the priorities with the highest number first.
var sortedPriorities []int
for k := range prior {
sortedPriorities = append(sortedPriorities, k)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedPriorities)))
// Go through each priority set.
for _, p := range sortedPriorities {
rs.say("Sorting triggers with priority %d", p)
// So, some of these triggers may include an {inherits} tag, if they
// came from a topic which inherits another topic. Lower inherits values
// mean higher priority on the stack. Triggers that have NO inherits
// value at all (which will default to -1), will be moved to the END of
// the stack at the end (have the highest number/lowest priority).
inherits := -1 // -1 means no {inherits} tag
highestInherits := -1 // Highest number seen so far
// Loop through and categorize these triggers.
track := map[int]*sortTrack{}
track[inherits] = initSortTrack()
// Loop through all the triggers.
for _, trig := range prior[p] {
pattern := trig.trigger
rs.say("Looking at trigger: %s", pattern)
// See if the trigger has an {inherits} tag.
match := reInherits.FindStringSubmatch(pattern)
if len(match) > 0 {
inherits, _ = strconv.Atoi(match[1])
if inherits > highestInherits {
highestInherits = inherits
}
rs.say("Trigger belongs to a topic that inherits other topics. "+
"Level=%d", inherits)
pattern = reInherits.ReplaceAllString(pattern, "")
} else {
inherits = -1
}
// If this is the first time we've seen this inheritance level,
// initialize its sort track structure.
if _, ok := track[inherits]; !ok {
track[inherits] = initSortTrack()
}
// Start inspecting the trigger's contents.
if strings.Contains(pattern, "_") {
// Alphabetic wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a _ wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].alpha[cnt]; !ok {
track[inherits].alpha[cnt] = []sortedTriggerEntry{}
}
track[inherits].alpha[cnt] = append(track[inherits].alpha[cnt], trig)
} else {
track[inherits].under = append(track[inherits].under, trig)
}
} else if strings.Contains(pattern, "#") {
// Numeric wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a # wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].number[cnt]; !ok {
track[inherits].number[cnt] = []sortedTriggerEntry{}
}
track[inherits].number[cnt] = append(track[inherits].number[cnt], trig)
} else {
track[inherits].pound = append(track[inherits].pound, trig)
}
} else if strings.Contains(pattern, "*") {
// Wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a * wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].wild[cnt]; !ok {
track[inherits].wild[cnt] = []sortedTriggerEntry{}
}
track[inherits].wild[cnt] = append(track[inherits].wild[cnt], trig)
} else {
track[inherits].star = append(track[inherits].star, trig)
}
} else if strings.Contains(pattern, "[") {
// Optionals included.
cnt := wordCount(pattern, false)
rs.say("Has optionals with %d words", cnt)
if _, ok := track[inherits].option[cnt]; !ok {
track[inherits].option[cnt] = []sortedTriggerEntry{}
}
track[inherits].option[cnt] = append(track[inherits].option[cnt], trig)
} else {
// Totally atomic.
cnt := wordCount(pattern, false)
rs.say("Totally atomic trigger with %d words", cnt)
if _, ok := track[inherits].atomic[cnt]; !ok {
track[inherits].atomic[cnt] = []sortedTriggerEntry{}
}
track[inherits].atomic[cnt] = append(track[inherits].atomic[cnt], trig)
}
}
// Move the no-{inherits} triggers to the bottom of the stack.
track[highestInherits+1] = track[-1]
delete(track, -1)
// Sort the track from the lowest to the highest.
var trackSorted []int
for k := range track {
trackSorted = append(trackSorted, k)
}
sort.Ints(trackSorted)
// Go through each priority level from greatest to smallest.
for _, ip := range trackSorted {
rs.say("ip=%d", ip)
// Sort each of the main kinds of triggers by their word counts.
running = sortByWords(running, track[ip].atomic)
running = sortByWords(running, track[ip].option)
running = sortByWords(running, track[ip].alpha)
running = sortByWords(running, track[ip].number)
running = sortByWords(running, track[ip].wild)
// Add the single wildcard triggers, sorted by length.
running = sortByLength(running, track[ip].under)
running = sortByLength(running, track[ip].pound)
running = sortByLength(running, track[ip].star)
}
}
return running
}
// sortList sorts lists (like substitutions) from a string:string map.
func sortList(dict map[string]string) []string {
output := []string{}
// Track by number of words.
track := map[int][]string{}
// Loop through each item.
for item := range dict {
cnt := wordCount(item, true)
if _, ok := track[cnt]; !ok {
track[cnt] = []string{}
}
track[cnt] = append(track[cnt], item)
}
// Sort them by word count, descending.
sortedCounts := []int{}
for cnt := range track {
sortedCounts = append(sortedCounts, cnt)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedCounts)))
for _, cnt := range sortedCounts {
// Sort the strings of this word-count by their lengths.
sortedLengths := track[cnt]
sort.Sort(sort.Reverse(byLength(sortedLengths)))
output = append(output, sortedLengths...)
}
return output
}
/*
sortByWords sorts a set of triggers by word count and overall length.
This is a helper function for sorting the `atomic`, `option`, `alpha`, `number`
and `wild` attributes of the sortTrack and adding them to the running sort
buffer in that specific order. Since attribute lookup by reflection is expensive
in Go, this function is given the relevant sort buffer directly, and the current
running sort buffer to add the results to.
The `triggers` parameter is a map between word counts and the triggers that
fit that number of words.
*/
func sortByWords(running []sortedTriggerEntry, triggers map[int][]sortedTriggerEntry) []sortedTriggerEntry {
// Sort the triggers by their word counts from greatest to smallest.
var sortedWords []int
for wc := range triggers {
sortedWords = append(sortedWords, wc)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedWords)))
for _, wc := range sortedWords {
// Triggers with equal word lengths should be sorted by overall trigger length.
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers[wc] {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Add the triggers to the running triggers bucket.
for _, pattern := range sortedPatterns {
running = append(running, patternMap[pattern]...)
}
}
return running
}
/*
sortByLength sorts a set of triggers purely by character length.
This is like `sortByWords`, but it's intended for triggers that consist solely
of wildcard-like symbols with no real words. For example a trigger of `* * *`
qualifies for this, and it has no words, so we sort by length so it gets a
higher priority than simply `*`.
*/
func sortByLength(running []sortedTriggerEntry, triggers []sortedTriggerEntry) []sortedTriggerEntry {
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Only loop through unique patterns.
patternSet := map[string]bool{}
// Add them to the running triggers bucket.
for _, pattern := range sortedPatterns {
if _, ok := patternSet[pattern]; ok {
continue
}
patternSet[pattern] = true
running = append(running, patternMap[pattern]...)
}
return running
}
// initSortTrack initializes a new, empty sortTrack object.
func initSortTrack() *sortTrack | {
return &sortTrack{
atomic: map[int][]sortedTriggerEntry{},
option: map[int][]sortedTriggerEntry{},
alpha: map[int][]sortedTriggerEntry{},
number: map[int][]sortedTriggerEntry{},
wild: map[int][]sortedTriggerEntry{},
pound: []sortedTriggerEntry{},
under: []sortedTriggerEntry{},
star: []sortedTriggerEntry{},
}
} | identifier_body | |
sorting.go | package rivescript
// Data sorting functions
import (
"errors"
"sort"
"strconv"
"strings"
)
// Sort buffer data, for RiveScript.SortReplies()
type sortBuffer struct {
topics map[string][]sortedTriggerEntry // Topic name -> array of triggers
thats map[string][]sortedTriggerEntry
sub []string // Substitutions
person []string // Person substitutions
}
// Holds a sorted trigger and the pointer to that trigger's data
type sortedTriggerEntry struct {
trigger string
pointer *astTrigger
}
// Temporary categorization of triggers while sorting
type sortTrack struct {
atomic map[int][]sortedTriggerEntry // Sort by number of whole words
option map[int][]sortedTriggerEntry // Sort optionals by number of words
alpha map[int][]sortedTriggerEntry // Sort alpha wildcards by no. of words
number map[int][]sortedTriggerEntry // Sort numeric wildcards by no. of words
wild map[int][]sortedTriggerEntry // Sort wildcards by no. of words
pound []sortedTriggerEntry // Triggers of just '#'
under []sortedTriggerEntry // Triggers of just '_'
star []sortedTriggerEntry // Triggers of just '*'
}
/*
SortReplies sorts the reply structures in memory for optimal matching.
After you have finished loading your RiveScript code, call this method to
populate the various sort buffers. This is absolutely necessary for reply
matching to work efficiently!
If the bot has loaded no topics, or if it ends up with no sorted triggers at
the end, it will return an error saying such. This usually means the bot didn't
load any RiveScript code, for example because it looked in the wrong directory.
*/
func (rs *RiveScript) SortReplies() error {
// (Re)initialize the sort cache.
rs.sorted.topics = map[string][]sortedTriggerEntry{}
rs.sorted.thats = map[string][]sortedTriggerEntry{}
rs.say("Sorting triggers...")
// If there are no topics, give an error.
if len(rs.topics) == 0 {
return errors.New("SortReplies: no topics were found; did you load any RiveScript code?")
}
// Loop through all the topics.
for topic := range rs.topics {
rs.say("Analyzing topic %s", topic)
// Collect a list of all the triggers we're going to worry about. If this
// topic inherits another topic, we need to recursively add those to the
// list as well.
allTriggers := rs.getTopicTriggers(topic, false)
// Sort these triggers.
rs.sorted.topics[topic] = rs.sortTriggerSet(allTriggers, true)
// Get all of the %Previous triggers for this topic.
thatTriggers := rs.getTopicTriggers(topic, true)
// And sort them, too.
rs.sorted.thats[topic] = rs.sortTriggerSet(thatTriggers, false)
}
// Sort the substitution lists.
rs.sorted.sub = sortList(rs.sub)
rs.sorted.person = sortList(rs.person)
// Did we sort anything at all?
if len(rs.sorted.topics) == 0 && len(rs.sorted.thats) == 0 {
return errors.New("SortReplies: ended up with empty trigger lists; did you load any RiveScript code?")
}
return nil
}
/*
sortTriggerSet sorts a group of triggers in an optimal sorting order.
This function has two use cases:
1. Create a sort buffer for "normal" (matchable) triggers, which are triggers
that are NOT accompanied by a %Previous tag.
2. Create a sort buffer for triggers that had %Previous tags.
Use the `excludePrevious` parameter to control which one is being done. This
function will return a list of sortedTriggerEntry items, and it's intended to
have no duplicate trigger patterns (unless the source RiveScript code explicitly
uses the same duplicate pattern twice, which is a user error).
*/
func (rs *RiveScript) sortTriggerSet(triggers []sortedTriggerEntry, excludePrevious bool) []sortedTriggerEntry {
// Create a priority map, of priority numbers -> their triggers.
prior := map[int][]sortedTriggerEntry{}
// Go through and bucket each trigger by weight (priority).
for _, trig := range triggers {
if excludePrevious && trig.pointer.previous != "" {
continue
}
// Check the trigger text for any {weight} tags, default being 0
match := reWeight.FindStringSubmatch(trig.trigger)
weight := 0
if len(match) > 0 {
weight, _ = strconv.Atoi(match[1])
}
// First trigger of this priority? Initialize the weight map.
if _, ok := prior[weight]; !ok {
prior[weight] = []sortedTriggerEntry{}
}
prior[weight] = append(prior[weight], trig)
}
// Keep a running list of sorted triggers for this topic.
running := []sortedTriggerEntry{}
// Sort the priorities with the highest number first.
var sortedPriorities []int
for k := range prior {
sortedPriorities = append(sortedPriorities, k)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedPriorities)))
// Go through each priority set.
for _, p := range sortedPriorities {
rs.say("Sorting triggers with priority %d", p)
// So, some of these triggers may include an {inherits} tag, if they
// came from a topic which inherits another topic. Lower inherits values
// mean higher priority on the stack. Triggers that have NO inherits
// value at all (which will default to -1), will be moved to the END of
// the stack at the end (have the highest number/lowest priority).
inherits := -1 // -1 means no {inherits} tag
highestInherits := -1 // Highest number seen so far
// Loop through and categorize these triggers.
track := map[int]*sortTrack{}
track[inherits] = initSortTrack()
// Loop through all the triggers.
for _, trig := range prior[p] {
pattern := trig.trigger
rs.say("Looking at trigger: %s", pattern)
// See if the trigger has an {inherits} tag.
match := reInherits.FindStringSubmatch(pattern)
if len(match) > 0 {
inherits, _ = strconv.Atoi(match[1])
if inherits > highestInherits {
highestInherits = inherits
}
rs.say("Trigger belongs to a topic that inherits other topics. "+
"Level=%d", inherits)
pattern = reInherits.ReplaceAllString(pattern, "")
} else {
inherits = -1
}
// If this is the first time we've seen this inheritance level,
// initialize its sort track structure.
if _, ok := track[inherits]; !ok {
track[inherits] = initSortTrack()
}
// Start inspecting the trigger's contents.
if strings.Contains(pattern, "_") {
// Alphabetic wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a _ wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].alpha[cnt]; !ok {
track[inherits].alpha[cnt] = []sortedTriggerEntry{}
}
track[inherits].alpha[cnt] = append(track[inherits].alpha[cnt], trig)
} else {
track[inherits].under = append(track[inherits].under, trig)
}
} else if strings.Contains(pattern, "#") {
// Numeric wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a # wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].number[cnt]; !ok {
track[inherits].number[cnt] = []sortedTriggerEntry{}
}
track[inherits].number[cnt] = append(track[inherits].number[cnt], trig)
} else {
track[inherits].pound = append(track[inherits].pound, trig)
}
} else if strings.Contains(pattern, "*") {
// Wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a * wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].wild[cnt]; !ok {
track[inherits].wild[cnt] = []sortedTriggerEntry{}
}
track[inherits].wild[cnt] = append(track[inherits].wild[cnt], trig)
} else {
track[inherits].star = append(track[inherits].star, trig)
}
} else if strings.Contains(pattern, "[") {
// Optionals included.
cnt := wordCount(pattern, false)
rs.say("Has optionals with %d words", cnt)
if _, ok := track[inherits].option[cnt]; !ok {
track[inherits].option[cnt] = []sortedTriggerEntry{}
}
track[inherits].option[cnt] = append(track[inherits].option[cnt], trig)
} else {
// Totally atomic.
cnt := wordCount(pattern, false) | track[inherits].atomic[cnt] = append(track[inherits].atomic[cnt], trig)
}
}
// Move the no-{inherits} triggers to the bottom of the stack.
track[highestInherits+1] = track[-1]
delete(track, -1)
// Sort the track from the lowest to the highest.
var trackSorted []int
for k := range track {
trackSorted = append(trackSorted, k)
}
sort.Ints(trackSorted)
// Go through each priority level from greatest to smallest.
for _, ip := range trackSorted {
rs.say("ip=%d", ip)
// Sort each of the main kinds of triggers by their word counts.
running = sortByWords(running, track[ip].atomic)
running = sortByWords(running, track[ip].option)
running = sortByWords(running, track[ip].alpha)
running = sortByWords(running, track[ip].number)
running = sortByWords(running, track[ip].wild)
// Add the single wildcard triggers, sorted by length.
running = sortByLength(running, track[ip].under)
running = sortByLength(running, track[ip].pound)
running = sortByLength(running, track[ip].star)
}
}
return running
}
// sortList sorts lists (like substitutions) from a string:string map.
func sortList(dict map[string]string) []string {
output := []string{}
// Track by number of words.
track := map[int][]string{}
// Loop through each item.
for item := range dict {
cnt := wordCount(item, true)
if _, ok := track[cnt]; !ok {
track[cnt] = []string{}
}
track[cnt] = append(track[cnt], item)
}
// Sort them by word count, descending.
sortedCounts := []int{}
for cnt := range track {
sortedCounts = append(sortedCounts, cnt)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedCounts)))
for _, cnt := range sortedCounts {
// Sort the strings of this word-count by their lengths.
sortedLengths := track[cnt]
sort.Sort(sort.Reverse(byLength(sortedLengths)))
output = append(output, sortedLengths...)
}
return output
}
/*
sortByWords sorts a set of triggers by word count and overall length.
This is a helper function for sorting the `atomic`, `option`, `alpha`, `number`
and `wild` attributes of the sortTrack and adding them to the running sort
buffer in that specific order. Since attribute lookup by reflection is expensive
in Go, this function is given the relevant sort buffer directly, and the current
running sort buffer to add the results to.
The `triggers` parameter is a map between word counts and the triggers that
fit that number of words.
*/
func sortByWords(running []sortedTriggerEntry, triggers map[int][]sortedTriggerEntry) []sortedTriggerEntry {
// Sort the triggers by their word counts from greatest to smallest.
var sortedWords []int
for wc := range triggers {
sortedWords = append(sortedWords, wc)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedWords)))
for _, wc := range sortedWords {
// Triggers with equal word lengths should be sorted by overall trigger length.
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers[wc] {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Add the triggers to the running triggers bucket.
for _, pattern := range sortedPatterns {
running = append(running, patternMap[pattern]...)
}
}
return running
}
/*
sortByLength sorts a set of triggers purely by character length.
This is like `sortByWords`, but it's intended for triggers that consist solely
of wildcard-like symbols with no real words. For example a trigger of `* * *`
qualifies for this, and it has no words, so we sort by length so it gets a
higher priority than simply `*`.
*/
func sortByLength(running []sortedTriggerEntry, triggers []sortedTriggerEntry) []sortedTriggerEntry {
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Only loop through unique patterns.
patternSet := map[string]bool{}
// Add them to the running triggers bucket.
for _, pattern := range sortedPatterns {
if _, ok := patternSet[pattern]; ok {
continue
}
patternSet[pattern] = true
running = append(running, patternMap[pattern]...)
}
return running
}
// initSortTrack initializes a new, empty sortTrack object.
func initSortTrack() *sortTrack {
return &sortTrack{
atomic: map[int][]sortedTriggerEntry{},
option: map[int][]sortedTriggerEntry{},
alpha: map[int][]sortedTriggerEntry{},
number: map[int][]sortedTriggerEntry{},
wild: map[int][]sortedTriggerEntry{},
pound: []sortedTriggerEntry{},
under: []sortedTriggerEntry{},
star: []sortedTriggerEntry{},
}
} | rs.say("Totally atomic trigger with %d words", cnt)
if _, ok := track[inherits].atomic[cnt]; !ok {
track[inherits].atomic[cnt] = []sortedTriggerEntry{}
} | random_line_split |
sorting.go | package rivescript
// Data sorting functions
import (
"errors"
"sort"
"strconv"
"strings"
)
// Sort buffer data, for RiveScript.SortReplies()
type sortBuffer struct {
topics map[string][]sortedTriggerEntry // Topic name -> array of triggers
thats map[string][]sortedTriggerEntry
sub []string // Substitutions
person []string // Person substitutions
}
// Holds a sorted trigger and the pointer to that trigger's data
type sortedTriggerEntry struct {
trigger string
pointer *astTrigger
}
// Temporary categorization of triggers while sorting
type sortTrack struct {
atomic map[int][]sortedTriggerEntry // Sort by number of whole words
option map[int][]sortedTriggerEntry // Sort optionals by number of words
alpha map[int][]sortedTriggerEntry // Sort alpha wildcards by no. of words
number map[int][]sortedTriggerEntry // Sort numeric wildcards by no. of words
wild map[int][]sortedTriggerEntry // Sort wildcards by no. of words
pound []sortedTriggerEntry // Triggers of just '#'
under []sortedTriggerEntry // Triggers of just '_'
star []sortedTriggerEntry // Triggers of just '*'
}
/*
SortReplies sorts the reply structures in memory for optimal matching.
After you have finished loading your RiveScript code, call this method to
populate the various sort buffers. This is absolutely necessary for reply
matching to work efficiently!
If the bot has loaded no topics, or if it ends up with no sorted triggers at
the end, it will return an error saying such. This usually means the bot didn't
load any RiveScript code, for example because it looked in the wrong directory.
*/
func (rs *RiveScript) SortReplies() error {
// (Re)initialize the sort cache.
rs.sorted.topics = map[string][]sortedTriggerEntry{}
rs.sorted.thats = map[string][]sortedTriggerEntry{}
rs.say("Sorting triggers...")
// If there are no topics, give an error.
if len(rs.topics) == 0 {
return errors.New("SortReplies: no topics were found; did you load any RiveScript code?")
}
// Loop through all the topics.
for topic := range rs.topics {
rs.say("Analyzing topic %s", topic)
// Collect a list of all the triggers we're going to worry about. If this
// topic inherits another topic, we need to recursively add those to the
// list as well.
allTriggers := rs.getTopicTriggers(topic, false)
// Sort these triggers.
rs.sorted.topics[topic] = rs.sortTriggerSet(allTriggers, true)
// Get all of the %Previous triggers for this topic.
thatTriggers := rs.getTopicTriggers(topic, true)
// And sort them, too.
rs.sorted.thats[topic] = rs.sortTriggerSet(thatTriggers, false)
}
// Sort the substitution lists.
rs.sorted.sub = sortList(rs.sub)
rs.sorted.person = sortList(rs.person)
// Did we sort anything at all?
if len(rs.sorted.topics) == 0 && len(rs.sorted.thats) == 0 {
return errors.New("SortReplies: ended up with empty trigger lists; did you load any RiveScript code?")
}
return nil
}
/*
sortTriggerSet sorts a group of triggers in an optimal sorting order.
This function has two use cases:
1. Create a sort buffer for "normal" (matchable) triggers, which are triggers
that are NOT accompanied by a %Previous tag.
2. Create a sort buffer for triggers that had %Previous tags.
Use the `excludePrevious` parameter to control which one is being done. This
function will return a list of sortedTriggerEntry items, and it's intended to
have no duplicate trigger patterns (unless the source RiveScript code explicitly
uses the same duplicate pattern twice, which is a user error).
*/
func (rs *RiveScript) sortTriggerSet(triggers []sortedTriggerEntry, excludePrevious bool) []sortedTriggerEntry {
// Create a priority map, of priority numbers -> their triggers.
prior := map[int][]sortedTriggerEntry{}
// Go through and bucket each trigger by weight (priority).
for _, trig := range triggers {
if excludePrevious && trig.pointer.previous != "" {
continue
}
// Check the trigger text for any {weight} tags, default being 0
match := reWeight.FindStringSubmatch(trig.trigger)
weight := 0
if len(match) > 0 {
weight, _ = strconv.Atoi(match[1])
}
// First trigger of this priority? Initialize the weight map.
if _, ok := prior[weight]; !ok {
prior[weight] = []sortedTriggerEntry{}
}
prior[weight] = append(prior[weight], trig)
}
// Keep a running list of sorted triggers for this topic.
running := []sortedTriggerEntry{}
// Sort the priorities with the highest number first.
var sortedPriorities []int
for k := range prior {
sortedPriorities = append(sortedPriorities, k)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedPriorities)))
// Go through each priority set.
for _, p := range sortedPriorities {
rs.say("Sorting triggers with priority %d", p)
// So, some of these triggers may include an {inherits} tag, if they
// came from a topic which inherits another topic. Lower inherits values
// mean higher priority on the stack. Triggers that have NO inherits
// value at all (which will default to -1), will be moved to the END of
// the stack at the end (have the highest number/lowest priority).
inherits := -1 // -1 means no {inherits} tag
highestInherits := -1 // Highest number seen so far
// Loop through and categorize these triggers.
track := map[int]*sortTrack{}
track[inherits] = initSortTrack()
// Loop through all the triggers.
for _, trig := range prior[p] {
pattern := trig.trigger
rs.say("Looking at trigger: %s", pattern)
// See if the trigger has an {inherits} tag.
match := reInherits.FindStringSubmatch(pattern)
if len(match) > 0 {
inherits, _ = strconv.Atoi(match[1])
if inherits > highestInherits {
highestInherits = inherits
}
rs.say("Trigger belongs to a topic that inherits other topics. "+
"Level=%d", inherits)
pattern = reInherits.ReplaceAllString(pattern, "")
} else {
inherits = -1
}
// If this is the first time we've seen this inheritance level,
// initialize its sort track structure.
if _, ok := track[inherits]; !ok {
track[inherits] = initSortTrack()
}
// Start inspecting the trigger's contents.
if strings.Contains(pattern, "_") {
// Alphabetic wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a _ wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].alpha[cnt]; !ok {
track[inherits].alpha[cnt] = []sortedTriggerEntry{}
}
track[inherits].alpha[cnt] = append(track[inherits].alpha[cnt], trig)
} else {
track[inherits].under = append(track[inherits].under, trig)
}
} else if strings.Contains(pattern, "#") {
// Numeric wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a # wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].number[cnt]; !ok {
track[inherits].number[cnt] = []sortedTriggerEntry{}
}
track[inherits].number[cnt] = append(track[inherits].number[cnt], trig)
} else {
track[inherits].pound = append(track[inherits].pound, trig)
}
} else if strings.Contains(pattern, "*") {
// Wildcard included.
cnt := wordCount(pattern, false)
rs.say("Has a * wildcard with %d words", cnt)
if cnt > 0 {
if _, ok := track[inherits].wild[cnt]; !ok {
track[inherits].wild[cnt] = []sortedTriggerEntry{}
}
track[inherits].wild[cnt] = append(track[inherits].wild[cnt], trig)
} else {
track[inherits].star = append(track[inherits].star, trig)
}
} else if strings.Contains(pattern, "[") {
// Optionals included.
cnt := wordCount(pattern, false)
rs.say("Has optionals with %d words", cnt)
if _, ok := track[inherits].option[cnt]; !ok {
track[inherits].option[cnt] = []sortedTriggerEntry{}
}
track[inherits].option[cnt] = append(track[inherits].option[cnt], trig)
} else {
// Totally atomic.
cnt := wordCount(pattern, false)
rs.say("Totally atomic trigger with %d words", cnt)
if _, ok := track[inherits].atomic[cnt]; !ok {
track[inherits].atomic[cnt] = []sortedTriggerEntry{}
}
track[inherits].atomic[cnt] = append(track[inherits].atomic[cnt], trig)
}
}
// Move the no-{inherits} triggers to the bottom of the stack.
track[highestInherits+1] = track[-1]
delete(track, -1)
// Sort the track from the lowest to the highest.
var trackSorted []int
for k := range track {
trackSorted = append(trackSorted, k)
}
sort.Ints(trackSorted)
// Go through each priority level from greatest to smallest.
for _, ip := range trackSorted {
rs.say("ip=%d", ip)
// Sort each of the main kinds of triggers by their word counts.
running = sortByWords(running, track[ip].atomic)
running = sortByWords(running, track[ip].option)
running = sortByWords(running, track[ip].alpha)
running = sortByWords(running, track[ip].number)
running = sortByWords(running, track[ip].wild)
// Add the single wildcard triggers, sorted by length.
running = sortByLength(running, track[ip].under)
running = sortByLength(running, track[ip].pound)
running = sortByLength(running, track[ip].star)
}
}
return running
}
// sortList sorts lists (like substitutions) from a string:string map.
func sortList(dict map[string]string) []string {
output := []string{}
// Track by number of words.
track := map[int][]string{}
// Loop through each item.
for item := range dict {
cnt := wordCount(item, true)
if _, ok := track[cnt]; !ok {
track[cnt] = []string{}
}
track[cnt] = append(track[cnt], item)
}
// Sort them by word count, descending.
sortedCounts := []int{}
for cnt := range track {
sortedCounts = append(sortedCounts, cnt)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedCounts)))
for _, cnt := range sortedCounts {
// Sort the strings of this word-count by their lengths.
sortedLengths := track[cnt]
sort.Sort(sort.Reverse(byLength(sortedLengths)))
output = append(output, sortedLengths...)
}
return output
}
/*
sortByWords sorts a set of triggers by word count and overall length.
This is a helper function for sorting the `atomic`, `option`, `alpha`, `number`
and `wild` attributes of the sortTrack and adding them to the running sort
buffer in that specific order. Since attribute lookup by reflection is expensive
in Go, this function is given the relevant sort buffer directly, and the current
running sort buffer to add the results to.
The `triggers` parameter is a map between word counts and the triggers that
fit that number of words.
*/
func sortByWords(running []sortedTriggerEntry, triggers map[int][]sortedTriggerEntry) []sortedTriggerEntry {
// Sort the triggers by their word counts from greatest to smallest.
var sortedWords []int
for wc := range triggers {
sortedWords = append(sortedWords, wc)
}
sort.Sort(sort.Reverse(sort.IntSlice(sortedWords)))
for _, wc := range sortedWords {
// Triggers with equal word lengths should be sorted by overall trigger length.
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers[wc] {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Add the triggers to the running triggers bucket.
for _, pattern := range sortedPatterns {
running = append(running, patternMap[pattern]...)
}
}
return running
}
/*
sortByLength sorts a set of triggers purely by character length.
This is like `sortByWords`, but it's intended for triggers that consist solely
of wildcard-like symbols with no real words. For example a trigger of `* * *`
qualifies for this, and it has no words, so we sort by length so it gets a
higher priority than simply `*`.
*/
func sortByLength(running []sortedTriggerEntry, triggers []sortedTriggerEntry) []sortedTriggerEntry {
var sortedPatterns []string
patternMap := map[string][]sortedTriggerEntry{}
for _, trig := range triggers {
sortedPatterns = append(sortedPatterns, trig.trigger)
if _, ok := patternMap[trig.trigger]; !ok {
patternMap[trig.trigger] = []sortedTriggerEntry{}
}
patternMap[trig.trigger] = append(patternMap[trig.trigger], trig)
}
sort.Sort(sort.Reverse(byLength(sortedPatterns)))
// Only loop through unique patterns.
patternSet := map[string]bool{}
// Add them to the running triggers bucket.
for _, pattern := range sortedPatterns {
if _, ok := patternSet[pattern]; ok |
patternSet[pattern] = true
running = append(running, patternMap[pattern]...)
}
return running
}
// initSortTrack initializes a new, empty sortTrack object.
func initSortTrack() *sortTrack {
return &sortTrack{
atomic: map[int][]sortedTriggerEntry{},
option: map[int][]sortedTriggerEntry{},
alpha: map[int][]sortedTriggerEntry{},
number: map[int][]sortedTriggerEntry{},
wild: map[int][]sortedTriggerEntry{},
pound: []sortedTriggerEntry{},
under: []sortedTriggerEntry{},
star: []sortedTriggerEntry{},
}
}
| {
continue
} | conditional_block |
app.js | var SECONDS = 59;
var MINUTES = 3;
var SCORE = [0,0];
var VALUE1;
var VALUE2;
var sliceCount = 0;
var p1data = [];
var p2data = [];
var p1trend = "0";
var p2trend = "0";
var multiplierA;
var multiplierB;
var makePointsFlag = true;
var P1NAME;
var P2NAME;
var P1EMAIL;
var P2EMAIL;
var COMBONAME = null;
function add(a, b) {
return a + b;
}
function aggregateAverage () {//calculates the average SCORE of all players
var average = 0; //holds a cumulative list of all of the player scores
var tempString = localStorage.getItem("cumulativescores");
var allScores = tempString.split(",") ? tempString.split(",") :"0,0";
average = allScores.reduce(function(a, b){a= parseFloat(a);b= parseFloat(b); return a+b;})
// for (var i = 0; i < allScores.length; i++){
average = Math.round(average/allScores.length);
document.getElementById("average").innerHTML = (average);
}
function average (data) {
var sum = data.reduce(function(sum, value){
return sum + value;
}, 0);
var avg = sum / data.length;
return avg;
}
function contactNameInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[0].split("=")[1];
nameTwo = chopped[1].split("=")[1];
var re = new RegExp("\s*([A-Za-z\d]+)\s*");
nameOne = re.exec(nameOne)[0];
nameTwo = re.exec(nameTwo)[0];
P1NAME = nameOne;
P2NAME = nameTwo;
coupleName = this.nameMash (nameOne, nameTwo);
COMBONAME = coupleName;
document.getElementById("player-1").innerHTML = (nameOne + "'s Score is:");
document.getElementById("player-2").innerHTML = (nameTwo + "'s Score is:");
document.getElementById("couple-name").innerHTML = ("Couple Name: " + coupleName);
}
function contactEmailInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
var atRegex = /%40/g;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[2].split("=")[1];
nameTwo = chopped[3].split("=")[1];
P1EMAIL = nameOne.replace(atRegex, '@');
P2EMAIL = nameTwo.replace(atRegex,'@');
document.getElementById("email-message").innerHTML = ("Thanks! We will be getting back to you sometime before the next burn!");
}
function datesTimes () {//grabs the time... no network or persistant time... Need a GPS module for the Raspberry PI
var cleanDate;
cleanDate = new Date().toLocaleString()
localStorage.setItem("timestamp", cleanDate);
}
function dataLoader(){//pulls the data from a local JSON file
$.getJSON("http://localhost:8000/Love-Staring-Machine/result.json", function(data) {
VALUE1 = data["player1"];
VALUE2 = data["player2"];
});
}
function finalMessage () {//Delivers the final message in the form of a modal overlay based on compadability of scores
//derive a compatability index based on distance of final scores
var p1Score = SCORE[0];
var p2Score = SCORE[1];
var higherScore = p1Score > p2Score ? p1Score : p2Score;
var distance = Math.abs(p1Score - p2Score);
var relDistance = distance / higherScore;
var message = [
"Hell No!!!",
"Y'all Fuck",
"True Love!"
];
var messenger;
if (relDistance > .1) {
messenger = 0;
}
else if (relDistance > .05) {
messenger = 1;
}
else {
messenger = 2;
}
//render the modal overlay
document.getElementById("timer-readout").innerHTML = (message[messenger]);
}
function finalData () {
//Stpres all he data as an object
var finalObject = {};
var totalFinalObjects = JSON.parse(localStorage.getItem("finalobjects"));
var participants = localStorage.getItem("totalparticipants");
var p1Name = P1NAME ? P1NAME : null;
p2Name = P2NAME ? P2NAME : null;
var coupleName = COMBONAME ? COMBONAME : null;
p1Email = P1EMAIL ? P1EMAIL : null;
p2Email = P2EMAIL ? P2EMAIL : null;
//grabs from localstorage the entire
totalFinalObjects[participants] = {
'p1': {
'n': p1Name,
'e': p1Email,
'p': SCORE[0],
's': p1data
},
'p2' : {
'n': p2Name,
'e': p1Email,
'p': SCORE[1],
's': p2data
},
'n': COMBONAME
};
localStorage.setItem("finalobjects", JSON.stringify(totalFinalObjects));
}
function highScore () {//checks if any of the present SCOREs are higher than the all time high SCORE
var tempSCORE = parseInt(localStorage.getItem("highScore"));
if (SCORE[0] > tempSCORE) {
localStorage.setItem("highScore", SCORE[0]);
}
if (SCORE[1] > tempSCORE) {
localStorage.setItem("highScore", SCORE[1]);
}
}
function initialization () {//initializes the persistant dashboard metrics for the first time
//add all of the local storage variables
//localStorage.setItem("highScore", 0);
//localStorage.setItem("totalparticipants", 0);
//localStorage.setItem("average", 0);
//localStorage.setItem("cumulativescores", 0)
localStorage.setItem("finalobjects", "{}");
}
function myTimer() {//Simple, non-accurate clock funtion
var secs = "" + SECONDS;
var min = MINUTES;
if ( MINUTES >= 0){
SECONDS --;
if (SECONDS < 9) {
secs = "0" + secs;
}
if (SECONDS === 0){
SECONDS = 59;
secs = "00";//TODO: fix this where the at 1:00 it displays :00
MINUTES --;
}
if (MINUTES > 0){
document.getElementById("timer-readout").innerHTML = (min + ":" + secs);
}
else {
document.getElementById("timer-readout").innerHTML = (":" + secs);
}
}
else {
makePointsFlag = false;
storeScoresForAverages();
finalMessage();
finalData();
clearTimeout(loop);
clearTimeout(slice);
clearTimeout(countdown);
clearTimeout(points);
clearTimeout(leader);
}
}
function nameMash (p1,p2) {//celebrity name generator splits on the vowels or if all else fails just smash them together
if (p1.length > 5 || p2.length > 5) {//TODO: Clean up this logic and make it more compact
//use the p1 and p2 arguments and loop through to grab the regex vowels
var re = /[aeiou]/gi;
var p1Array = p1.match(re);
var p2Array = p2.match(re);
//if there are more than 2 split on the second
if (p1Array.length >= 2 && p2Array.length >= 2) {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == p1Array.length){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == p2Array.length){
var player2 = p2.substring(match.index - 2, p2.length);
}
}
return player1 + player2;
}
else {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == 1){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == 1){
var player2 = p2.substring(match.index - 1, p2.length);
}
}
return player1 + player2;
}
}
else {
if (p1.length > 2 && p2.length > 2){
return p1.substring(0,1).toUpperCase() + p1.substring(1,Math.floor(p1.length/2)).toLowerCase() + p2.substring(Math.floor(p2.length/2),p2.length).toLowerCase();
}
else {
return p1.substring(0,1).toUpperCase() + p1.substring(1, p1.length).toLowerCase() + p2.substring(2,p2.length).toLowerCase();
}
}
}
function onRefreshInitialization () {//initializes the persistant dashboard metrics
document.getElementById('p1').focus();
$('#form')[0].reset();
}
function overlay() {
el = document.getElementById("overlay");
el.style.visibility = (el.style.visibility == "visible") ? "hidden" : "visible";
}
function pointGenerator () {//this function computes the points
//TODO: Make a funtion to check directional trends and integrate the result into this function
if (makePointsFlag) {
var trendValue1,
trendValue2;
trendOfReadings();
if (p1trend === '0'){
trendValue1 = 9;
}
else if (p1trend === '+'){
trendValue1 = 30;
}
else if (p1trend === '-'){
trendValue1 = 5;
}
else {
trendValue1 = 1;
}
if (p2trend === '0'){
trendValue2 = 9;
}
else if (p2trend === '+'){
trendValue2 = 30;
}
else if (p2trend === '-') |
else {
trendValue2 = 1;
}
trendValue1 ? SCORE[0] += Math.round(trendValue1) : null;
trendValue2 ? SCORE[1] += Math.round(trendValue2) : null;
scoreRender();
}
}
function scoreRender () {
document.getElementById("player-1-score").innerHTML = SCORE[0] ? SCORE[0] : "Loading...";
document.getElementById("player-2-score").innerHTML = SCORE[1] ? SCORE[1] : "Loading...";
//sets the high scoreRender
document.getElementById("high-score").innerHTML = (localStorage.getItem("highScore"));
}
function standardDeviation(values){
var avg = average(values);
var squareDiffs = values.map(function(value){
var diff = value - avg;
var sqrDiff = diff * diff;
return sqrDiff;
});
var avgSquareDiff = average(squareDiffs);
var stdDev = Math.sqrt(avgSquareDiff);
return stdDev;
}
function storeScoresForAverages() {
var tempArray = [];
tempArray.push(localStorage.getItem("cumulativescores"));
tempArray.push(SCORE[0]);
tempArray.push(SCORE[1]);
localStorage.setItem("cumulativescores", tempArray);
}
function timeSlice () {
p1data[sliceCount] = VALUE1;
p2data[sliceCount] = VALUE2;
sliceCount ++;
//Store 240 time slices (one per second) for both players
multiplierA = standardDeviation(p1data);
multiplierB = standardDeviation(p2data);
//this data is used for modeling the results
//creates a baseline to determine if disconnet has occured
//writes the list of time slices into localstorage
localStorage.setItem("player1slices", p1data);
localStorage.setItem("player2slices", p2data);
}
function totalParticipants () {//keeps a rolling total on how many times the test has been ran
var newTotal = parseInt(localStorage.getItem("totalparticipants")) + 1;
document.getElementById("participant-total").innerHTML = (newTotal);
localStorage.setItem("totalparticipants", newTotal);
}
function totalPoints () {//create a rolling total
var newTotal;
localStorage.setItem("averagepoints", rollingAverage);
localStorage.setItem("totalparticipants", newTotal);
}
function trendOfReadings () {//Takes in the last n readings and makes comparison to determine directional trending
var driftDebounce = 0; //tune based off of how much it wobbles
if (sliceCount > 5){//slice count is always ahead by one
//simple and needs refactoring
//TODO: take the last five averages and do a simple comparison for smoothing
if (p1data[sliceCount - 1] > p1data[sliceCount - 2] && p1data[sliceCount - 2] > p1data[sliceCount - 3]){
p1trend = "+";
}
else if (p1data[sliceCount - 1] < p1data[sliceCount - 2] && p1data[sliceCount - 2] < p1data[sliceCount - 3]){
p1trend = "-";
}
else {
p1trend = "0";
}
if (p2data[sliceCount - 1] > p2data[sliceCount - 2] && p2data[sliceCount - 2] > p2data[sliceCount - 3]){
p2trend = "+";
}
else if (p2data[sliceCount - 1] < p2data[sliceCount - 2] && p2data[sliceCount - 2] < p2data[sliceCount - 3]){
p2trend = "-";
}
else {
p2trend = "0";
}
}
}
///////////////////////////////////////////////////////////////////////////////
function render() {//keep all of the execution of the app within this function
//initialization();
onRefreshInitialization();
aggregateAverage();
storeScoresForAverages();
totalParticipants();
datesTimes();
pointGenerator();
dataLoader();
loop = setInterval(dataLoader, 1000);
slice = setInterval(timeSlice, 1000);
countdown = setInterval(myTimer,1000);
points = setInterval(pointGenerator, 633);
leader = setInterval(highScore,1000);
//TODO: store everything in local storage better for extraction at a later date
}
$(document).ready(function() {
render();
});
| {
trendValue2 = 5;
} | conditional_block |
app.js | var SECONDS = 59;
var MINUTES = 3;
var SCORE = [0,0];
var VALUE1;
var VALUE2;
var sliceCount = 0;
var p1data = [];
var p2data = [];
var p1trend = "0";
var p2trend = "0";
var multiplierA;
var multiplierB;
var makePointsFlag = true;
var P1NAME;
var P2NAME;
var P1EMAIL;
var P2EMAIL;
var COMBONAME = null;
function add(a, b) {
return a + b;
}
function aggregateAverage () {//calculates the average SCORE of all players
var average = 0; //holds a cumulative list of all of the player scores
var tempString = localStorage.getItem("cumulativescores");
var allScores = tempString.split(",") ? tempString.split(",") :"0,0";
average = allScores.reduce(function(a, b){a= parseFloat(a);b= parseFloat(b); return a+b;})
// for (var i = 0; i < allScores.length; i++){
average = Math.round(average/allScores.length);
document.getElementById("average").innerHTML = (average);
}
function average (data) {
var sum = data.reduce(function(sum, value){
return sum + value;
}, 0);
var avg = sum / data.length;
return avg;
}
function contactNameInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[0].split("=")[1];
nameTwo = chopped[1].split("=")[1];
var re = new RegExp("\s*([A-Za-z\d]+)\s*");
nameOne = re.exec(nameOne)[0];
nameTwo = re.exec(nameTwo)[0];
P1NAME = nameOne;
P2NAME = nameTwo;
coupleName = this.nameMash (nameOne, nameTwo);
COMBONAME = coupleName;
document.getElementById("player-1").innerHTML = (nameOne + "'s Score is:");
document.getElementById("player-2").innerHTML = (nameTwo + "'s Score is:");
document.getElementById("couple-name").innerHTML = ("Couple Name: " + coupleName);
}
function contactEmailInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
var atRegex = /%40/g;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[2].split("=")[1];
nameTwo = chopped[3].split("=")[1];
P1EMAIL = nameOne.replace(atRegex, '@');
P2EMAIL = nameTwo.replace(atRegex,'@');
document.getElementById("email-message").innerHTML = ("Thanks! We will be getting back to you sometime before the next burn!");
}
function datesTimes () {//grabs the time... no network or persistant time... Need a GPS module for the Raspberry PI
var cleanDate;
cleanDate = new Date().toLocaleString()
localStorage.setItem("timestamp", cleanDate);
}
function dataLoader(){//pulls the data from a local JSON file
$.getJSON("http://localhost:8000/Love-Staring-Machine/result.json", function(data) {
VALUE1 = data["player1"];
VALUE2 = data["player2"];
});
}
function finalMessage () {//Delivers the final message in the form of a modal overlay based on compadability of scores
//derive a compatability index based on distance of final scores
var p1Score = SCORE[0];
var p2Score = SCORE[1];
var higherScore = p1Score > p2Score ? p1Score : p2Score;
var distance = Math.abs(p1Score - p2Score);
var relDistance = distance / higherScore;
var message = [
"Hell No!!!",
"Y'all Fuck",
"True Love!"
];
var messenger;
if (relDistance > .1) {
messenger = 0;
}
else if (relDistance > .05) {
messenger = 1;
}
else {
messenger = 2;
}
//render the modal overlay
document.getElementById("timer-readout").innerHTML = (message[messenger]);
}
function finalData () {
//Stpres all he data as an object
var finalObject = {};
var totalFinalObjects = JSON.parse(localStorage.getItem("finalobjects"));
var participants = localStorage.getItem("totalparticipants");
var p1Name = P1NAME ? P1NAME : null;
p2Name = P2NAME ? P2NAME : null;
var coupleName = COMBONAME ? COMBONAME : null;
p1Email = P1EMAIL ? P1EMAIL : null;
p2Email = P2EMAIL ? P2EMAIL : null;
//grabs from localstorage the entire
totalFinalObjects[participants] = {
'p1': {
'n': p1Name,
'e': p1Email,
'p': SCORE[0],
's': p1data
},
'p2' : {
'n': p2Name,
'e': p1Email,
'p': SCORE[1],
's': p2data
},
'n': COMBONAME
};
localStorage.setItem("finalobjects", JSON.stringify(totalFinalObjects));
}
function highScore () |
function initialization () {//initializes the persistant dashboard metrics for the first time
//add all of the local storage variables
//localStorage.setItem("highScore", 0);
//localStorage.setItem("totalparticipants", 0);
//localStorage.setItem("average", 0);
//localStorage.setItem("cumulativescores", 0)
localStorage.setItem("finalobjects", "{}");
}
function myTimer() {//Simple, non-accurate clock funtion
var secs = "" + SECONDS;
var min = MINUTES;
if ( MINUTES >= 0){
SECONDS --;
if (SECONDS < 9) {
secs = "0" + secs;
}
if (SECONDS === 0){
SECONDS = 59;
secs = "00";//TODO: fix this where the at 1:00 it displays :00
MINUTES --;
}
if (MINUTES > 0){
document.getElementById("timer-readout").innerHTML = (min + ":" + secs);
}
else {
document.getElementById("timer-readout").innerHTML = (":" + secs);
}
}
else {
makePointsFlag = false;
storeScoresForAverages();
finalMessage();
finalData();
clearTimeout(loop);
clearTimeout(slice);
clearTimeout(countdown);
clearTimeout(points);
clearTimeout(leader);
}
}
function nameMash (p1,p2) {//celebrity name generator splits on the vowels or if all else fails just smash them together
if (p1.length > 5 || p2.length > 5) {//TODO: Clean up this logic and make it more compact
//use the p1 and p2 arguments and loop through to grab the regex vowels
var re = /[aeiou]/gi;
var p1Array = p1.match(re);
var p2Array = p2.match(re);
//if there are more than 2 split on the second
if (p1Array.length >= 2 && p2Array.length >= 2) {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == p1Array.length){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == p2Array.length){
var player2 = p2.substring(match.index - 2, p2.length);
}
}
return player1 + player2;
}
else {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == 1){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == 1){
var player2 = p2.substring(match.index - 1, p2.length);
}
}
return player1 + player2;
}
}
else {
if (p1.length > 2 && p2.length > 2){
return p1.substring(0,1).toUpperCase() + p1.substring(1,Math.floor(p1.length/2)).toLowerCase() + p2.substring(Math.floor(p2.length/2),p2.length).toLowerCase();
}
else {
return p1.substring(0,1).toUpperCase() + p1.substring(1, p1.length).toLowerCase() + p2.substring(2,p2.length).toLowerCase();
}
}
}
function onRefreshInitialization () {//initializes the persistant dashboard metrics
document.getElementById('p1').focus();
$('#form')[0].reset();
}
function overlay() {
el = document.getElementById("overlay");
el.style.visibility = (el.style.visibility == "visible") ? "hidden" : "visible";
}
function pointGenerator () {//this function computes the points
//TODO: Make a funtion to check directional trends and integrate the result into this function
if (makePointsFlag) {
var trendValue1,
trendValue2;
trendOfReadings();
if (p1trend === '0'){
trendValue1 = 9;
}
else if (p1trend === '+'){
trendValue1 = 30;
}
else if (p1trend === '-'){
trendValue1 = 5;
}
else {
trendValue1 = 1;
}
if (p2trend === '0'){
trendValue2 = 9;
}
else if (p2trend === '+'){
trendValue2 = 30;
}
else if (p2trend === '-'){
trendValue2 = 5;
}
else {
trendValue2 = 1;
}
trendValue1 ? SCORE[0] += Math.round(trendValue1) : null;
trendValue2 ? SCORE[1] += Math.round(trendValue2) : null;
scoreRender();
}
}
function scoreRender () {
document.getElementById("player-1-score").innerHTML = SCORE[0] ? SCORE[0] : "Loading...";
document.getElementById("player-2-score").innerHTML = SCORE[1] ? SCORE[1] : "Loading...";
//sets the high scoreRender
document.getElementById("high-score").innerHTML = (localStorage.getItem("highScore"));
}
function standardDeviation(values){
var avg = average(values);
var squareDiffs = values.map(function(value){
var diff = value - avg;
var sqrDiff = diff * diff;
return sqrDiff;
});
var avgSquareDiff = average(squareDiffs);
var stdDev = Math.sqrt(avgSquareDiff);
return stdDev;
}
function storeScoresForAverages() {
var tempArray = [];
tempArray.push(localStorage.getItem("cumulativescores"));
tempArray.push(SCORE[0]);
tempArray.push(SCORE[1]);
localStorage.setItem("cumulativescores", tempArray);
}
function timeSlice () {
p1data[sliceCount] = VALUE1;
p2data[sliceCount] = VALUE2;
sliceCount ++;
//Store 240 time slices (one per second) for both players
multiplierA = standardDeviation(p1data);
multiplierB = standardDeviation(p2data);
//this data is used for modeling the results
//creates a baseline to determine if disconnet has occured
//writes the list of time slices into localstorage
localStorage.setItem("player1slices", p1data);
localStorage.setItem("player2slices", p2data);
}
function totalParticipants () {//keeps a rolling total on how many times the test has been ran
var newTotal = parseInt(localStorage.getItem("totalparticipants")) + 1;
document.getElementById("participant-total").innerHTML = (newTotal);
localStorage.setItem("totalparticipants", newTotal);
}
function totalPoints () {//create a rolling total
var newTotal;
localStorage.setItem("averagepoints", rollingAverage);
localStorage.setItem("totalparticipants", newTotal);
}
function trendOfReadings () {//Takes in the last n readings and makes comparison to determine directional trending
var driftDebounce = 0; //tune based off of how much it wobbles
if (sliceCount > 5){//slice count is always ahead by one
//simple and needs refactoring
//TODO: take the last five averages and do a simple comparison for smoothing
if (p1data[sliceCount - 1] > p1data[sliceCount - 2] && p1data[sliceCount - 2] > p1data[sliceCount - 3]){
p1trend = "+";
}
else if (p1data[sliceCount - 1] < p1data[sliceCount - 2] && p1data[sliceCount - 2] < p1data[sliceCount - 3]){
p1trend = "-";
}
else {
p1trend = "0";
}
if (p2data[sliceCount - 1] > p2data[sliceCount - 2] && p2data[sliceCount - 2] > p2data[sliceCount - 3]){
p2trend = "+";
}
else if (p2data[sliceCount - 1] < p2data[sliceCount - 2] && p2data[sliceCount - 2] < p2data[sliceCount - 3]){
p2trend = "-";
}
else {
p2trend = "0";
}
}
}
///////////////////////////////////////////////////////////////////////////////
function render() {//keep all of the execution of the app within this function
//initialization();
onRefreshInitialization();
aggregateAverage();
storeScoresForAverages();
totalParticipants();
datesTimes();
pointGenerator();
dataLoader();
loop = setInterval(dataLoader, 1000);
slice = setInterval(timeSlice, 1000);
countdown = setInterval(myTimer,1000);
points = setInterval(pointGenerator, 633);
leader = setInterval(highScore,1000);
//TODO: store everything in local storage better for extraction at a later date
}
$(document).ready(function() {
render();
});
| {//checks if any of the present SCOREs are higher than the all time high SCORE
var tempSCORE = parseInt(localStorage.getItem("highScore"));
if (SCORE[0] > tempSCORE) {
localStorage.setItem("highScore", SCORE[0]);
}
if (SCORE[1] > tempSCORE) {
localStorage.setItem("highScore", SCORE[1]);
}
} | identifier_body |
app.js | var SECONDS = 59;
var MINUTES = 3;
var SCORE = [0,0];
var VALUE1;
var VALUE2;
var sliceCount = 0;
var p1data = [];
var p2data = [];
var p1trend = "0";
var p2trend = "0";
var multiplierA;
var multiplierB;
var makePointsFlag = true;
var P1NAME;
var P2NAME;
var P1EMAIL;
var P2EMAIL;
var COMBONAME = null;
function add(a, b) {
return a + b;
}
function aggregateAverage () {//calculates the average SCORE of all players
var average = 0; //holds a cumulative list of all of the player scores
var tempString = localStorage.getItem("cumulativescores");
var allScores = tempString.split(",") ? tempString.split(",") :"0,0";
average = allScores.reduce(function(a, b){a= parseFloat(a);b= parseFloat(b); return a+b;})
// for (var i = 0; i < allScores.length; i++){
average = Math.round(average/allScores.length);
document.getElementById("average").innerHTML = (average);
}
function average (data) {
var sum = data.reduce(function(sum, value){
return sum + value;
}, 0);
var avg = sum / data.length;
return avg;
}
function contactNameInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[0].split("=")[1];
nameTwo = chopped[1].split("=")[1];
var re = new RegExp("\s*([A-Za-z\d]+)\s*");
nameOne = re.exec(nameOne)[0];
nameTwo = re.exec(nameTwo)[0];
P1NAME = nameOne;
P2NAME = nameTwo;
coupleName = this.nameMash (nameOne, nameTwo);
COMBONAME = coupleName;
document.getElementById("player-1").innerHTML = (nameOne + "'s Score is:");
document.getElementById("player-2").innerHTML = (nameTwo + "'s Score is:");
document.getElementById("couple-name").innerHTML = ("Couple Name: " + coupleName);
}
function contactEmailInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
var atRegex = /%40/g;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[2].split("=")[1];
nameTwo = chopped[3].split("=")[1];
P1EMAIL = nameOne.replace(atRegex, '@');
P2EMAIL = nameTwo.replace(atRegex,'@');
document.getElementById("email-message").innerHTML = ("Thanks! We will be getting back to you sometime before the next burn!");
}
function datesTimes () {//grabs the time... no network or persistant time... Need a GPS module for the Raspberry PI
var cleanDate;
cleanDate = new Date().toLocaleString()
localStorage.setItem("timestamp", cleanDate);
}
function dataLoader(){//pulls the data from a local JSON file
$.getJSON("http://localhost:8000/Love-Staring-Machine/result.json", function(data) {
VALUE1 = data["player1"];
VALUE2 = data["player2"];
});
}
function finalMessage () {//Delivers the final message in the form of a modal overlay based on compadability of scores
//derive a compatability index based on distance of final scores
var p1Score = SCORE[0];
var p2Score = SCORE[1];
var higherScore = p1Score > p2Score ? p1Score : p2Score;
var distance = Math.abs(p1Score - p2Score);
var relDistance = distance / higherScore;
var message = [
"Hell No!!!",
"Y'all Fuck",
"True Love!"
];
var messenger;
if (relDistance > .1) {
messenger = 0;
}
else if (relDistance > .05) {
messenger = 1;
}
else {
messenger = 2;
}
//render the modal overlay
document.getElementById("timer-readout").innerHTML = (message[messenger]);
}
function finalData () {
//Stpres all he data as an object
var finalObject = {};
var totalFinalObjects = JSON.parse(localStorage.getItem("finalobjects"));
var participants = localStorage.getItem("totalparticipants");
var p1Name = P1NAME ? P1NAME : null;
p2Name = P2NAME ? P2NAME : null;
var coupleName = COMBONAME ? COMBONAME : null;
p1Email = P1EMAIL ? P1EMAIL : null;
p2Email = P2EMAIL ? P2EMAIL : null;
//grabs from localstorage the entire
totalFinalObjects[participants] = {
'p1': {
'n': p1Name,
'e': p1Email,
'p': SCORE[0],
's': p1data
},
'p2' : {
'n': p2Name,
'e': p1Email,
'p': SCORE[1],
's': p2data
},
'n': COMBONAME
|
function highScore () {//checks if any of the present SCOREs are higher than the all time high SCORE
var tempSCORE = parseInt(localStorage.getItem("highScore"));
if (SCORE[0] > tempSCORE) {
localStorage.setItem("highScore", SCORE[0]);
}
if (SCORE[1] > tempSCORE) {
localStorage.setItem("highScore", SCORE[1]);
}
}
function initialization () {//initializes the persistant dashboard metrics for the first time
//add all of the local storage variables
//localStorage.setItem("highScore", 0);
//localStorage.setItem("totalparticipants", 0);
//localStorage.setItem("average", 0);
//localStorage.setItem("cumulativescores", 0)
localStorage.setItem("finalobjects", "{}");
}
function myTimer() {//Simple, non-accurate clock funtion
var secs = "" + SECONDS;
var min = MINUTES;
if ( MINUTES >= 0){
SECONDS --;
if (SECONDS < 9) {
secs = "0" + secs;
}
if (SECONDS === 0){
SECONDS = 59;
secs = "00";//TODO: fix this where the at 1:00 it displays :00
MINUTES --;
}
if (MINUTES > 0){
document.getElementById("timer-readout").innerHTML = (min + ":" + secs);
}
else {
document.getElementById("timer-readout").innerHTML = (":" + secs);
}
}
else {
makePointsFlag = false;
storeScoresForAverages();
finalMessage();
finalData();
clearTimeout(loop);
clearTimeout(slice);
clearTimeout(countdown);
clearTimeout(points);
clearTimeout(leader);
}
}
function nameMash (p1,p2) {//celebrity name generator splits on the vowels or if all else fails just smash them together
if (p1.length > 5 || p2.length > 5) {//TODO: Clean up this logic and make it more compact
//use the p1 and p2 arguments and loop through to grab the regex vowels
var re = /[aeiou]/gi;
var p1Array = p1.match(re);
var p2Array = p2.match(re);
//if there are more than 2 split on the second
if (p1Array.length >= 2 && p2Array.length >= 2) {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == p1Array.length){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == p2Array.length){
var player2 = p2.substring(match.index - 2, p2.length);
}
}
return player1 + player2;
}
else {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == 1){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == 1){
var player2 = p2.substring(match.index - 1, p2.length);
}
}
return player1 + player2;
}
}
else {
if (p1.length > 2 && p2.length > 2){
return p1.substring(0,1).toUpperCase() + p1.substring(1,Math.floor(p1.length/2)).toLowerCase() + p2.substring(Math.floor(p2.length/2),p2.length).toLowerCase();
}
else {
return p1.substring(0,1).toUpperCase() + p1.substring(1, p1.length).toLowerCase() + p2.substring(2,p2.length).toLowerCase();
}
}
}
function onRefreshInitialization () {//initializes the persistant dashboard metrics
document.getElementById('p1').focus();
$('#form')[0].reset();
}
function overlay() {
el = document.getElementById("overlay");
el.style.visibility = (el.style.visibility == "visible") ? "hidden" : "visible";
}
function pointGenerator () {//this function computes the points
//TODO: Make a funtion to check directional trends and integrate the result into this function
if (makePointsFlag) {
var trendValue1,
trendValue2;
trendOfReadings();
if (p1trend === '0'){
trendValue1 = 9;
}
else if (p1trend === '+'){
trendValue1 = 30;
}
else if (p1trend === '-'){
trendValue1 = 5;
}
else {
trendValue1 = 1;
}
if (p2trend === '0'){
trendValue2 = 9;
}
else if (p2trend === '+'){
trendValue2 = 30;
}
else if (p2trend === '-'){
trendValue2 = 5;
}
else {
trendValue2 = 1;
}
trendValue1 ? SCORE[0] += Math.round(trendValue1) : null;
trendValue2 ? SCORE[1] += Math.round(trendValue2) : null;
scoreRender();
}
}
function scoreRender () {
document.getElementById("player-1-score").innerHTML = SCORE[0] ? SCORE[0] : "Loading...";
document.getElementById("player-2-score").innerHTML = SCORE[1] ? SCORE[1] : "Loading...";
//sets the high scoreRender
document.getElementById("high-score").innerHTML = (localStorage.getItem("highScore"));
}
function standardDeviation(values){
var avg = average(values);
var squareDiffs = values.map(function(value){
var diff = value - avg;
var sqrDiff = diff * diff;
return sqrDiff;
});
var avgSquareDiff = average(squareDiffs);
var stdDev = Math.sqrt(avgSquareDiff);
return stdDev;
}
function storeScoresForAverages() {
var tempArray = [];
tempArray.push(localStorage.getItem("cumulativescores"));
tempArray.push(SCORE[0]);
tempArray.push(SCORE[1]);
localStorage.setItem("cumulativescores", tempArray);
}
function timeSlice () {
p1data[sliceCount] = VALUE1;
p2data[sliceCount] = VALUE2;
sliceCount ++;
//Store 240 time slices (one per second) for both players
multiplierA = standardDeviation(p1data);
multiplierB = standardDeviation(p2data);
//this data is used for modeling the results
//creates a baseline to determine if disconnet has occured
//writes the list of time slices into localstorage
localStorage.setItem("player1slices", p1data);
localStorage.setItem("player2slices", p2data);
}
function totalParticipants () {//keeps a rolling total on how many times the test has been ran
var newTotal = parseInt(localStorage.getItem("totalparticipants")) + 1;
document.getElementById("participant-total").innerHTML = (newTotal);
localStorage.setItem("totalparticipants", newTotal);
}
function totalPoints () {//create a rolling total
var newTotal;
localStorage.setItem("averagepoints", rollingAverage);
localStorage.setItem("totalparticipants", newTotal);
}
function trendOfReadings () {//Takes in the last n readings and makes comparison to determine directional trending
var driftDebounce = 0; //tune based off of how much it wobbles
if (sliceCount > 5){//slice count is always ahead by one
//simple and needs refactoring
//TODO: take the last five averages and do a simple comparison for smoothing
if (p1data[sliceCount - 1] > p1data[sliceCount - 2] && p1data[sliceCount - 2] > p1data[sliceCount - 3]){
p1trend = "+";
}
else if (p1data[sliceCount - 1] < p1data[sliceCount - 2] && p1data[sliceCount - 2] < p1data[sliceCount - 3]){
p1trend = "-";
}
else {
p1trend = "0";
}
if (p2data[sliceCount - 1] > p2data[sliceCount - 2] && p2data[sliceCount - 2] > p2data[sliceCount - 3]){
p2trend = "+";
}
else if (p2data[sliceCount - 1] < p2data[sliceCount - 2] && p2data[sliceCount - 2] < p2data[sliceCount - 3]){
p2trend = "-";
}
else {
p2trend = "0";
}
}
}
///////////////////////////////////////////////////////////////////////////////
function render() {//keep all of the execution of the app within this function
//initialization();
onRefreshInitialization();
aggregateAverage();
storeScoresForAverages();
totalParticipants();
datesTimes();
pointGenerator();
dataLoader();
loop = setInterval(dataLoader, 1000);
slice = setInterval(timeSlice, 1000);
countdown = setInterval(myTimer,1000);
points = setInterval(pointGenerator, 633);
leader = setInterval(highScore,1000);
//TODO: store everything in local storage better for extraction at a later date
}
$(document).ready(function() {
render();
}); | };
localStorage.setItem("finalobjects", JSON.stringify(totalFinalObjects));
} | random_line_split |
app.js | var SECONDS = 59;
var MINUTES = 3;
var SCORE = [0,0];
var VALUE1;
var VALUE2;
var sliceCount = 0;
var p1data = [];
var p2data = [];
var p1trend = "0";
var p2trend = "0";
var multiplierA;
var multiplierB;
var makePointsFlag = true;
var P1NAME;
var P2NAME;
var P1EMAIL;
var P2EMAIL;
var COMBONAME = null;
function add(a, b) {
return a + b;
}
function aggregateAverage () {//calculates the average SCORE of all players
var average = 0; //holds a cumulative list of all of the player scores
var tempString = localStorage.getItem("cumulativescores");
var allScores = tempString.split(",") ? tempString.split(",") :"0,0";
average = allScores.reduce(function(a, b){a= parseFloat(a);b= parseFloat(b); return a+b;})
// for (var i = 0; i < allScores.length; i++){
average = Math.round(average/allScores.length);
document.getElementById("average").innerHTML = (average);
}
function average (data) {
var sum = data.reduce(function(sum, value){
return sum + value;
}, 0);
var avg = sum / data.length;
return avg;
}
function contactNameInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[0].split("=")[1];
nameTwo = chopped[1].split("=")[1];
var re = new RegExp("\s*([A-Za-z\d]+)\s*");
nameOne = re.exec(nameOne)[0];
nameTwo = re.exec(nameTwo)[0];
P1NAME = nameOne;
P2NAME = nameTwo;
coupleName = this.nameMash (nameOne, nameTwo);
COMBONAME = coupleName;
document.getElementById("player-1").innerHTML = (nameOne + "'s Score is:");
document.getElementById("player-2").innerHTML = (nameTwo + "'s Score is:");
document.getElementById("couple-name").innerHTML = ("Couple Name: " + coupleName);
}
function contactEmailInfo () { //grabs the contact details and transforms them into a combination name and stores everything to local storage
var coupleName, name, email;
var atRegex = /%40/g;
nameTemp = $('#form').serialize();
chopped = nameTemp.split("&");
nameOne = chopped[2].split("=")[1];
nameTwo = chopped[3].split("=")[1];
P1EMAIL = nameOne.replace(atRegex, '@');
P2EMAIL = nameTwo.replace(atRegex,'@');
document.getElementById("email-message").innerHTML = ("Thanks! We will be getting back to you sometime before the next burn!");
}
function datesTimes () {//grabs the time... no network or persistant time... Need a GPS module for the Raspberry PI
var cleanDate;
cleanDate = new Date().toLocaleString()
localStorage.setItem("timestamp", cleanDate);
}
function dataLoader(){//pulls the data from a local JSON file
$.getJSON("http://localhost:8000/Love-Staring-Machine/result.json", function(data) {
VALUE1 = data["player1"];
VALUE2 = data["player2"];
});
}
function finalMessage () {//Delivers the final message in the form of a modal overlay based on compadability of scores
//derive a compatability index based on distance of final scores
var p1Score = SCORE[0];
var p2Score = SCORE[1];
var higherScore = p1Score > p2Score ? p1Score : p2Score;
var distance = Math.abs(p1Score - p2Score);
var relDistance = distance / higherScore;
var message = [
"Hell No!!!",
"Y'all Fuck",
"True Love!"
];
var messenger;
if (relDistance > .1) {
messenger = 0;
}
else if (relDistance > .05) {
messenger = 1;
}
else {
messenger = 2;
}
//render the modal overlay
document.getElementById("timer-readout").innerHTML = (message[messenger]);
}
function finalData () {
//Stpres all he data as an object
var finalObject = {};
var totalFinalObjects = JSON.parse(localStorage.getItem("finalobjects"));
var participants = localStorage.getItem("totalparticipants");
var p1Name = P1NAME ? P1NAME : null;
p2Name = P2NAME ? P2NAME : null;
var coupleName = COMBONAME ? COMBONAME : null;
p1Email = P1EMAIL ? P1EMAIL : null;
p2Email = P2EMAIL ? P2EMAIL : null;
//grabs from localstorage the entire
totalFinalObjects[participants] = {
'p1': {
'n': p1Name,
'e': p1Email,
'p': SCORE[0],
's': p1data
},
'p2' : {
'n': p2Name,
'e': p1Email,
'p': SCORE[1],
's': p2data
},
'n': COMBONAME
};
localStorage.setItem("finalobjects", JSON.stringify(totalFinalObjects));
}
function highScore () {//checks if any of the present SCOREs are higher than the all time high SCORE
var tempSCORE = parseInt(localStorage.getItem("highScore"));
if (SCORE[0] > tempSCORE) {
localStorage.setItem("highScore", SCORE[0]);
}
if (SCORE[1] > tempSCORE) {
localStorage.setItem("highScore", SCORE[1]);
}
}
function initialization () {//initializes the persistant dashboard metrics for the first time
//add all of the local storage variables
//localStorage.setItem("highScore", 0);
//localStorage.setItem("totalparticipants", 0);
//localStorage.setItem("average", 0);
//localStorage.setItem("cumulativescores", 0)
localStorage.setItem("finalobjects", "{}");
}
function myTimer() {//Simple, non-accurate clock funtion
var secs = "" + SECONDS;
var min = MINUTES;
if ( MINUTES >= 0){
SECONDS --;
if (SECONDS < 9) {
secs = "0" + secs;
}
if (SECONDS === 0){
SECONDS = 59;
secs = "00";//TODO: fix this where the at 1:00 it displays :00
MINUTES --;
}
if (MINUTES > 0){
document.getElementById("timer-readout").innerHTML = (min + ":" + secs);
}
else {
document.getElementById("timer-readout").innerHTML = (":" + secs);
}
}
else {
makePointsFlag = false;
storeScoresForAverages();
finalMessage();
finalData();
clearTimeout(loop);
clearTimeout(slice);
clearTimeout(countdown);
clearTimeout(points);
clearTimeout(leader);
}
}
function nameMash (p1,p2) {//celebrity name generator splits on the vowels or if all else fails just smash them together
if (p1.length > 5 || p2.length > 5) {//TODO: Clean up this logic and make it more compact
//use the p1 and p2 arguments and loop through to grab the regex vowels
var re = /[aeiou]/gi;
var p1Array = p1.match(re);
var p2Array = p2.match(re);
//if there are more than 2 split on the second
if (p1Array.length >= 2 && p2Array.length >= 2) {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == p1Array.length){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == p2Array.length){
var player2 = p2.substring(match.index - 2, p2.length);
}
}
return player1 + player2;
}
else {
var i = 0
while ((match = re.exec(p1)) != null) {
i ++;
if (i == 1){
var player1 = p1.substring(0,match.index + 1);
}
}
var z = 0
while ((match = re.exec(p2)) != null) {
z ++;
if (z == 1){
var player2 = p2.substring(match.index - 1, p2.length);
}
}
return player1 + player2;
}
}
else {
if (p1.length > 2 && p2.length > 2){
return p1.substring(0,1).toUpperCase() + p1.substring(1,Math.floor(p1.length/2)).toLowerCase() + p2.substring(Math.floor(p2.length/2),p2.length).toLowerCase();
}
else {
return p1.substring(0,1).toUpperCase() + p1.substring(1, p1.length).toLowerCase() + p2.substring(2,p2.length).toLowerCase();
}
}
}
function onRefreshInitialization () {//initializes the persistant dashboard metrics
document.getElementById('p1').focus();
$('#form')[0].reset();
}
function | () {
el = document.getElementById("overlay");
el.style.visibility = (el.style.visibility == "visible") ? "hidden" : "visible";
}
function pointGenerator () {//this function computes the points
//TODO: Make a funtion to check directional trends and integrate the result into this function
if (makePointsFlag) {
var trendValue1,
trendValue2;
trendOfReadings();
if (p1trend === '0'){
trendValue1 = 9;
}
else if (p1trend === '+'){
trendValue1 = 30;
}
else if (p1trend === '-'){
trendValue1 = 5;
}
else {
trendValue1 = 1;
}
if (p2trend === '0'){
trendValue2 = 9;
}
else if (p2trend === '+'){
trendValue2 = 30;
}
else if (p2trend === '-'){
trendValue2 = 5;
}
else {
trendValue2 = 1;
}
trendValue1 ? SCORE[0] += Math.round(trendValue1) : null;
trendValue2 ? SCORE[1] += Math.round(trendValue2) : null;
scoreRender();
}
}
function scoreRender () {
document.getElementById("player-1-score").innerHTML = SCORE[0] ? SCORE[0] : "Loading...";
document.getElementById("player-2-score").innerHTML = SCORE[1] ? SCORE[1] : "Loading...";
//sets the high scoreRender
document.getElementById("high-score").innerHTML = (localStorage.getItem("highScore"));
}
function standardDeviation(values){
var avg = average(values);
var squareDiffs = values.map(function(value){
var diff = value - avg;
var sqrDiff = diff * diff;
return sqrDiff;
});
var avgSquareDiff = average(squareDiffs);
var stdDev = Math.sqrt(avgSquareDiff);
return stdDev;
}
function storeScoresForAverages() {
var tempArray = [];
tempArray.push(localStorage.getItem("cumulativescores"));
tempArray.push(SCORE[0]);
tempArray.push(SCORE[1]);
localStorage.setItem("cumulativescores", tempArray);
}
function timeSlice () {
p1data[sliceCount] = VALUE1;
p2data[sliceCount] = VALUE2;
sliceCount ++;
//Store 240 time slices (one per second) for both players
multiplierA = standardDeviation(p1data);
multiplierB = standardDeviation(p2data);
//this data is used for modeling the results
//creates a baseline to determine if disconnet has occured
//writes the list of time slices into localstorage
localStorage.setItem("player1slices", p1data);
localStorage.setItem("player2slices", p2data);
}
function totalParticipants () {//keeps a rolling total on how many times the test has been ran
var newTotal = parseInt(localStorage.getItem("totalparticipants")) + 1;
document.getElementById("participant-total").innerHTML = (newTotal);
localStorage.setItem("totalparticipants", newTotal);
}
function totalPoints () {//create a rolling total
var newTotal;
localStorage.setItem("averagepoints", rollingAverage);
localStorage.setItem("totalparticipants", newTotal);
}
function trendOfReadings () {//Takes in the last n readings and makes comparison to determine directional trending
var driftDebounce = 0; //tune based off of how much it wobbles
if (sliceCount > 5){//slice count is always ahead by one
//simple and needs refactoring
//TODO: take the last five averages and do a simple comparison for smoothing
if (p1data[sliceCount - 1] > p1data[sliceCount - 2] && p1data[sliceCount - 2] > p1data[sliceCount - 3]){
p1trend = "+";
}
else if (p1data[sliceCount - 1] < p1data[sliceCount - 2] && p1data[sliceCount - 2] < p1data[sliceCount - 3]){
p1trend = "-";
}
else {
p1trend = "0";
}
if (p2data[sliceCount - 1] > p2data[sliceCount - 2] && p2data[sliceCount - 2] > p2data[sliceCount - 3]){
p2trend = "+";
}
else if (p2data[sliceCount - 1] < p2data[sliceCount - 2] && p2data[sliceCount - 2] < p2data[sliceCount - 3]){
p2trend = "-";
}
else {
p2trend = "0";
}
}
}
///////////////////////////////////////////////////////////////////////////////
function render() {//keep all of the execution of the app within this function
//initialization();
onRefreshInitialization();
aggregateAverage();
storeScoresForAverages();
totalParticipants();
datesTimes();
pointGenerator();
dataLoader();
loop = setInterval(dataLoader, 1000);
slice = setInterval(timeSlice, 1000);
countdown = setInterval(myTimer,1000);
points = setInterval(pointGenerator, 633);
leader = setInterval(highScore,1000);
//TODO: store everything in local storage better for extraction at a later date
}
$(document).ready(function() {
render();
});
| overlay | identifier_name |
XYRepresentation.py | # -*- coding: utf-8 -*-
"""
Created on Mon Nov 5 15:06:34 2018
@author: lawrence
"""
import numpy as np
import random as rd
import matplotlib.pyplot as plt
import matplotlib.path as mplpath
import matplotlib.patches as patches
from matplotlib.collections import PatchCollection
from matplotlib import collections as mc
import shapely.geometry as shapely
from XYaStarInterpreter import interpret
from Astar import find_path
import PRM
import copy
#from descartes.patch import PolygonPatch
class Graph():
def __init__(self,mp):
self.edges=[]
self.vertices=[]
self.mp=mp
def addVertex(self,point):
self.vertices.append(point)
def copy(self):
return copy.deepcopy(self)
def ngd(self, a):
neighbors=[]
distances=[]
for pt in self.vertices:
if pt[0]!=a[0] or pt[1]!=a[1]:
dist=np.sqrt(np.square(pt[0]-a[0])+np.square(pt[1]-a[1]))
if not distances:
distances.append(dist)
neighbors.append(pt)
else:
counter=0
while counter<len(distances) and dist>distances[counter]:
counter+=1
distances.insert(counter,dist)
neighbors.insert(counter,pt)
return neighbors
def can_connect(self,a,q):
return not self.mp.collide(a,q)
def connect(self,a,q):
|
def sample(self):
samp=self.mp.sample()
self.addVertex(samp)
return samp
class Map():
points=[] #PRM points
edges=[] #PRM edges
lines=[]
buff_lines=[]
obstacles=[]
buff=0
vis_graph=None
visibility=False
def __init__(self,lx=0,hx=0,ly=0,hy=0):
self.lx=lx
self.hx=hx
self.ly=ly
self.hy=hy
"""Returns a pt that is collision free"""
def sample(self):
x=None
y=None
while x==None or self.collide((x,y)):
xwidth=self.hx-self.lx
ywidth=self.hy-self.ly
x=xwidth*rd.random()+self.lx
y=ywidth*rd.random()+self.ly
return (x,y)
def collide(self,point1,point2=None):
if point2==None:
point=shapely.Point(point1[0],point1[1])
for obs in self.obstacles:
if point.within(obs[1]) and not point.touches(obs[1]):
return True
else:
path =shapely.LineString([point1,point2])
if self.buff>0:
path=path.buffer(self.buff)
for obs in self.obstacles:
if obs[1].intersects(path) and not path.touches(obs[1]):
return True
return False
def clear(self):
self.lines=[]
self.buff_lines=[]
self.obstacles=[]
"""vertices are of format [(a,b),(c,d)]"""
def add_Poly(self,vertices=[]):
if self.visibility:
init_poly=shapely.Polygon(vertices)
buff_poly=init_poly.buffer(self.buff,cap_style=2,join_style =2)
new_vert=list(buff_poly.exterior.coords)
self.obstacles.append((mplpath.Path(vertices),init_poly,new_vert,mplpath.Path(new_vert),buff_poly))
else:
self.obstacles.append((mplpath.Path(vertices),shapely.Polygon(vertices),vertices))
def display(self):
"""start grid"""
fig, ax = plt.subplots()
"""Add Obstacles"""
if self.buff>0 and self.visibility:
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[3], facecolor='orange',alpha=0.5))
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[0], facecolor='purple'))
"""Set boundaries"""
ax.set_xlim([self.lx,self.hx])
ax.set_ylim([self.ly,self.hy])
"""add edges"""
c=[]
for edge in self.edges:
c.append((1,0,0,0.5))
# vis_lines.append([(edge[0][0],edge[0][1]),(edge[1][0],edge[1][1])])
ax.add_collection(mc.LineCollection(self.edges,colors=c,linewidths = 1.0))
"""Set size of plot"""
fig_size = plt.rcParams["figure.figsize"]
fig_size[0] = 12
fig_size[1] = 9
plt.rcParams["figure.figsize"] = fig_size
"""draw points"""
for pt in self.points:
plt.plot(pt[0],pt[1],marker='o', markersize=5, color="black")
"""draw lines to the plot"""
if not self.visibility and self.buff>0:
path=shapely.LineString(self.buff_lines)
poly=path.buffer(self.buff)
poly_points=list(poly.exterior.coords)
ax.add_patch(patches.PathPatch(mplpath.Path(poly_points), facecolor='yellow',alpha=0.5))
lc = mc.LineCollection(self.lines,linewidths = 2.5)
ax.add_collection(lc)
"""Set up Axis """
ax.minorticks_on()
ax.xaxis.set_major_locator(plt.MultipleLocator(1))
ax.yaxis.set_major_locator(plt.MultipleLocator(1))
ax.xaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.yaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.grid(which='major', linestyle='-', linewidth='0.5', color='black')
ax.grid(which='minor', linestyle='-', linewidth='0.2', color='black')
plt.show()
def average(intlist):
total=0
for val in intlist:
total+=val
if len(intlist)>0:
return total/float(len(intlist))
else:
return -1
def sd(intlist):
avg= average(intlist)
variance=0
for val in intlist:
variance+=np.square(val-avg)
if len(intlist)>0:
variance= variance/float(len(intlist))
return np.sqrt(variance)
else:
return -1
def stats():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-8,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(9,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-7,-5) ,(-7,-4) ])
mp.add_Poly([(7,6), (0,4) ,(-8,7) ,(0,6), (4,8)])
mp.add_Poly([(-9,-9), (8,-5) ,(9,-8)])
starts=[]
goals=[]
for i in range(25):
starts.append(mp.sample())
goals.append(mp.sample())
prmcc_maps=[]
prmk_maps=[]
prmstar_maps=[]
conn=[]
for i in range(10):
g1=Graph(mp)
g2=Graph(mp)
g3=Graph(mp)
conn.append(PRM.prm_cc(g1,25*i+25))
PRM.prm_k(g2,25*i+25,5)
PRM.prm_star(g3,25*i+25)
prmcc_maps.append(g1)
prmk_maps.append(g2)
prmstar_maps.append(g3)
print i
cc_stats=[]
k_stats=[]
star_stats=[]
c=0
for prm_map in prmcc_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_cc(temp,0,starts[i],goals[i],copy.deepcopy(conn[c]))
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
cc_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmk_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_k(temp,0,5,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
k_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmstar_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_star(temp,0,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
star_stats.append(average(raw_dat))
c+=1
print c
print cc_stats
print k_stats
print star_stats
def test():
# mp = Map(-5,5,-5,5)
mp = Map(-7, 8, -7, 8)
start=(-6,7)
goal=(6,-6)
"""Add obstacles"""
# mp.add_Poly([(-1,-1),(-1,1),(1,1),(1,-1)])
mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
# mp.add_Poly([(-2,0),(-2,-1),(2,-1),(2,0)])
graph=Graph(mp)
"""Create graph for PRM"""
# PRM.prm_cc(graph,100,start,goal)
# PRM.prm_k(graph,100,3,start,goal)
PRM.prm_star(graph,5)
"""Add graph and tree to display and print out what it looks"""
mp.points=graph.vertices
mp.edges=graph.edges
mp.display()
"""Run A-Star to find a path"""
# ag=interpret(graph.vertices,graph.edges)
# end = ag.nodes.pop()#end is always last of list
# beg = ag.nodes.pop()#beginning is second to last
# find_path(beg,end)
# iterator = end
#
# """Get line segments to draw a-star path"""
# lines=[]
# while iterator.parent != None:
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
# iterator=iterator.parent
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
#
# """Input all of data to map display and display it"""
# mp.lines=lines
# mp.points=graph.vertices
# mp.edges=graph.edges
# mp.display()
def main():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
g1=Graph(mp)
PRM.prm_star(g1,20)
start=(-6,7)
goal=(6,-6)
PRM.prm_star(g1,0,start,goal)
if __name__ == '__main__':
stats()
| if self.can_connect(a,q):
if (a,q) not in self.edges and (q,a) not in self.edges:
self.edges.append((a,q)) | identifier_body |
XYRepresentation.py | # -*- coding: utf-8 -*-
"""
Created on Mon Nov 5 15:06:34 2018
@author: lawrence
"""
import numpy as np
import random as rd
import matplotlib.pyplot as plt
import matplotlib.path as mplpath
import matplotlib.patches as patches
from matplotlib.collections import PatchCollection
from matplotlib import collections as mc
import shapely.geometry as shapely
from XYaStarInterpreter import interpret
from Astar import find_path
import PRM
import copy
#from descartes.patch import PolygonPatch
class Graph():
def __init__(self,mp):
self.edges=[]
self.vertices=[]
self.mp=mp
def addVertex(self,point):
self.vertices.append(point)
def copy(self):
return copy.deepcopy(self)
def ngd(self, a):
neighbors=[]
distances=[]
for pt in self.vertices:
if pt[0]!=a[0] or pt[1]!=a[1]:
dist=np.sqrt(np.square(pt[0]-a[0])+np.square(pt[1]-a[1]))
if not distances:
distances.append(dist)
neighbors.append(pt)
else:
counter=0
while counter<len(distances) and dist>distances[counter]:
counter+=1
distances.insert(counter,dist)
neighbors.insert(counter,pt)
return neighbors
def can_connect(self,a,q):
return not self.mp.collide(a,q)
def connect(self,a,q):
if self.can_connect(a,q):
if (a,q) not in self.edges and (q,a) not in self.edges:
self.edges.append((a,q))
def sample(self):
samp=self.mp.sample()
self.addVertex(samp)
return samp
class Map():
points=[] #PRM points
edges=[] #PRM edges
lines=[]
buff_lines=[]
obstacles=[]
buff=0
vis_graph=None
visibility=False
def __init__(self,lx=0,hx=0,ly=0,hy=0):
self.lx=lx
self.hx=hx
self.ly=ly
self.hy=hy
"""Returns a pt that is collision free"""
def sample(self):
x=None
y=None
while x==None or self.collide((x,y)):
xwidth=self.hx-self.lx
ywidth=self.hy-self.ly
x=xwidth*rd.random()+self.lx
y=ywidth*rd.random()+self.ly
return (x,y)
def collide(self,point1,point2=None):
if point2==None:
point=shapely.Point(point1[0],point1[1])
for obs in self.obstacles:
if point.within(obs[1]) and not point.touches(obs[1]):
return True
else:
path =shapely.LineString([point1,point2])
if self.buff>0:
path=path.buffer(self.buff)
for obs in self.obstacles:
|
return False
def clear(self):
self.lines=[]
self.buff_lines=[]
self.obstacles=[]
"""vertices are of format [(a,b),(c,d)]"""
def add_Poly(self,vertices=[]):
if self.visibility:
init_poly=shapely.Polygon(vertices)
buff_poly=init_poly.buffer(self.buff,cap_style=2,join_style =2)
new_vert=list(buff_poly.exterior.coords)
self.obstacles.append((mplpath.Path(vertices),init_poly,new_vert,mplpath.Path(new_vert),buff_poly))
else:
self.obstacles.append((mplpath.Path(vertices),shapely.Polygon(vertices),vertices))
def display(self):
"""start grid"""
fig, ax = plt.subplots()
"""Add Obstacles"""
if self.buff>0 and self.visibility:
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[3], facecolor='orange',alpha=0.5))
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[0], facecolor='purple'))
"""Set boundaries"""
ax.set_xlim([self.lx,self.hx])
ax.set_ylim([self.ly,self.hy])
"""add edges"""
c=[]
for edge in self.edges:
c.append((1,0,0,0.5))
# vis_lines.append([(edge[0][0],edge[0][1]),(edge[1][0],edge[1][1])])
ax.add_collection(mc.LineCollection(self.edges,colors=c,linewidths = 1.0))
"""Set size of plot"""
fig_size = plt.rcParams["figure.figsize"]
fig_size[0] = 12
fig_size[1] = 9
plt.rcParams["figure.figsize"] = fig_size
"""draw points"""
for pt in self.points:
plt.plot(pt[0],pt[1],marker='o', markersize=5, color="black")
"""draw lines to the plot"""
if not self.visibility and self.buff>0:
path=shapely.LineString(self.buff_lines)
poly=path.buffer(self.buff)
poly_points=list(poly.exterior.coords)
ax.add_patch(patches.PathPatch(mplpath.Path(poly_points), facecolor='yellow',alpha=0.5))
lc = mc.LineCollection(self.lines,linewidths = 2.5)
ax.add_collection(lc)
"""Set up Axis """
ax.minorticks_on()
ax.xaxis.set_major_locator(plt.MultipleLocator(1))
ax.yaxis.set_major_locator(plt.MultipleLocator(1))
ax.xaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.yaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.grid(which='major', linestyle='-', linewidth='0.5', color='black')
ax.grid(which='minor', linestyle='-', linewidth='0.2', color='black')
plt.show()
def average(intlist):
total=0
for val in intlist:
total+=val
if len(intlist)>0:
return total/float(len(intlist))
else:
return -1
def sd(intlist):
avg= average(intlist)
variance=0
for val in intlist:
variance+=np.square(val-avg)
if len(intlist)>0:
variance= variance/float(len(intlist))
return np.sqrt(variance)
else:
return -1
def stats():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-8,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(9,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-7,-5) ,(-7,-4) ])
mp.add_Poly([(7,6), (0,4) ,(-8,7) ,(0,6), (4,8)])
mp.add_Poly([(-9,-9), (8,-5) ,(9,-8)])
starts=[]
goals=[]
for i in range(25):
starts.append(mp.sample())
goals.append(mp.sample())
prmcc_maps=[]
prmk_maps=[]
prmstar_maps=[]
conn=[]
for i in range(10):
g1=Graph(mp)
g2=Graph(mp)
g3=Graph(mp)
conn.append(PRM.prm_cc(g1,25*i+25))
PRM.prm_k(g2,25*i+25,5)
PRM.prm_star(g3,25*i+25)
prmcc_maps.append(g1)
prmk_maps.append(g2)
prmstar_maps.append(g3)
print i
cc_stats=[]
k_stats=[]
star_stats=[]
c=0
for prm_map in prmcc_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_cc(temp,0,starts[i],goals[i],copy.deepcopy(conn[c]))
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
cc_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmk_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_k(temp,0,5,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
k_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmstar_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_star(temp,0,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
star_stats.append(average(raw_dat))
c+=1
print c
print cc_stats
print k_stats
print star_stats
def test():
# mp = Map(-5,5,-5,5)
mp = Map(-7, 8, -7, 8)
start=(-6,7)
goal=(6,-6)
"""Add obstacles"""
# mp.add_Poly([(-1,-1),(-1,1),(1,1),(1,-1)])
mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
# mp.add_Poly([(-2,0),(-2,-1),(2,-1),(2,0)])
graph=Graph(mp)
"""Create graph for PRM"""
# PRM.prm_cc(graph,100,start,goal)
# PRM.prm_k(graph,100,3,start,goal)
PRM.prm_star(graph,5)
"""Add graph and tree to display and print out what it looks"""
mp.points=graph.vertices
mp.edges=graph.edges
mp.display()
"""Run A-Star to find a path"""
# ag=interpret(graph.vertices,graph.edges)
# end = ag.nodes.pop()#end is always last of list
# beg = ag.nodes.pop()#beginning is second to last
# find_path(beg,end)
# iterator = end
#
# """Get line segments to draw a-star path"""
# lines=[]
# while iterator.parent != None:
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
# iterator=iterator.parent
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
#
# """Input all of data to map display and display it"""
# mp.lines=lines
# mp.points=graph.vertices
# mp.edges=graph.edges
# mp.display()
def main():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
g1=Graph(mp)
PRM.prm_star(g1,20)
start=(-6,7)
goal=(6,-6)
PRM.prm_star(g1,0,start,goal)
if __name__ == '__main__':
stats()
| if obs[1].intersects(path) and not path.touches(obs[1]):
return True | conditional_block |
XYRepresentation.py | # -*- coding: utf-8 -*-
"""
Created on Mon Nov 5 15:06:34 2018
@author: lawrence
"""
import numpy as np
import random as rd
import matplotlib.pyplot as plt
import matplotlib.path as mplpath
import matplotlib.patches as patches
from matplotlib.collections import PatchCollection
from matplotlib import collections as mc
import shapely.geometry as shapely
from XYaStarInterpreter import interpret
from Astar import find_path
import PRM
import copy
#from descartes.patch import PolygonPatch
class Graph():
def __init__(self,mp):
self.edges=[]
self.vertices=[]
self.mp=mp
def addVertex(self,point):
self.vertices.append(point)
def copy(self):
return copy.deepcopy(self)
def ngd(self, a):
neighbors=[]
distances=[]
for pt in self.vertices:
if pt[0]!=a[0] or pt[1]!=a[1]:
dist=np.sqrt(np.square(pt[0]-a[0])+np.square(pt[1]-a[1]))
if not distances:
distances.append(dist)
neighbors.append(pt)
else:
counter=0
while counter<len(distances) and dist>distances[counter]:
counter+=1
distances.insert(counter,dist)
neighbors.insert(counter,pt)
return neighbors
def can_connect(self,a,q):
return not self.mp.collide(a,q)
def | (self,a,q):
if self.can_connect(a,q):
if (a,q) not in self.edges and (q,a) not in self.edges:
self.edges.append((a,q))
def sample(self):
samp=self.mp.sample()
self.addVertex(samp)
return samp
class Map():
points=[] #PRM points
edges=[] #PRM edges
lines=[]
buff_lines=[]
obstacles=[]
buff=0
vis_graph=None
visibility=False
def __init__(self,lx=0,hx=0,ly=0,hy=0):
self.lx=lx
self.hx=hx
self.ly=ly
self.hy=hy
"""Returns a pt that is collision free"""
def sample(self):
x=None
y=None
while x==None or self.collide((x,y)):
xwidth=self.hx-self.lx
ywidth=self.hy-self.ly
x=xwidth*rd.random()+self.lx
y=ywidth*rd.random()+self.ly
return (x,y)
def collide(self,point1,point2=None):
if point2==None:
point=shapely.Point(point1[0],point1[1])
for obs in self.obstacles:
if point.within(obs[1]) and not point.touches(obs[1]):
return True
else:
path =shapely.LineString([point1,point2])
if self.buff>0:
path=path.buffer(self.buff)
for obs in self.obstacles:
if obs[1].intersects(path) and not path.touches(obs[1]):
return True
return False
def clear(self):
self.lines=[]
self.buff_lines=[]
self.obstacles=[]
"""vertices are of format [(a,b),(c,d)]"""
def add_Poly(self,vertices=[]):
if self.visibility:
init_poly=shapely.Polygon(vertices)
buff_poly=init_poly.buffer(self.buff,cap_style=2,join_style =2)
new_vert=list(buff_poly.exterior.coords)
self.obstacles.append((mplpath.Path(vertices),init_poly,new_vert,mplpath.Path(new_vert),buff_poly))
else:
self.obstacles.append((mplpath.Path(vertices),shapely.Polygon(vertices),vertices))
def display(self):
"""start grid"""
fig, ax = plt.subplots()
"""Add Obstacles"""
if self.buff>0 and self.visibility:
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[3], facecolor='orange',alpha=0.5))
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[0], facecolor='purple'))
"""Set boundaries"""
ax.set_xlim([self.lx,self.hx])
ax.set_ylim([self.ly,self.hy])
"""add edges"""
c=[]
for edge in self.edges:
c.append((1,0,0,0.5))
# vis_lines.append([(edge[0][0],edge[0][1]),(edge[1][0],edge[1][1])])
ax.add_collection(mc.LineCollection(self.edges,colors=c,linewidths = 1.0))
"""Set size of plot"""
fig_size = plt.rcParams["figure.figsize"]
fig_size[0] = 12
fig_size[1] = 9
plt.rcParams["figure.figsize"] = fig_size
"""draw points"""
for pt in self.points:
plt.plot(pt[0],pt[1],marker='o', markersize=5, color="black")
"""draw lines to the plot"""
if not self.visibility and self.buff>0:
path=shapely.LineString(self.buff_lines)
poly=path.buffer(self.buff)
poly_points=list(poly.exterior.coords)
ax.add_patch(patches.PathPatch(mplpath.Path(poly_points), facecolor='yellow',alpha=0.5))
lc = mc.LineCollection(self.lines,linewidths = 2.5)
ax.add_collection(lc)
"""Set up Axis """
ax.minorticks_on()
ax.xaxis.set_major_locator(plt.MultipleLocator(1))
ax.yaxis.set_major_locator(plt.MultipleLocator(1))
ax.xaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.yaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.grid(which='major', linestyle='-', linewidth='0.5', color='black')
ax.grid(which='minor', linestyle='-', linewidth='0.2', color='black')
plt.show()
def average(intlist):
total=0
for val in intlist:
total+=val
if len(intlist)>0:
return total/float(len(intlist))
else:
return -1
def sd(intlist):
avg= average(intlist)
variance=0
for val in intlist:
variance+=np.square(val-avg)
if len(intlist)>0:
variance= variance/float(len(intlist))
return np.sqrt(variance)
else:
return -1
def stats():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-8,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(9,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-7,-5) ,(-7,-4) ])
mp.add_Poly([(7,6), (0,4) ,(-8,7) ,(0,6), (4,8)])
mp.add_Poly([(-9,-9), (8,-5) ,(9,-8)])
starts=[]
goals=[]
for i in range(25):
starts.append(mp.sample())
goals.append(mp.sample())
prmcc_maps=[]
prmk_maps=[]
prmstar_maps=[]
conn=[]
for i in range(10):
g1=Graph(mp)
g2=Graph(mp)
g3=Graph(mp)
conn.append(PRM.prm_cc(g1,25*i+25))
PRM.prm_k(g2,25*i+25,5)
PRM.prm_star(g3,25*i+25)
prmcc_maps.append(g1)
prmk_maps.append(g2)
prmstar_maps.append(g3)
print i
cc_stats=[]
k_stats=[]
star_stats=[]
c=0
for prm_map in prmcc_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_cc(temp,0,starts[i],goals[i],copy.deepcopy(conn[c]))
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
cc_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmk_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_k(temp,0,5,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
k_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmstar_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_star(temp,0,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
star_stats.append(average(raw_dat))
c+=1
print c
print cc_stats
print k_stats
print star_stats
def test():
# mp = Map(-5,5,-5,5)
mp = Map(-7, 8, -7, 8)
start=(-6,7)
goal=(6,-6)
"""Add obstacles"""
# mp.add_Poly([(-1,-1),(-1,1),(1,1),(1,-1)])
mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
# mp.add_Poly([(-2,0),(-2,-1),(2,-1),(2,0)])
graph=Graph(mp)
"""Create graph for PRM"""
# PRM.prm_cc(graph,100,start,goal)
# PRM.prm_k(graph,100,3,start,goal)
PRM.prm_star(graph,5)
"""Add graph and tree to display and print out what it looks"""
mp.points=graph.vertices
mp.edges=graph.edges
mp.display()
"""Run A-Star to find a path"""
# ag=interpret(graph.vertices,graph.edges)
# end = ag.nodes.pop()#end is always last of list
# beg = ag.nodes.pop()#beginning is second to last
# find_path(beg,end)
# iterator = end
#
# """Get line segments to draw a-star path"""
# lines=[]
# while iterator.parent != None:
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
# iterator=iterator.parent
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
#
# """Input all of data to map display and display it"""
# mp.lines=lines
# mp.points=graph.vertices
# mp.edges=graph.edges
# mp.display()
def main():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
g1=Graph(mp)
PRM.prm_star(g1,20)
start=(-6,7)
goal=(6,-6)
PRM.prm_star(g1,0,start,goal)
if __name__ == '__main__':
stats()
| connect | identifier_name |
XYRepresentation.py | # -*- coding: utf-8 -*-
"""
Created on Mon Nov 5 15:06:34 2018
@author: lawrence
"""
import numpy as np
import random as rd
import matplotlib.pyplot as plt
import matplotlib.path as mplpath
import matplotlib.patches as patches
from matplotlib.collections import PatchCollection
from matplotlib import collections as mc
import shapely.geometry as shapely
from XYaStarInterpreter import interpret
from Astar import find_path
import PRM
import copy
#from descartes.patch import PolygonPatch
class Graph():
def __init__(self,mp):
self.edges=[]
self.vertices=[]
self.mp=mp
def addVertex(self,point):
self.vertices.append(point)
def copy(self):
return copy.deepcopy(self)
def ngd(self, a):
neighbors=[]
distances=[]
for pt in self.vertices:
if pt[0]!=a[0] or pt[1]!=a[1]:
dist=np.sqrt(np.square(pt[0]-a[0])+np.square(pt[1]-a[1]))
if not distances:
distances.append(dist)
neighbors.append(pt)
else:
counter=0
while counter<len(distances) and dist>distances[counter]:
counter+=1
distances.insert(counter,dist)
neighbors.insert(counter,pt)
return neighbors
def can_connect(self,a,q):
return not self.mp.collide(a,q)
def connect(self,a,q):
if self.can_connect(a,q):
if (a,q) not in self.edges and (q,a) not in self.edges:
self.edges.append((a,q))
def sample(self):
samp=self.mp.sample()
self.addVertex(samp)
return samp
class Map():
points=[] #PRM points
edges=[] #PRM edges
lines=[]
buff_lines=[]
obstacles=[]
buff=0
vis_graph=None
visibility=False
def __init__(self,lx=0,hx=0,ly=0,hy=0):
self.lx=lx
self.hx=hx
self.ly=ly
self.hy=hy
"""Returns a pt that is collision free"""
def sample(self):
x=None
y=None
while x==None or self.collide((x,y)):
xwidth=self.hx-self.lx
ywidth=self.hy-self.ly
x=xwidth*rd.random()+self.lx
y=ywidth*rd.random()+self.ly
return (x,y)
def collide(self,point1,point2=None):
if point2==None:
point=shapely.Point(point1[0],point1[1])
for obs in self.obstacles:
if point.within(obs[1]) and not point.touches(obs[1]):
return True
else:
path =shapely.LineString([point1,point2])
if self.buff>0:
path=path.buffer(self.buff)
for obs in self.obstacles:
if obs[1].intersects(path) and not path.touches(obs[1]):
return True
return False
def clear(self):
self.lines=[]
self.buff_lines=[]
self.obstacles=[]
"""vertices are of format [(a,b),(c,d)]"""
def add_Poly(self,vertices=[]):
if self.visibility:
init_poly=shapely.Polygon(vertices)
buff_poly=init_poly.buffer(self.buff,cap_style=2,join_style =2)
new_vert=list(buff_poly.exterior.coords)
self.obstacles.append((mplpath.Path(vertices),init_poly,new_vert,mplpath.Path(new_vert),buff_poly))
else:
self.obstacles.append((mplpath.Path(vertices),shapely.Polygon(vertices),vertices))
def display(self):
"""start grid"""
fig, ax = plt.subplots()
"""Add Obstacles"""
if self.buff>0 and self.visibility:
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[3], facecolor='orange',alpha=0.5))
for poly in self.obstacles:
ax.add_patch(patches.PathPatch(poly[0], facecolor='purple'))
"""Set boundaries"""
ax.set_xlim([self.lx,self.hx])
ax.set_ylim([self.ly,self.hy])
"""add edges"""
c=[]
for edge in self.edges:
c.append((1,0,0,0.5))
# vis_lines.append([(edge[0][0],edge[0][1]),(edge[1][0],edge[1][1])])
ax.add_collection(mc.LineCollection(self.edges,colors=c,linewidths = 1.0))
"""Set size of plot"""
fig_size = plt.rcParams["figure.figsize"]
fig_size[0] = 12
fig_size[1] = 9
plt.rcParams["figure.figsize"] = fig_size
"""draw points"""
for pt in self.points:
plt.plot(pt[0],pt[1],marker='o', markersize=5, color="black")
"""draw lines to the plot"""
if not self.visibility and self.buff>0:
path=shapely.LineString(self.buff_lines)
poly=path.buffer(self.buff)
poly_points=list(poly.exterior.coords)
ax.add_patch(patches.PathPatch(mplpath.Path(poly_points), facecolor='yellow',alpha=0.5))
lc = mc.LineCollection(self.lines,linewidths = 2.5)
ax.add_collection(lc)
"""Set up Axis """
ax.minorticks_on()
ax.xaxis.set_major_locator(plt.MultipleLocator(1))
ax.yaxis.set_major_locator(plt.MultipleLocator(1))
ax.xaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.yaxis.set_minor_locator(plt.MultipleLocator(0.25))
ax.grid(which='major', linestyle='-', linewidth='0.5', color='black')
ax.grid(which='minor', linestyle='-', linewidth='0.2', color='black')
plt.show()
def average(intlist):
total=0
for val in intlist:
total+=val
if len(intlist)>0:
return total/float(len(intlist))
else:
return -1
def sd(intlist):
avg= average(intlist)
variance=0
for val in intlist:
variance+=np.square(val-avg)
if len(intlist)>0:
variance= variance/float(len(intlist))
return np.sqrt(variance)
else:
return -1
def stats():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-8,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(9,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-7,-5) ,(-7,-4) ])
mp.add_Poly([(7,6), (0,4) ,(-8,7) ,(0,6), (4,8)])
mp.add_Poly([(-9,-9), (8,-5) ,(9,-8)])
starts=[]
goals=[]
for i in range(25):
starts.append(mp.sample())
goals.append(mp.sample())
prmcc_maps=[]
prmk_maps=[]
prmstar_maps=[]
conn=[]
for i in range(10):
g1=Graph(mp)
g2=Graph(mp)
g3=Graph(mp)
conn.append(PRM.prm_cc(g1,25*i+25))
PRM.prm_k(g2,25*i+25,5)
PRM.prm_star(g3,25*i+25)
prmcc_maps.append(g1)
prmk_maps.append(g2)
prmstar_maps.append(g3)
print i
cc_stats=[]
k_stats=[]
star_stats=[]
c=0
for prm_map in prmcc_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_cc(temp,0,starts[i],goals[i],copy.deepcopy(conn[c]))
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
cc_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmk_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_k(temp,0,5,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
k_stats.append(average(raw_dat))
c+=1
print c
c=0
for prm_map in prmstar_maps:
raw_dat=[]
for i in range(len(starts)):
temp=prm_map.copy()
PRM.prm_star(temp,0,starts[i],goals[i])
ag=interpret(temp.vertices,temp.edges)
end = ag.nodes.pop()
beg = ag.nodes.pop()
if find_path(beg,end):
raw_dat.append(end.g)
star_stats.append(average(raw_dat))
c+=1
print c
print cc_stats
print k_stats
print star_stats
def test():
# mp = Map(-5,5,-5,5)
mp = Map(-7, 8, -7, 8)
start=(-6,7)
goal=(6,-6)
"""Add obstacles"""
# mp.add_Poly([(-1,-1),(-1,1),(1,1),(1,-1)]) | graph=Graph(mp)
"""Create graph for PRM"""
# PRM.prm_cc(graph,100,start,goal)
# PRM.prm_k(graph,100,3,start,goal)
PRM.prm_star(graph,5)
"""Add graph and tree to display and print out what it looks"""
mp.points=graph.vertices
mp.edges=graph.edges
mp.display()
"""Run A-Star to find a path"""
# ag=interpret(graph.vertices,graph.edges)
# end = ag.nodes.pop()#end is always last of list
# beg = ag.nodes.pop()#beginning is second to last
# find_path(beg,end)
# iterator = end
#
# """Get line segments to draw a-star path"""
# lines=[]
# while iterator.parent != None:
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
# iterator=iterator.parent
# lines.append([(iterator.x,iterator.y),(iterator.parent.x,iterator.parent.y)])
#
# """Input all of data to map display and display it"""
# mp.lines=lines
# mp.points=graph.vertices
# mp.edges=graph.edges
# mp.display()
def main():
mp = Map(-10,10,-10,10)
mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
g1=Graph(mp)
PRM.prm_star(g1,20)
start=(-6,7)
goal=(6,-6)
PRM.prm_star(g1,0,start,goal)
if __name__ == '__main__':
stats() | mp.add_Poly([(-1,-1), (-6,-2), (-5,2), (-3,2), (-4,0)])
mp.add_Poly([(6,5), (4,1), (5,-2), (2,-4), (1,2)])
mp.add_Poly([(0,-3) ,(0,-4) ,(1,-5) ,(-5,-5) ,(-5,-4) ])
mp.add_Poly([(6,6), (0,4) ,(-5,6) ,(0,6), (4,7)])
# mp.add_Poly([(-2,0),(-2,-1),(2,-1),(2,0)]) | random_line_split |
loadout-builder-reducer.ts | import {
defaultLoadoutParameters,
LoadoutParameters,
UpgradeSpendTier,
} from '@destinyitemmanager/dim-api-types';
import { D2ManifestDefinitions } from 'app/destiny2/d2-definitions';
import { t } from 'app/i18next-t';
import { DimItem, PluggableInventoryItemDefinition } from 'app/inventory/item-types';
import { DimStore } from 'app/inventory/store-types';
import { getCurrentStore, getItemAcrossStores } from 'app/inventory/stores-helpers';
import { Loadout } from 'app/loadout-drawer/loadout-types';
import { showNotification } from 'app/notifications/notifications';
import { armor2PlugCategoryHashesByName } from 'app/search/d2-known-values';
import { DestinyClass } from 'bungie-api-ts/destiny2';
import _ from 'lodash';
import { useReducer } from 'react';
import { isLoadoutBuilderItem } from '../loadout/item-utils';
import {
lockedModsFromLoadoutParameters,
statFiltersFromLoadoutParamaters,
statOrderFromLoadoutParameters,
} from './loadout-params';
import { ArmorSet, ArmorStatHashes, ExcludedItems, PinnedItems, StatFilters } from './types';
export interface LoadoutBuilderState {
statOrder: ArmorStatHashes[]; // stat hashes, including disabled stats
upgradeSpendTier: UpgradeSpendTier;
lockItemEnergyType: boolean;
pinnedItems: PinnedItems;
excludedItems: ExcludedItems;
lockedMods: PluggableInventoryItemDefinition[];
lockedExoticHash?: number;
selectedStoreId?: string;
statFilters: Readonly<StatFilters>;
modPicker: {
open: boolean;
initialQuery?: string;
};
compareSet?: ArmorSet;
}
function warnMissingClass(classType: DestinyClass, defs: D2ManifestDefinitions) {
const missingClassName = Object.values(defs.Class).find((c) => c.classType === classType)!
.displayProperties.name; | body: t('LoadoutBuilder.MissingClassDescription'),
});
}
const lbStateInit = ({
stores,
preloadedLoadout,
initialLoadoutParameters,
classType,
defs,
}: {
stores: DimStore[];
preloadedLoadout?: Loadout;
initialLoadoutParameters: LoadoutParameters;
classType: DestinyClass | undefined;
defs: D2ManifestDefinitions;
}): LoadoutBuilderState => {
const pinnedItems: PinnedItems = {};
const matchingClass =
classType !== undefined ? stores.find((store) => store.classType === classType) : undefined;
if (classType !== undefined && !matchingClass) {
warnMissingClass(classType, defs);
// Take out the exotic
initialLoadoutParameters = { ...initialLoadoutParameters, exoticArmorHash: undefined };
}
let selectedStoreId = (matchingClass ?? getCurrentStore(stores)!).id;
let loadoutParams = initialLoadoutParameters;
if (stores.length && preloadedLoadout) {
const loadoutStore = stores.find((store) => store.classType === preloadedLoadout.classType);
if (!loadoutStore) {
warnMissingClass(preloadedLoadout.classType, defs);
} else {
selectedStoreId = loadoutStore.id;
// TODO: instead of locking items, show the loadout fixed at the top to compare against and leave all items free
for (const loadoutItem of preloadedLoadout.items) {
if (loadoutItem.equipped) {
const item = getItemAcrossStores(stores, loadoutItem);
if (item && isLoadoutBuilderItem(item)) {
pinnedItems[item.bucket.hash] = item;
}
}
}
// Load all parameters from the loadout if we can
if (preloadedLoadout.parameters) {
loadoutParams = { ...defaultLoadoutParameters, ...preloadedLoadout.parameters };
}
}
}
const statOrder = statOrderFromLoadoutParameters(loadoutParams);
const statFilters = statFiltersFromLoadoutParamaters(loadoutParams);
const lockedMods = lockedModsFromLoadoutParameters(loadoutParams, defs);
const lockItemEnergyType = Boolean(loadoutParams?.lockItemEnergyType);
// We need to handle the deprecated case
const upgradeSpendTier =
loadoutParams.upgradeSpendTier === UpgradeSpendTier.AscendantShardsLockEnergyType
? UpgradeSpendTier.Nothing
: loadoutParams.upgradeSpendTier!;
const lockedExoticHash = loadoutParams.exoticArmorHash;
return {
lockItemEnergyType,
upgradeSpendTier,
statOrder,
pinnedItems,
excludedItems: [],
statFilters,
lockedMods,
lockedExoticHash,
selectedStoreId,
modPicker: {
open: false,
},
};
};
export type LoadoutBuilderAction =
| { type: 'changeCharacter'; storeId: string }
| { type: 'statFiltersChanged'; statFilters: LoadoutBuilderState['statFilters'] }
| { type: 'sortOrderChanged'; sortOrder: LoadoutBuilderState['statOrder'] }
| {
type: 'lockItemEnergyTypeChanged';
lockItemEnergyType: LoadoutBuilderState['lockItemEnergyType'];
}
| { type: 'upgradeSpendTierChanged'; upgradeSpendTier: LoadoutBuilderState['upgradeSpendTier'] }
| { type: 'pinItem'; item: DimItem }
| { type: 'setPinnedItems'; items: DimItem[] }
| { type: 'unpinItem'; item: DimItem }
| { type: 'excludeItem'; item: DimItem }
| { type: 'unexcludeItem'; item: DimItem }
| {
type: 'lockedModsChanged';
lockedMods: PluggableInventoryItemDefinition[];
}
| { type: 'removeLockedMod'; mod: PluggableInventoryItemDefinition }
| { type: 'addGeneralMods'; mods: PluggableInventoryItemDefinition[] }
| { type: 'lockExotic'; lockedExoticHash: number }
| { type: 'removeLockedExotic' }
| { type: 'openModPicker'; initialQuery?: string }
| { type: 'closeModPicker' }
| { type: 'openCompareDrawer'; set: ArmorSet }
| { type: 'closeCompareDrawer' };
// TODO: Move more logic inside the reducer
function lbStateReducer(
state: LoadoutBuilderState,
action: LoadoutBuilderAction
): LoadoutBuilderState {
switch (action.type) {
case 'changeCharacter':
return {
...state,
selectedStoreId: action.storeId,
pinnedItems: {},
excludedItems: {},
lockedExoticHash: undefined,
};
case 'statFiltersChanged':
return { ...state, statFilters: action.statFilters };
case 'pinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
// Remove any previously locked item in that bucket and add this one
pinnedItems: {
...state.pinnedItems,
[bucketHash]: item,
},
// Locking an item clears excluded items in this bucket
excludedItems: {
...state.excludedItems,
[bucketHash]: undefined,
},
};
}
case 'setPinnedItems': {
const { items } = action;
return {
...state,
pinnedItems: _.keyBy(items, (i) => i.bucket.hash),
excludedItems: {},
};
}
case 'unpinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
pinnedItems: {
...state.pinnedItems,
[bucketHash]: undefined,
},
};
}
case 'excludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
if (state.excludedItems[bucketHash]?.some((i) => i.id === item.id)) {
return state; // item's already there
}
const existingExcluded = state.excludedItems[bucketHash] ?? [];
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: [...existingExcluded, item],
},
};
}
case 'unexcludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
const newExcluded = (state.excludedItems[bucketHash] ?? []).filter((i) => i.id !== item.id);
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: newExcluded.length > 0 ? newExcluded : undefined,
},
};
}
case 'lockedModsChanged': {
return {
...state,
lockedMods: action.lockedMods,
};
}
case 'sortOrderChanged': {
return {
...state,
statOrder: action.sortOrder,
};
}
case 'lockItemEnergyTypeChanged': {
return {
...state,
lockItemEnergyType: action.lockItemEnergyType,
};
}
case 'upgradeSpendTierChanged': {
return {
...state,
upgradeSpendTier: action.upgradeSpendTier,
};
}
case 'addGeneralMods': {
let currentGeneralModsCount = state.lockedMods.filter(
(mod) => mod.plug.plugCategoryHash === armor2PlugCategoryHashesByName.general
).length;
const newMods = [...state.lockedMods];
const failures: string[] = [];
for (const mod of action.mods) {
if (currentGeneralModsCount < 5) {
newMods.push(mod);
currentGeneralModsCount++;
} else {
failures.push(mod.displayProperties.name);
}
}
if (failures.length) {
showNotification({
title: t('LoadoutBuilder.UnableToAddAllMods'),
body: t('LoadoutBuilder.UnableToAddAllModsBody', { mods: failures.join(', ') }),
type: 'warning',
});
}
return {
...state,
lockedMods: newMods,
};
}
case 'removeLockedMod': {
const indexToRemove = state.lockedMods.findIndex((mod) => mod.hash === action.mod.hash);
const newMods = [...state.lockedMods];
newMods.splice(indexToRemove, 1);
return {
...state,
lockedMods: newMods,
};
}
case 'lockExotic': {
const { lockedExoticHash } = action;
return { ...state, lockedExoticHash };
}
case 'removeLockedExotic': {
return { ...state, lockedExoticHash: undefined };
}
case 'openModPicker':
return {
...state,
modPicker: {
open: true,
initialQuery: action.initialQuery,
},
};
case 'closeModPicker':
return { ...state, modPicker: { open: false } };
case 'openCompareDrawer':
return { ...state, compareSet: action.set };
case 'closeCompareDrawer':
return { ...state, compareSet: undefined };
}
}
export function useLbState(
stores: DimStore[],
preloadedLoadout: Loadout | undefined,
classType: DestinyClass | undefined,
initialLoadoutParameters: LoadoutParameters,
defs: D2ManifestDefinitions
) {
return useReducer(
lbStateReducer,
{ stores, preloadedLoadout, initialLoadoutParameters, defs, classType },
lbStateInit
);
} |
showNotification({
type: 'error',
title: t('LoadoutBuilder.MissingClass', { className: missingClassName }), | random_line_split |
loadout-builder-reducer.ts | import {
defaultLoadoutParameters,
LoadoutParameters,
UpgradeSpendTier,
} from '@destinyitemmanager/dim-api-types';
import { D2ManifestDefinitions } from 'app/destiny2/d2-definitions';
import { t } from 'app/i18next-t';
import { DimItem, PluggableInventoryItemDefinition } from 'app/inventory/item-types';
import { DimStore } from 'app/inventory/store-types';
import { getCurrentStore, getItemAcrossStores } from 'app/inventory/stores-helpers';
import { Loadout } from 'app/loadout-drawer/loadout-types';
import { showNotification } from 'app/notifications/notifications';
import { armor2PlugCategoryHashesByName } from 'app/search/d2-known-values';
import { DestinyClass } from 'bungie-api-ts/destiny2';
import _ from 'lodash';
import { useReducer } from 'react';
import { isLoadoutBuilderItem } from '../loadout/item-utils';
import {
lockedModsFromLoadoutParameters,
statFiltersFromLoadoutParamaters,
statOrderFromLoadoutParameters,
} from './loadout-params';
import { ArmorSet, ArmorStatHashes, ExcludedItems, PinnedItems, StatFilters } from './types';
export interface LoadoutBuilderState {
statOrder: ArmorStatHashes[]; // stat hashes, including disabled stats
upgradeSpendTier: UpgradeSpendTier;
lockItemEnergyType: boolean;
pinnedItems: PinnedItems;
excludedItems: ExcludedItems;
lockedMods: PluggableInventoryItemDefinition[];
lockedExoticHash?: number;
selectedStoreId?: string;
statFilters: Readonly<StatFilters>;
modPicker: {
open: boolean;
initialQuery?: string;
};
compareSet?: ArmorSet;
}
function | (classType: DestinyClass, defs: D2ManifestDefinitions) {
const missingClassName = Object.values(defs.Class).find((c) => c.classType === classType)!
.displayProperties.name;
showNotification({
type: 'error',
title: t('LoadoutBuilder.MissingClass', { className: missingClassName }),
body: t('LoadoutBuilder.MissingClassDescription'),
});
}
const lbStateInit = ({
stores,
preloadedLoadout,
initialLoadoutParameters,
classType,
defs,
}: {
stores: DimStore[];
preloadedLoadout?: Loadout;
initialLoadoutParameters: LoadoutParameters;
classType: DestinyClass | undefined;
defs: D2ManifestDefinitions;
}): LoadoutBuilderState => {
const pinnedItems: PinnedItems = {};
const matchingClass =
classType !== undefined ? stores.find((store) => store.classType === classType) : undefined;
if (classType !== undefined && !matchingClass) {
warnMissingClass(classType, defs);
// Take out the exotic
initialLoadoutParameters = { ...initialLoadoutParameters, exoticArmorHash: undefined };
}
let selectedStoreId = (matchingClass ?? getCurrentStore(stores)!).id;
let loadoutParams = initialLoadoutParameters;
if (stores.length && preloadedLoadout) {
const loadoutStore = stores.find((store) => store.classType === preloadedLoadout.classType);
if (!loadoutStore) {
warnMissingClass(preloadedLoadout.classType, defs);
} else {
selectedStoreId = loadoutStore.id;
// TODO: instead of locking items, show the loadout fixed at the top to compare against and leave all items free
for (const loadoutItem of preloadedLoadout.items) {
if (loadoutItem.equipped) {
const item = getItemAcrossStores(stores, loadoutItem);
if (item && isLoadoutBuilderItem(item)) {
pinnedItems[item.bucket.hash] = item;
}
}
}
// Load all parameters from the loadout if we can
if (preloadedLoadout.parameters) {
loadoutParams = { ...defaultLoadoutParameters, ...preloadedLoadout.parameters };
}
}
}
const statOrder = statOrderFromLoadoutParameters(loadoutParams);
const statFilters = statFiltersFromLoadoutParamaters(loadoutParams);
const lockedMods = lockedModsFromLoadoutParameters(loadoutParams, defs);
const lockItemEnergyType = Boolean(loadoutParams?.lockItemEnergyType);
// We need to handle the deprecated case
const upgradeSpendTier =
loadoutParams.upgradeSpendTier === UpgradeSpendTier.AscendantShardsLockEnergyType
? UpgradeSpendTier.Nothing
: loadoutParams.upgradeSpendTier!;
const lockedExoticHash = loadoutParams.exoticArmorHash;
return {
lockItemEnergyType,
upgradeSpendTier,
statOrder,
pinnedItems,
excludedItems: [],
statFilters,
lockedMods,
lockedExoticHash,
selectedStoreId,
modPicker: {
open: false,
},
};
};
export type LoadoutBuilderAction =
| { type: 'changeCharacter'; storeId: string }
| { type: 'statFiltersChanged'; statFilters: LoadoutBuilderState['statFilters'] }
| { type: 'sortOrderChanged'; sortOrder: LoadoutBuilderState['statOrder'] }
| {
type: 'lockItemEnergyTypeChanged';
lockItemEnergyType: LoadoutBuilderState['lockItemEnergyType'];
}
| { type: 'upgradeSpendTierChanged'; upgradeSpendTier: LoadoutBuilderState['upgradeSpendTier'] }
| { type: 'pinItem'; item: DimItem }
| { type: 'setPinnedItems'; items: DimItem[] }
| { type: 'unpinItem'; item: DimItem }
| { type: 'excludeItem'; item: DimItem }
| { type: 'unexcludeItem'; item: DimItem }
| {
type: 'lockedModsChanged';
lockedMods: PluggableInventoryItemDefinition[];
}
| { type: 'removeLockedMod'; mod: PluggableInventoryItemDefinition }
| { type: 'addGeneralMods'; mods: PluggableInventoryItemDefinition[] }
| { type: 'lockExotic'; lockedExoticHash: number }
| { type: 'removeLockedExotic' }
| { type: 'openModPicker'; initialQuery?: string }
| { type: 'closeModPicker' }
| { type: 'openCompareDrawer'; set: ArmorSet }
| { type: 'closeCompareDrawer' };
// TODO: Move more logic inside the reducer
function lbStateReducer(
state: LoadoutBuilderState,
action: LoadoutBuilderAction
): LoadoutBuilderState {
switch (action.type) {
case 'changeCharacter':
return {
...state,
selectedStoreId: action.storeId,
pinnedItems: {},
excludedItems: {},
lockedExoticHash: undefined,
};
case 'statFiltersChanged':
return { ...state, statFilters: action.statFilters };
case 'pinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
// Remove any previously locked item in that bucket and add this one
pinnedItems: {
...state.pinnedItems,
[bucketHash]: item,
},
// Locking an item clears excluded items in this bucket
excludedItems: {
...state.excludedItems,
[bucketHash]: undefined,
},
};
}
case 'setPinnedItems': {
const { items } = action;
return {
...state,
pinnedItems: _.keyBy(items, (i) => i.bucket.hash),
excludedItems: {},
};
}
case 'unpinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
pinnedItems: {
...state.pinnedItems,
[bucketHash]: undefined,
},
};
}
case 'excludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
if (state.excludedItems[bucketHash]?.some((i) => i.id === item.id)) {
return state; // item's already there
}
const existingExcluded = state.excludedItems[bucketHash] ?? [];
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: [...existingExcluded, item],
},
};
}
case 'unexcludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
const newExcluded = (state.excludedItems[bucketHash] ?? []).filter((i) => i.id !== item.id);
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: newExcluded.length > 0 ? newExcluded : undefined,
},
};
}
case 'lockedModsChanged': {
return {
...state,
lockedMods: action.lockedMods,
};
}
case 'sortOrderChanged': {
return {
...state,
statOrder: action.sortOrder,
};
}
case 'lockItemEnergyTypeChanged': {
return {
...state,
lockItemEnergyType: action.lockItemEnergyType,
};
}
case 'upgradeSpendTierChanged': {
return {
...state,
upgradeSpendTier: action.upgradeSpendTier,
};
}
case 'addGeneralMods': {
let currentGeneralModsCount = state.lockedMods.filter(
(mod) => mod.plug.plugCategoryHash === armor2PlugCategoryHashesByName.general
).length;
const newMods = [...state.lockedMods];
const failures: string[] = [];
for (const mod of action.mods) {
if (currentGeneralModsCount < 5) {
newMods.push(mod);
currentGeneralModsCount++;
} else {
failures.push(mod.displayProperties.name);
}
}
if (failures.length) {
showNotification({
title: t('LoadoutBuilder.UnableToAddAllMods'),
body: t('LoadoutBuilder.UnableToAddAllModsBody', { mods: failures.join(', ') }),
type: 'warning',
});
}
return {
...state,
lockedMods: newMods,
};
}
case 'removeLockedMod': {
const indexToRemove = state.lockedMods.findIndex((mod) => mod.hash === action.mod.hash);
const newMods = [...state.lockedMods];
newMods.splice(indexToRemove, 1);
return {
...state,
lockedMods: newMods,
};
}
case 'lockExotic': {
const { lockedExoticHash } = action;
return { ...state, lockedExoticHash };
}
case 'removeLockedExotic': {
return { ...state, lockedExoticHash: undefined };
}
case 'openModPicker':
return {
...state,
modPicker: {
open: true,
initialQuery: action.initialQuery,
},
};
case 'closeModPicker':
return { ...state, modPicker: { open: false } };
case 'openCompareDrawer':
return { ...state, compareSet: action.set };
case 'closeCompareDrawer':
return { ...state, compareSet: undefined };
}
}
export function useLbState(
stores: DimStore[],
preloadedLoadout: Loadout | undefined,
classType: DestinyClass | undefined,
initialLoadoutParameters: LoadoutParameters,
defs: D2ManifestDefinitions
) {
return useReducer(
lbStateReducer,
{ stores, preloadedLoadout, initialLoadoutParameters, defs, classType },
lbStateInit
);
}
| warnMissingClass | identifier_name |
loadout-builder-reducer.ts | import {
defaultLoadoutParameters,
LoadoutParameters,
UpgradeSpendTier,
} from '@destinyitemmanager/dim-api-types';
import { D2ManifestDefinitions } from 'app/destiny2/d2-definitions';
import { t } from 'app/i18next-t';
import { DimItem, PluggableInventoryItemDefinition } from 'app/inventory/item-types';
import { DimStore } from 'app/inventory/store-types';
import { getCurrentStore, getItemAcrossStores } from 'app/inventory/stores-helpers';
import { Loadout } from 'app/loadout-drawer/loadout-types';
import { showNotification } from 'app/notifications/notifications';
import { armor2PlugCategoryHashesByName } from 'app/search/d2-known-values';
import { DestinyClass } from 'bungie-api-ts/destiny2';
import _ from 'lodash';
import { useReducer } from 'react';
import { isLoadoutBuilderItem } from '../loadout/item-utils';
import {
lockedModsFromLoadoutParameters,
statFiltersFromLoadoutParamaters,
statOrderFromLoadoutParameters,
} from './loadout-params';
import { ArmorSet, ArmorStatHashes, ExcludedItems, PinnedItems, StatFilters } from './types';
export interface LoadoutBuilderState {
statOrder: ArmorStatHashes[]; // stat hashes, including disabled stats
upgradeSpendTier: UpgradeSpendTier;
lockItemEnergyType: boolean;
pinnedItems: PinnedItems;
excludedItems: ExcludedItems;
lockedMods: PluggableInventoryItemDefinition[];
lockedExoticHash?: number;
selectedStoreId?: string;
statFilters: Readonly<StatFilters>;
modPicker: {
open: boolean;
initialQuery?: string;
};
compareSet?: ArmorSet;
}
function warnMissingClass(classType: DestinyClass, defs: D2ManifestDefinitions) {
const missingClassName = Object.values(defs.Class).find((c) => c.classType === classType)!
.displayProperties.name;
showNotification({
type: 'error',
title: t('LoadoutBuilder.MissingClass', { className: missingClassName }),
body: t('LoadoutBuilder.MissingClassDescription'),
});
}
const lbStateInit = ({
stores,
preloadedLoadout,
initialLoadoutParameters,
classType,
defs,
}: {
stores: DimStore[];
preloadedLoadout?: Loadout;
initialLoadoutParameters: LoadoutParameters;
classType: DestinyClass | undefined;
defs: D2ManifestDefinitions;
}): LoadoutBuilderState => {
const pinnedItems: PinnedItems = {};
const matchingClass =
classType !== undefined ? stores.find((store) => store.classType === classType) : undefined;
if (classType !== undefined && !matchingClass) {
warnMissingClass(classType, defs);
// Take out the exotic
initialLoadoutParameters = { ...initialLoadoutParameters, exoticArmorHash: undefined };
}
let selectedStoreId = (matchingClass ?? getCurrentStore(stores)!).id;
let loadoutParams = initialLoadoutParameters;
if (stores.length && preloadedLoadout) {
const loadoutStore = stores.find((store) => store.classType === preloadedLoadout.classType);
if (!loadoutStore) {
warnMissingClass(preloadedLoadout.classType, defs);
} else {
selectedStoreId = loadoutStore.id;
// TODO: instead of locking items, show the loadout fixed at the top to compare against and leave all items free
for (const loadoutItem of preloadedLoadout.items) {
if (loadoutItem.equipped) {
const item = getItemAcrossStores(stores, loadoutItem);
if (item && isLoadoutBuilderItem(item)) {
pinnedItems[item.bucket.hash] = item;
}
}
}
// Load all parameters from the loadout if we can
if (preloadedLoadout.parameters) {
loadoutParams = { ...defaultLoadoutParameters, ...preloadedLoadout.parameters };
}
}
}
const statOrder = statOrderFromLoadoutParameters(loadoutParams);
const statFilters = statFiltersFromLoadoutParamaters(loadoutParams);
const lockedMods = lockedModsFromLoadoutParameters(loadoutParams, defs);
const lockItemEnergyType = Boolean(loadoutParams?.lockItemEnergyType);
// We need to handle the deprecated case
const upgradeSpendTier =
loadoutParams.upgradeSpendTier === UpgradeSpendTier.AscendantShardsLockEnergyType
? UpgradeSpendTier.Nothing
: loadoutParams.upgradeSpendTier!;
const lockedExoticHash = loadoutParams.exoticArmorHash;
return {
lockItemEnergyType,
upgradeSpendTier,
statOrder,
pinnedItems,
excludedItems: [],
statFilters,
lockedMods,
lockedExoticHash,
selectedStoreId,
modPicker: {
open: false,
},
};
};
export type LoadoutBuilderAction =
| { type: 'changeCharacter'; storeId: string }
| { type: 'statFiltersChanged'; statFilters: LoadoutBuilderState['statFilters'] }
| { type: 'sortOrderChanged'; sortOrder: LoadoutBuilderState['statOrder'] }
| {
type: 'lockItemEnergyTypeChanged';
lockItemEnergyType: LoadoutBuilderState['lockItemEnergyType'];
}
| { type: 'upgradeSpendTierChanged'; upgradeSpendTier: LoadoutBuilderState['upgradeSpendTier'] }
| { type: 'pinItem'; item: DimItem }
| { type: 'setPinnedItems'; items: DimItem[] }
| { type: 'unpinItem'; item: DimItem }
| { type: 'excludeItem'; item: DimItem }
| { type: 'unexcludeItem'; item: DimItem }
| {
type: 'lockedModsChanged';
lockedMods: PluggableInventoryItemDefinition[];
}
| { type: 'removeLockedMod'; mod: PluggableInventoryItemDefinition }
| { type: 'addGeneralMods'; mods: PluggableInventoryItemDefinition[] }
| { type: 'lockExotic'; lockedExoticHash: number }
| { type: 'removeLockedExotic' }
| { type: 'openModPicker'; initialQuery?: string }
| { type: 'closeModPicker' }
| { type: 'openCompareDrawer'; set: ArmorSet }
| { type: 'closeCompareDrawer' };
// TODO: Move more logic inside the reducer
function lbStateReducer(
state: LoadoutBuilderState,
action: LoadoutBuilderAction
): LoadoutBuilderState |
export function useLbState(
stores: DimStore[],
preloadedLoadout: Loadout | undefined,
classType: DestinyClass | undefined,
initialLoadoutParameters: LoadoutParameters,
defs: D2ManifestDefinitions
) {
return useReducer(
lbStateReducer,
{ stores, preloadedLoadout, initialLoadoutParameters, defs, classType },
lbStateInit
);
}
| {
switch (action.type) {
case 'changeCharacter':
return {
...state,
selectedStoreId: action.storeId,
pinnedItems: {},
excludedItems: {},
lockedExoticHash: undefined,
};
case 'statFiltersChanged':
return { ...state, statFilters: action.statFilters };
case 'pinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
// Remove any previously locked item in that bucket and add this one
pinnedItems: {
...state.pinnedItems,
[bucketHash]: item,
},
// Locking an item clears excluded items in this bucket
excludedItems: {
...state.excludedItems,
[bucketHash]: undefined,
},
};
}
case 'setPinnedItems': {
const { items } = action;
return {
...state,
pinnedItems: _.keyBy(items, (i) => i.bucket.hash),
excludedItems: {},
};
}
case 'unpinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
pinnedItems: {
...state.pinnedItems,
[bucketHash]: undefined,
},
};
}
case 'excludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
if (state.excludedItems[bucketHash]?.some((i) => i.id === item.id)) {
return state; // item's already there
}
const existingExcluded = state.excludedItems[bucketHash] ?? [];
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: [...existingExcluded, item],
},
};
}
case 'unexcludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
const newExcluded = (state.excludedItems[bucketHash] ?? []).filter((i) => i.id !== item.id);
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: newExcluded.length > 0 ? newExcluded : undefined,
},
};
}
case 'lockedModsChanged': {
return {
...state,
lockedMods: action.lockedMods,
};
}
case 'sortOrderChanged': {
return {
...state,
statOrder: action.sortOrder,
};
}
case 'lockItemEnergyTypeChanged': {
return {
...state,
lockItemEnergyType: action.lockItemEnergyType,
};
}
case 'upgradeSpendTierChanged': {
return {
...state,
upgradeSpendTier: action.upgradeSpendTier,
};
}
case 'addGeneralMods': {
let currentGeneralModsCount = state.lockedMods.filter(
(mod) => mod.plug.plugCategoryHash === armor2PlugCategoryHashesByName.general
).length;
const newMods = [...state.lockedMods];
const failures: string[] = [];
for (const mod of action.mods) {
if (currentGeneralModsCount < 5) {
newMods.push(mod);
currentGeneralModsCount++;
} else {
failures.push(mod.displayProperties.name);
}
}
if (failures.length) {
showNotification({
title: t('LoadoutBuilder.UnableToAddAllMods'),
body: t('LoadoutBuilder.UnableToAddAllModsBody', { mods: failures.join(', ') }),
type: 'warning',
});
}
return {
...state,
lockedMods: newMods,
};
}
case 'removeLockedMod': {
const indexToRemove = state.lockedMods.findIndex((mod) => mod.hash === action.mod.hash);
const newMods = [...state.lockedMods];
newMods.splice(indexToRemove, 1);
return {
...state,
lockedMods: newMods,
};
}
case 'lockExotic': {
const { lockedExoticHash } = action;
return { ...state, lockedExoticHash };
}
case 'removeLockedExotic': {
return { ...state, lockedExoticHash: undefined };
}
case 'openModPicker':
return {
...state,
modPicker: {
open: true,
initialQuery: action.initialQuery,
},
};
case 'closeModPicker':
return { ...state, modPicker: { open: false } };
case 'openCompareDrawer':
return { ...state, compareSet: action.set };
case 'closeCompareDrawer':
return { ...state, compareSet: undefined };
}
} | identifier_body |
loadout-builder-reducer.ts | import {
defaultLoadoutParameters,
LoadoutParameters,
UpgradeSpendTier,
} from '@destinyitemmanager/dim-api-types';
import { D2ManifestDefinitions } from 'app/destiny2/d2-definitions';
import { t } from 'app/i18next-t';
import { DimItem, PluggableInventoryItemDefinition } from 'app/inventory/item-types';
import { DimStore } from 'app/inventory/store-types';
import { getCurrentStore, getItemAcrossStores } from 'app/inventory/stores-helpers';
import { Loadout } from 'app/loadout-drawer/loadout-types';
import { showNotification } from 'app/notifications/notifications';
import { armor2PlugCategoryHashesByName } from 'app/search/d2-known-values';
import { DestinyClass } from 'bungie-api-ts/destiny2';
import _ from 'lodash';
import { useReducer } from 'react';
import { isLoadoutBuilderItem } from '../loadout/item-utils';
import {
lockedModsFromLoadoutParameters,
statFiltersFromLoadoutParamaters,
statOrderFromLoadoutParameters,
} from './loadout-params';
import { ArmorSet, ArmorStatHashes, ExcludedItems, PinnedItems, StatFilters } from './types';
export interface LoadoutBuilderState {
statOrder: ArmorStatHashes[]; // stat hashes, including disabled stats
upgradeSpendTier: UpgradeSpendTier;
lockItemEnergyType: boolean;
pinnedItems: PinnedItems;
excludedItems: ExcludedItems;
lockedMods: PluggableInventoryItemDefinition[];
lockedExoticHash?: number;
selectedStoreId?: string;
statFilters: Readonly<StatFilters>;
modPicker: {
open: boolean;
initialQuery?: string;
};
compareSet?: ArmorSet;
}
function warnMissingClass(classType: DestinyClass, defs: D2ManifestDefinitions) {
const missingClassName = Object.values(defs.Class).find((c) => c.classType === classType)!
.displayProperties.name;
showNotification({
type: 'error',
title: t('LoadoutBuilder.MissingClass', { className: missingClassName }),
body: t('LoadoutBuilder.MissingClassDescription'),
});
}
const lbStateInit = ({
stores,
preloadedLoadout,
initialLoadoutParameters,
classType,
defs,
}: {
stores: DimStore[];
preloadedLoadout?: Loadout;
initialLoadoutParameters: LoadoutParameters;
classType: DestinyClass | undefined;
defs: D2ManifestDefinitions;
}): LoadoutBuilderState => {
const pinnedItems: PinnedItems = {};
const matchingClass =
classType !== undefined ? stores.find((store) => store.classType === classType) : undefined;
if (classType !== undefined && !matchingClass) {
warnMissingClass(classType, defs);
// Take out the exotic
initialLoadoutParameters = { ...initialLoadoutParameters, exoticArmorHash: undefined };
}
let selectedStoreId = (matchingClass ?? getCurrentStore(stores)!).id;
let loadoutParams = initialLoadoutParameters;
if (stores.length && preloadedLoadout) |
const statOrder = statOrderFromLoadoutParameters(loadoutParams);
const statFilters = statFiltersFromLoadoutParamaters(loadoutParams);
const lockedMods = lockedModsFromLoadoutParameters(loadoutParams, defs);
const lockItemEnergyType = Boolean(loadoutParams?.lockItemEnergyType);
// We need to handle the deprecated case
const upgradeSpendTier =
loadoutParams.upgradeSpendTier === UpgradeSpendTier.AscendantShardsLockEnergyType
? UpgradeSpendTier.Nothing
: loadoutParams.upgradeSpendTier!;
const lockedExoticHash = loadoutParams.exoticArmorHash;
return {
lockItemEnergyType,
upgradeSpendTier,
statOrder,
pinnedItems,
excludedItems: [],
statFilters,
lockedMods,
lockedExoticHash,
selectedStoreId,
modPicker: {
open: false,
},
};
};
export type LoadoutBuilderAction =
| { type: 'changeCharacter'; storeId: string }
| { type: 'statFiltersChanged'; statFilters: LoadoutBuilderState['statFilters'] }
| { type: 'sortOrderChanged'; sortOrder: LoadoutBuilderState['statOrder'] }
| {
type: 'lockItemEnergyTypeChanged';
lockItemEnergyType: LoadoutBuilderState['lockItemEnergyType'];
}
| { type: 'upgradeSpendTierChanged'; upgradeSpendTier: LoadoutBuilderState['upgradeSpendTier'] }
| { type: 'pinItem'; item: DimItem }
| { type: 'setPinnedItems'; items: DimItem[] }
| { type: 'unpinItem'; item: DimItem }
| { type: 'excludeItem'; item: DimItem }
| { type: 'unexcludeItem'; item: DimItem }
| {
type: 'lockedModsChanged';
lockedMods: PluggableInventoryItemDefinition[];
}
| { type: 'removeLockedMod'; mod: PluggableInventoryItemDefinition }
| { type: 'addGeneralMods'; mods: PluggableInventoryItemDefinition[] }
| { type: 'lockExotic'; lockedExoticHash: number }
| { type: 'removeLockedExotic' }
| { type: 'openModPicker'; initialQuery?: string }
| { type: 'closeModPicker' }
| { type: 'openCompareDrawer'; set: ArmorSet }
| { type: 'closeCompareDrawer' };
// TODO: Move more logic inside the reducer
function lbStateReducer(
state: LoadoutBuilderState,
action: LoadoutBuilderAction
): LoadoutBuilderState {
switch (action.type) {
case 'changeCharacter':
return {
...state,
selectedStoreId: action.storeId,
pinnedItems: {},
excludedItems: {},
lockedExoticHash: undefined,
};
case 'statFiltersChanged':
return { ...state, statFilters: action.statFilters };
case 'pinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
// Remove any previously locked item in that bucket and add this one
pinnedItems: {
...state.pinnedItems,
[bucketHash]: item,
},
// Locking an item clears excluded items in this bucket
excludedItems: {
...state.excludedItems,
[bucketHash]: undefined,
},
};
}
case 'setPinnedItems': {
const { items } = action;
return {
...state,
pinnedItems: _.keyBy(items, (i) => i.bucket.hash),
excludedItems: {},
};
}
case 'unpinItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
return {
...state,
pinnedItems: {
...state.pinnedItems,
[bucketHash]: undefined,
},
};
}
case 'excludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
if (state.excludedItems[bucketHash]?.some((i) => i.id === item.id)) {
return state; // item's already there
}
const existingExcluded = state.excludedItems[bucketHash] ?? [];
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: [...existingExcluded, item],
},
};
}
case 'unexcludeItem': {
const { item } = action;
const bucketHash = item.bucket.hash;
const newExcluded = (state.excludedItems[bucketHash] ?? []).filter((i) => i.id !== item.id);
return {
...state,
excludedItems: {
...state.excludedItems,
[bucketHash]: newExcluded.length > 0 ? newExcluded : undefined,
},
};
}
case 'lockedModsChanged': {
return {
...state,
lockedMods: action.lockedMods,
};
}
case 'sortOrderChanged': {
return {
...state,
statOrder: action.sortOrder,
};
}
case 'lockItemEnergyTypeChanged': {
return {
...state,
lockItemEnergyType: action.lockItemEnergyType,
};
}
case 'upgradeSpendTierChanged': {
return {
...state,
upgradeSpendTier: action.upgradeSpendTier,
};
}
case 'addGeneralMods': {
let currentGeneralModsCount = state.lockedMods.filter(
(mod) => mod.plug.plugCategoryHash === armor2PlugCategoryHashesByName.general
).length;
const newMods = [...state.lockedMods];
const failures: string[] = [];
for (const mod of action.mods) {
if (currentGeneralModsCount < 5) {
newMods.push(mod);
currentGeneralModsCount++;
} else {
failures.push(mod.displayProperties.name);
}
}
if (failures.length) {
showNotification({
title: t('LoadoutBuilder.UnableToAddAllMods'),
body: t('LoadoutBuilder.UnableToAddAllModsBody', { mods: failures.join(', ') }),
type: 'warning',
});
}
return {
...state,
lockedMods: newMods,
};
}
case 'removeLockedMod': {
const indexToRemove = state.lockedMods.findIndex((mod) => mod.hash === action.mod.hash);
const newMods = [...state.lockedMods];
newMods.splice(indexToRemove, 1);
return {
...state,
lockedMods: newMods,
};
}
case 'lockExotic': {
const { lockedExoticHash } = action;
return { ...state, lockedExoticHash };
}
case 'removeLockedExotic': {
return { ...state, lockedExoticHash: undefined };
}
case 'openModPicker':
return {
...state,
modPicker: {
open: true,
initialQuery: action.initialQuery,
},
};
case 'closeModPicker':
return { ...state, modPicker: { open: false } };
case 'openCompareDrawer':
return { ...state, compareSet: action.set };
case 'closeCompareDrawer':
return { ...state, compareSet: undefined };
}
}
export function useLbState(
stores: DimStore[],
preloadedLoadout: Loadout | undefined,
classType: DestinyClass | undefined,
initialLoadoutParameters: LoadoutParameters,
defs: D2ManifestDefinitions
) {
return useReducer(
lbStateReducer,
{ stores, preloadedLoadout, initialLoadoutParameters, defs, classType },
lbStateInit
);
}
| {
const loadoutStore = stores.find((store) => store.classType === preloadedLoadout.classType);
if (!loadoutStore) {
warnMissingClass(preloadedLoadout.classType, defs);
} else {
selectedStoreId = loadoutStore.id;
// TODO: instead of locking items, show the loadout fixed at the top to compare against and leave all items free
for (const loadoutItem of preloadedLoadout.items) {
if (loadoutItem.equipped) {
const item = getItemAcrossStores(stores, loadoutItem);
if (item && isLoadoutBuilderItem(item)) {
pinnedItems[item.bucket.hash] = item;
}
}
}
// Load all parameters from the loadout if we can
if (preloadedLoadout.parameters) {
loadoutParams = { ...defaultLoadoutParameters, ...preloadedLoadout.parameters };
}
}
} | conditional_block |
config.rs | // Copyright 2019 Twitter, Inc.
// Licensed under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
use crate::common::*;
use clap::{App, Arg, ArgMatches};
use logger::*;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::net::SocketAddr;
use std::process;
use std::time::Duration;
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
pub const NAME: &str = env!("CARGO_PKG_NAME");
pub const DEFAULT_SAMPLE_RATE_HZ: f64 = 1.0;
pub const DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS: usize = 50;
pub const DEFAULT_MAX_SAMPLER_TIMEOUTS: usize = 5;
pub const DEFAULT_INTERVAL_SECONDS: usize = 60;
/// This struct contains the configuration of the agent.
#[derive(Clone)]
pub struct Config {
/// the latching interval for stats
interval: u64,
/// sample rate for counters in Hz
sample_rate: f64,
/// the sampler timeout
sampler_timeout: Duration,
/// maximum consecutive sampler timeouts
max_sampler_timeouts: usize,
/// the listen address for the stats port
listen: SocketAddr,
/// the logging level
loglevel: Level,
/// memcache instance to instrument
memcache: Option<SocketAddr>,
/// flags for enabled statistics subsystems
flags: Flags,
/// the number of cores on the host
cores: usize,
/// an optional file to log stats to
stats_log: Option<String>,
/// flag to indicate Mesos sidecar mode
sidecar: bool,
}
#[derive(Clone)]
/// `Flags` is a simple wrapper for a doubly-keyed `HashSet`
pub struct Flags {
data: HashMap<String, HashSet<String>>,
}
impl Flags {
/// Creates a new empty set of `Flags`
pub fn new() -> Self {
Self {
data: HashMap::new(),
}
}
/// Insert a `pkey`+`lkey` into the set
pub fn insert(&mut self, pkey: &str, lkey: &str) {
let mut entry = self.data.remove(pkey).unwrap_or_default();
entry.insert(lkey.to_owned());
self.data.insert(pkey.to_owned(), entry);
}
/// True if the set contains `pkey`+`lkey`
pub fn contains(&self, pkey: &str, lkey: &str) -> bool {
if let Some(entry) = self.data.get(pkey) {
entry.get(lkey).is_some()
} else {
false
}
}
/// True if the set contains the `pkey`
pub fn | (&self, pkey: &str) -> bool {
self.data.get(pkey).is_some()
}
/// Remove a `pkey`+`lkey`
pub fn remove(&mut self, pkey: &str, lkey: &str) {
if let Some(entry) = self.data.get_mut(pkey) {
entry.remove(lkey);
}
}
/// Remove the `pkey` and all `lkey`s under it
pub fn remove_pkey(&mut self, pkey: &str) {
self.data.remove(pkey);
}
}
impl Config {
/// parse command line options and return `Config`
pub fn new() -> Config {
let matches = App::new(NAME)
.version(VERSION)
.author("Brian Martin <bmartin@twitter.com>")
.about("high-resolution systems performance telemetry agent")
.arg(
Arg::with_name("listen")
.short("l")
.long("listen")
.required(true)
.takes_value(true)
.value_name("IP:PORT")
.help("Sets the listen address for metrics"),
)
.arg(
Arg::with_name("verbose")
.short("v")
.long("verbose")
.multiple(true)
.help("Increase verbosity by one level. Can be used more than once"),
)
.arg(
Arg::with_name("interval")
.long("interval")
.value_name("Seconds")
.help("Integration window duration and stats endpoint refresh time")
.takes_value(true),
)
.arg(
Arg::with_name("sample-rate")
.long("sample-rate")
.value_name("Hertz")
.help("Sets the sampling frequency for the counters")
.takes_value(true),
)
.arg(
Arg::with_name("sampler-timeout")
.long("sampler-timeout")
.value_name("MS")
.help("Sets the timeout for per-sampler execution")
.takes_value(true),
)
.arg(
Arg::with_name("max-sampler-timeouts")
.long("max-sampler-timeouts")
.value_name("MS")
.help("Sets the maximum number of consecutive sampler timeouts")
.takes_value(true),
)
.arg(
Arg::with_name("cpu")
.long("cpu")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from CPU subsystem"),
)
.arg(
Arg::with_name("disk")
.long("disk")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Disk subsystem"),
)
.arg(
Arg::with_name("ebpf")
.long("ebpf")
.takes_value(true)
.multiple(true)
.possible_value("all")
.possible_value("block")
.possible_value("ext4")
.possible_value("scheduler")
.possible_value("xfs")
.help("Enable statistics from eBPF"),
)
.arg(
Arg::with_name("network")
.long("network")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Network subsystem"),
)
.arg(
Arg::with_name("perf")
.long("perf")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.possible_value("per-cgroup")
.help("Enable statistics from Perf Events subsystem"),
)
.arg(
Arg::with_name("memcache")
.long("memcache")
.required(false)
.takes_value(true)
.value_name("IP:PORT")
.help("Connect to the given memcache server and produce stats"),
)
.arg(
Arg::with_name("stats-log")
.long("stats-log")
.required(false)
.takes_value(true)
.value_name("LOG FILE")
.help("Enable logging of stats to file"),
)
.arg(
Arg::with_name("sidecar")
.long("sidecar")
.required(false)
.help("Enables Mesos sidecar mode, instrumenting the container"),
)
.get_matches();
let listen = matches
.value_of("listen")
.unwrap()
.parse()
.unwrap_or_else(|_| {
println!("ERROR: listen address is malformed");
process::exit(1);
});
let memcache = if let Some(sock) = matches.value_of("memcache") {
let socket = sock.parse().unwrap_or_else(|_| {
println!("ERROR: memcache address is malformed");
process::exit(1);
});
Some(socket)
} else {
None
};
let sample_rate =
parse_float_arg(&matches, "sample-rate").unwrap_or(DEFAULT_SAMPLE_RATE_HZ);
let sampler_timeout = Duration::from_millis(
parse_numeric_arg(&matches, "sampler-timeout")
.unwrap_or(DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS) as u64,
);
let max_sampler_timeouts = parse_numeric_arg(&matches, "max-sampler-timeouts")
.unwrap_or(DEFAULT_MAX_SAMPLER_TIMEOUTS);
let interval = parse_numeric_arg(&matches, "interval").unwrap_or(DEFAULT_INTERVAL_SECONDS)
as u64
* SECOND;
let cores = hardware_threads().unwrap_or(1);
let mut stats_enabled = Flags::new();
for subsystem in &["cpu", "disk", "ebpf", "network", "perf"] {
if let Some(values) = matches.values_of(subsystem) {
let flags: Vec<&str> = values.collect();
for flag in flags {
stats_enabled.insert(subsystem, flag);
}
}
}
let loglevel = match matches.occurrences_of("verbose") {
0 => Level::Info,
1 => Level::Debug,
_ => Level::Trace,
};
let stats_log = matches
.value_of("stats-log")
.map(std::string::ToString::to_string);
let sidecar = matches.is_present("sidecar");
Config {
cores,
flags: stats_enabled,
sample_rate,
sampler_timeout,
max_sampler_timeouts,
interval,
listen,
loglevel,
memcache,
stats_log,
sidecar,
}
}
/// what interval should the stats library latch on
pub fn interval(&self) -> u64 {
self.interval
}
/// what frequency the stats should be sampled on
pub fn sample_rate(&self) -> f64 {
self.sample_rate
}
/// the timeout for sampler execution
pub fn sampler_timeout(&self) -> Duration {
self.sampler_timeout
}
/// maximum consecutive sampler timeouts
pub fn max_sampler_timeouts(&self) -> usize {
self.max_sampler_timeouts
}
/// get listen address
pub fn listen(&self) -> SocketAddr {
self.listen
}
/// get log level
pub fn loglevel(&self) -> Level {
self.loglevel
}
/// how many cores on the host?
pub fn cores(&self) -> usize {
self.cores
}
pub fn memcache(&self) -> Option<SocketAddr> {
self.memcache
}
/// is a flag enabled for a subsystem?
pub fn is_enabled(&self, subsystem: &str, flag: &str) -> bool {
self.flags.contains(subsystem, flag)
}
pub fn is_subsystem_enabled(&self, subsystem: &str) -> bool {
self.flags.contains_pkey(subsystem)
}
pub fn stats_log(&self) -> Option<String> {
self.stats_log.clone()
}
}
/// a helper function to parse a numeric argument by name from `ArgMatches`
fn parse_numeric_arg(matches: &ArgMatches, key: &str) -> Option<usize> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1);
})
})
}
/// a helper function to parse a floating point argument by name from `ArgMatches`
fn parse_float_arg(matches: &ArgMatches, key: &str) -> Option<f64> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1);
})
})
}
/// helper function to discover the number of hardware threads
pub fn hardware_threads() -> Result<usize, ()> {
let path = "/sys/devices/system/cpu/present";
let f = File::open(path).map_err(|e| error!("failed to open file ({:?}): {}", path, e))?;
let mut f = BufReader::new(f);
let mut line = String::new();
f.read_line(&mut line)
.map_err(|_| error!("failed to read line"))?;
let line = line.trim();
let a: Vec<&str> = line.split('-').collect();
a.last()
.unwrap_or(&"0")
.parse::<usize>()
.map_err(|e| error!("could not parse num cpus from file ({:?}): {}", path, e))
.map(|i| i + 1)
}
| contains_pkey | identifier_name |
config.rs | // Copyright 2019 Twitter, Inc.
// Licensed under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
use crate::common::*;
use clap::{App, Arg, ArgMatches};
use logger::*;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::net::SocketAddr;
use std::process;
use std::time::Duration;
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
pub const NAME: &str = env!("CARGO_PKG_NAME");
pub const DEFAULT_SAMPLE_RATE_HZ: f64 = 1.0;
pub const DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS: usize = 50;
pub const DEFAULT_MAX_SAMPLER_TIMEOUTS: usize = 5;
pub const DEFAULT_INTERVAL_SECONDS: usize = 60;
/// This struct contains the configuration of the agent.
#[derive(Clone)]
pub struct Config {
/// the latching interval for stats
interval: u64,
/// sample rate for counters in Hz
sample_rate: f64,
/// the sampler timeout
sampler_timeout: Duration,
/// maximum consecutive sampler timeouts
max_sampler_timeouts: usize,
/// the listen address for the stats port
listen: SocketAddr,
/// the logging level
loglevel: Level,
/// memcache instance to instrument
memcache: Option<SocketAddr>,
/// flags for enabled statistics subsystems
flags: Flags,
/// the number of cores on the host
cores: usize,
/// an optional file to log stats to
stats_log: Option<String>,
/// flag to indicate Mesos sidecar mode
sidecar: bool,
}
#[derive(Clone)]
/// `Flags` is a simple wrapper for a doubly-keyed `HashSet`
pub struct Flags {
data: HashMap<String, HashSet<String>>,
}
impl Flags {
/// Creates a new empty set of `Flags`
pub fn new() -> Self {
Self {
data: HashMap::new(),
}
}
/// Insert a `pkey`+`lkey` into the set
pub fn insert(&mut self, pkey: &str, lkey: &str) {
let mut entry = self.data.remove(pkey).unwrap_or_default();
entry.insert(lkey.to_owned());
self.data.insert(pkey.to_owned(), entry);
}
/// True if the set contains `pkey`+`lkey`
pub fn contains(&self, pkey: &str, lkey: &str) -> bool {
if let Some(entry) = self.data.get(pkey) {
entry.get(lkey).is_some()
} else {
false
}
}
/// True if the set contains the `pkey`
pub fn contains_pkey(&self, pkey: &str) -> bool {
self.data.get(pkey).is_some()
}
/// Remove a `pkey`+`lkey`
pub fn remove(&mut self, pkey: &str, lkey: &str) {
if let Some(entry) = self.data.get_mut(pkey) {
entry.remove(lkey);
}
}
/// Remove the `pkey` and all `lkey`s under it
pub fn remove_pkey(&mut self, pkey: &str) {
self.data.remove(pkey);
}
}
impl Config {
/// parse command line options and return `Config`
pub fn new() -> Config {
let matches = App::new(NAME)
.version(VERSION)
.author("Brian Martin <bmartin@twitter.com>")
.about("high-resolution systems performance telemetry agent")
.arg(
Arg::with_name("listen")
.short("l")
.long("listen")
.required(true)
.takes_value(true)
.value_name("IP:PORT")
.help("Sets the listen address for metrics"),
)
.arg(
Arg::with_name("verbose")
.short("v")
.long("verbose")
.multiple(true)
.help("Increase verbosity by one level. Can be used more than once"),
)
.arg(
Arg::with_name("interval")
.long("interval")
.value_name("Seconds")
.help("Integration window duration and stats endpoint refresh time")
.takes_value(true),
)
.arg(
Arg::with_name("sample-rate")
.long("sample-rate")
.value_name("Hertz")
.help("Sets the sampling frequency for the counters")
.takes_value(true),
)
.arg(
Arg::with_name("sampler-timeout")
.long("sampler-timeout")
.value_name("MS")
.help("Sets the timeout for per-sampler execution")
.takes_value(true),
)
.arg(
Arg::with_name("max-sampler-timeouts")
.long("max-sampler-timeouts")
.value_name("MS")
.help("Sets the maximum number of consecutive sampler timeouts")
.takes_value(true),
)
.arg(
Arg::with_name("cpu")
.long("cpu")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from CPU subsystem"),
)
.arg(
Arg::with_name("disk")
.long("disk")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Disk subsystem"),
)
.arg(
Arg::with_name("ebpf")
.long("ebpf")
.takes_value(true)
.multiple(true)
.possible_value("all")
.possible_value("block")
.possible_value("ext4")
.possible_value("scheduler")
.possible_value("xfs")
.help("Enable statistics from eBPF"),
)
.arg(
Arg::with_name("network")
.long("network")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Network subsystem"),
)
.arg(
Arg::with_name("perf")
.long("perf")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.possible_value("per-cgroup")
.help("Enable statistics from Perf Events subsystem"),
)
.arg(
Arg::with_name("memcache")
.long("memcache")
.required(false)
.takes_value(true)
.value_name("IP:PORT")
.help("Connect to the given memcache server and produce stats"),
)
.arg(
Arg::with_name("stats-log")
.long("stats-log")
.required(false)
.takes_value(true)
.value_name("LOG FILE")
.help("Enable logging of stats to file"),
)
.arg(
Arg::with_name("sidecar")
.long("sidecar")
.required(false)
.help("Enables Mesos sidecar mode, instrumenting the container"),
)
.get_matches();
let listen = matches
.value_of("listen")
.unwrap()
.parse()
.unwrap_or_else(|_| {
println!("ERROR: listen address is malformed");
process::exit(1);
});
let memcache = if let Some(sock) = matches.value_of("memcache") {
let socket = sock.parse().unwrap_or_else(|_| {
println!("ERROR: memcache address is malformed");
process::exit(1);
});
Some(socket)
} else {
None
};
let sample_rate =
parse_float_arg(&matches, "sample-rate").unwrap_or(DEFAULT_SAMPLE_RATE_HZ);
let sampler_timeout = Duration::from_millis(
parse_numeric_arg(&matches, "sampler-timeout")
.unwrap_or(DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS) as u64,
);
let max_sampler_timeouts = parse_numeric_arg(&matches, "max-sampler-timeouts")
.unwrap_or(DEFAULT_MAX_SAMPLER_TIMEOUTS);
let interval = parse_numeric_arg(&matches, "interval").unwrap_or(DEFAULT_INTERVAL_SECONDS)
as u64
* SECOND;
let cores = hardware_threads().unwrap_or(1);
let mut stats_enabled = Flags::new();
for subsystem in &["cpu", "disk", "ebpf", "network", "perf"] {
if let Some(values) = matches.values_of(subsystem) {
let flags: Vec<&str> = values.collect();
for flag in flags {
stats_enabled.insert(subsystem, flag);
}
}
}
let loglevel = match matches.occurrences_of("verbose") {
0 => Level::Info,
1 => Level::Debug,
_ => Level::Trace,
};
let stats_log = matches
.value_of("stats-log")
.map(std::string::ToString::to_string);
let sidecar = matches.is_present("sidecar");
Config {
cores,
flags: stats_enabled,
sample_rate,
sampler_timeout,
max_sampler_timeouts,
interval,
listen,
loglevel,
memcache,
stats_log,
sidecar,
}
}
/// what interval should the stats library latch on
pub fn interval(&self) -> u64 {
self.interval
}
/// what frequency the stats should be sampled on
pub fn sample_rate(&self) -> f64 |
/// the timeout for sampler execution
pub fn sampler_timeout(&self) -> Duration {
self.sampler_timeout
}
/// maximum consecutive sampler timeouts
pub fn max_sampler_timeouts(&self) -> usize {
self.max_sampler_timeouts
}
/// get listen address
pub fn listen(&self) -> SocketAddr {
self.listen
}
/// get log level
pub fn loglevel(&self) -> Level {
self.loglevel
}
/// how many cores on the host?
pub fn cores(&self) -> usize {
self.cores
}
pub fn memcache(&self) -> Option<SocketAddr> {
self.memcache
}
/// is a flag enabled for a subsystem?
pub fn is_enabled(&self, subsystem: &str, flag: &str) -> bool {
self.flags.contains(subsystem, flag)
}
pub fn is_subsystem_enabled(&self, subsystem: &str) -> bool {
self.flags.contains_pkey(subsystem)
}
pub fn stats_log(&self) -> Option<String> {
self.stats_log.clone()
}
}
/// a helper function to parse a numeric argument by name from `ArgMatches`
fn parse_numeric_arg(matches: &ArgMatches, key: &str) -> Option<usize> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1);
})
})
}
/// a helper function to parse a floating point argument by name from `ArgMatches`
fn parse_float_arg(matches: &ArgMatches, key: &str) -> Option<f64> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1);
})
})
}
/// helper function to discover the number of hardware threads
pub fn hardware_threads() -> Result<usize, ()> {
let path = "/sys/devices/system/cpu/present";
let f = File::open(path).map_err(|e| error!("failed to open file ({:?}): {}", path, e))?;
let mut f = BufReader::new(f);
let mut line = String::new();
f.read_line(&mut line)
.map_err(|_| error!("failed to read line"))?;
let line = line.trim();
let a: Vec<&str> = line.split('-').collect();
a.last()
.unwrap_or(&"0")
.parse::<usize>()
.map_err(|e| error!("could not parse num cpus from file ({:?}): {}", path, e))
.map(|i| i + 1)
}
| {
self.sample_rate
} | identifier_body |
config.rs | // Copyright 2019 Twitter, Inc.
// Licensed under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
use crate::common::*;
use clap::{App, Arg, ArgMatches};
use logger::*;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::net::SocketAddr;
use std::process;
use std::time::Duration;
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
pub const NAME: &str = env!("CARGO_PKG_NAME");
pub const DEFAULT_SAMPLE_RATE_HZ: f64 = 1.0;
pub const DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS: usize = 50;
pub const DEFAULT_MAX_SAMPLER_TIMEOUTS: usize = 5;
pub const DEFAULT_INTERVAL_SECONDS: usize = 60;
/// This struct contains the configuration of the agent.
#[derive(Clone)]
pub struct Config {
/// the latching interval for stats
interval: u64,
/// sample rate for counters in Hz
sample_rate: f64,
/// the sampler timeout
sampler_timeout: Duration,
/// maximum consecutive sampler timeouts
max_sampler_timeouts: usize,
/// the listen address for the stats port
listen: SocketAddr,
/// the logging level
loglevel: Level,
/// memcache instance to instrument
memcache: Option<SocketAddr>,
/// flags for enabled statistics subsystems
flags: Flags,
/// the number of cores on the host
cores: usize,
/// an optional file to log stats to
stats_log: Option<String>,
/// flag to indicate Mesos sidecar mode
sidecar: bool,
}
#[derive(Clone)]
/// `Flags` is a simple wrapper for a doubly-keyed `HashSet`
pub struct Flags {
data: HashMap<String, HashSet<String>>,
}
impl Flags {
/// Creates a new empty set of `Flags`
pub fn new() -> Self {
Self {
data: HashMap::new(),
}
}
/// Insert a `pkey`+`lkey` into the set
pub fn insert(&mut self, pkey: &str, lkey: &str) {
let mut entry = self.data.remove(pkey).unwrap_or_default();
entry.insert(lkey.to_owned());
self.data.insert(pkey.to_owned(), entry);
}
/// True if the set contains `pkey`+`lkey`
pub fn contains(&self, pkey: &str, lkey: &str) -> bool {
if let Some(entry) = self.data.get(pkey) {
entry.get(lkey).is_some()
} else {
false
}
}
/// True if the set contains the `pkey`
pub fn contains_pkey(&self, pkey: &str) -> bool {
self.data.get(pkey).is_some()
}
/// Remove a `pkey`+`lkey`
pub fn remove(&mut self, pkey: &str, lkey: &str) {
if let Some(entry) = self.data.get_mut(pkey) {
entry.remove(lkey);
}
}
/// Remove the `pkey` and all `lkey`s under it
pub fn remove_pkey(&mut self, pkey: &str) {
self.data.remove(pkey);
}
}
impl Config {
/// parse command line options and return `Config`
pub fn new() -> Config {
let matches = App::new(NAME)
.version(VERSION)
.author("Brian Martin <bmartin@twitter.com>")
.about("high-resolution systems performance telemetry agent")
.arg(
Arg::with_name("listen")
.short("l")
.long("listen")
.required(true)
.takes_value(true)
.value_name("IP:PORT")
.help("Sets the listen address for metrics"),
)
.arg(
Arg::with_name("verbose")
.short("v")
.long("verbose")
.multiple(true)
.help("Increase verbosity by one level. Can be used more than once"),
)
.arg(
Arg::with_name("interval")
.long("interval")
.value_name("Seconds")
.help("Integration window duration and stats endpoint refresh time")
.takes_value(true),
)
.arg(
Arg::with_name("sample-rate")
.long("sample-rate")
.value_name("Hertz")
.help("Sets the sampling frequency for the counters")
.takes_value(true),
)
.arg(
Arg::with_name("sampler-timeout")
.long("sampler-timeout")
.value_name("MS")
.help("Sets the timeout for per-sampler execution")
.takes_value(true),
)
.arg(
Arg::with_name("max-sampler-timeouts")
.long("max-sampler-timeouts")
.value_name("MS")
.help("Sets the maximum number of consecutive sampler timeouts")
.takes_value(true),
)
.arg(
Arg::with_name("cpu")
.long("cpu")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from CPU subsystem"),
)
.arg(
Arg::with_name("disk")
.long("disk")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Disk subsystem"),
)
.arg(
Arg::with_name("ebpf")
.long("ebpf")
.takes_value(true)
.multiple(true)
.possible_value("all")
.possible_value("block")
.possible_value("ext4")
.possible_value("scheduler")
.possible_value("xfs")
.help("Enable statistics from eBPF"),
)
.arg(
Arg::with_name("network")
.long("network")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Network subsystem"),
)
.arg(
Arg::with_name("perf")
.long("perf")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.possible_value("per-cgroup")
.help("Enable statistics from Perf Events subsystem"),
)
.arg(
Arg::with_name("memcache")
.long("memcache")
.required(false)
.takes_value(true)
.value_name("IP:PORT")
.help("Connect to the given memcache server and produce stats"),
)
.arg(
Arg::with_name("stats-log")
.long("stats-log")
.required(false)
.takes_value(true)
.value_name("LOG FILE")
.help("Enable logging of stats to file"),
)
.arg(
Arg::with_name("sidecar")
.long("sidecar")
.required(false)
.help("Enables Mesos sidecar mode, instrumenting the container"),
)
.get_matches();
let listen = matches
.value_of("listen")
.unwrap()
.parse()
.unwrap_or_else(|_| {
println!("ERROR: listen address is malformed");
process::exit(1);
});
let memcache = if let Some(sock) = matches.value_of("memcache") | else {
None
};
let sample_rate =
parse_float_arg(&matches, "sample-rate").unwrap_or(DEFAULT_SAMPLE_RATE_HZ);
let sampler_timeout = Duration::from_millis(
parse_numeric_arg(&matches, "sampler-timeout")
.unwrap_or(DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS) as u64,
);
let max_sampler_timeouts = parse_numeric_arg(&matches, "max-sampler-timeouts")
.unwrap_or(DEFAULT_MAX_SAMPLER_TIMEOUTS);
let interval = parse_numeric_arg(&matches, "interval").unwrap_or(DEFAULT_INTERVAL_SECONDS)
as u64
* SECOND;
let cores = hardware_threads().unwrap_or(1);
let mut stats_enabled = Flags::new();
for subsystem in &["cpu", "disk", "ebpf", "network", "perf"] {
if let Some(values) = matches.values_of(subsystem) {
let flags: Vec<&str> = values.collect();
for flag in flags {
stats_enabled.insert(subsystem, flag);
}
}
}
let loglevel = match matches.occurrences_of("verbose") {
0 => Level::Info,
1 => Level::Debug,
_ => Level::Trace,
};
let stats_log = matches
.value_of("stats-log")
.map(std::string::ToString::to_string);
let sidecar = matches.is_present("sidecar");
Config {
cores,
flags: stats_enabled,
sample_rate,
sampler_timeout,
max_sampler_timeouts,
interval,
listen,
loglevel,
memcache,
stats_log,
sidecar,
}
}
/// what interval should the stats library latch on
pub fn interval(&self) -> u64 {
self.interval
}
/// what frequency the stats should be sampled on
pub fn sample_rate(&self) -> f64 {
self.sample_rate
}
/// the timeout for sampler execution
pub fn sampler_timeout(&self) -> Duration {
self.sampler_timeout
}
/// maximum consecutive sampler timeouts
pub fn max_sampler_timeouts(&self) -> usize {
self.max_sampler_timeouts
}
/// get listen address
pub fn listen(&self) -> SocketAddr {
self.listen
}
/// get log level
pub fn loglevel(&self) -> Level {
self.loglevel
}
/// how many cores on the host?
pub fn cores(&self) -> usize {
self.cores
}
pub fn memcache(&self) -> Option<SocketAddr> {
self.memcache
}
/// is a flag enabled for a subsystem?
pub fn is_enabled(&self, subsystem: &str, flag: &str) -> bool {
self.flags.contains(subsystem, flag)
}
pub fn is_subsystem_enabled(&self, subsystem: &str) -> bool {
self.flags.contains_pkey(subsystem)
}
pub fn stats_log(&self) -> Option<String> {
self.stats_log.clone()
}
}
/// a helper function to parse a numeric argument by name from `ArgMatches`
fn parse_numeric_arg(matches: &ArgMatches, key: &str) -> Option<usize> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1);
})
})
}
/// a helper function to parse a floating point argument by name from `ArgMatches`
fn parse_float_arg(matches: &ArgMatches, key: &str) -> Option<f64> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1);
})
})
}
/// helper function to discover the number of hardware threads
pub fn hardware_threads() -> Result<usize, ()> {
let path = "/sys/devices/system/cpu/present";
let f = File::open(path).map_err(|e| error!("failed to open file ({:?}): {}", path, e))?;
let mut f = BufReader::new(f);
let mut line = String::new();
f.read_line(&mut line)
.map_err(|_| error!("failed to read line"))?;
let line = line.trim();
let a: Vec<&str> = line.split('-').collect();
a.last()
.unwrap_or(&"0")
.parse::<usize>()
.map_err(|e| error!("could not parse num cpus from file ({:?}): {}", path, e))
.map(|i| i + 1)
}
| {
let socket = sock.parse().unwrap_or_else(|_| {
println!("ERROR: memcache address is malformed");
process::exit(1);
});
Some(socket)
} | conditional_block |
config.rs | // Copyright 2019 Twitter, Inc.
// Licensed under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
use crate::common::*;
use clap::{App, Arg, ArgMatches};
use logger::*;
use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::net::SocketAddr;
use std::process;
use std::time::Duration;
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
pub const NAME: &str = env!("CARGO_PKG_NAME");
pub const DEFAULT_SAMPLE_RATE_HZ: f64 = 1.0;
pub const DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS: usize = 50;
pub const DEFAULT_MAX_SAMPLER_TIMEOUTS: usize = 5;
pub const DEFAULT_INTERVAL_SECONDS: usize = 60;
/// This struct contains the configuration of the agent.
#[derive(Clone)]
pub struct Config {
/// the latching interval for stats
interval: u64,
/// sample rate for counters in Hz
sample_rate: f64,
/// the sampler timeout
sampler_timeout: Duration,
/// maximum consecutive sampler timeouts
max_sampler_timeouts: usize,
/// the listen address for the stats port
listen: SocketAddr,
/// the logging level
loglevel: Level,
/// memcache instance to instrument
memcache: Option<SocketAddr>,
/// flags for enabled statistics subsystems
flags: Flags,
/// the number of cores on the host
cores: usize,
/// an optional file to log stats to
stats_log: Option<String>,
/// flag to indicate Mesos sidecar mode
sidecar: bool,
}
#[derive(Clone)]
/// `Flags` is a simple wrapper for a doubly-keyed `HashSet`
pub struct Flags {
data: HashMap<String, HashSet<String>>,
}
impl Flags {
/// Creates a new empty set of `Flags`
pub fn new() -> Self {
Self {
data: HashMap::new(),
}
}
/// Insert a `pkey`+`lkey` into the set
pub fn insert(&mut self, pkey: &str, lkey: &str) {
let mut entry = self.data.remove(pkey).unwrap_or_default();
entry.insert(lkey.to_owned());
self.data.insert(pkey.to_owned(), entry);
}
/// True if the set contains `pkey`+`lkey`
pub fn contains(&self, pkey: &str, lkey: &str) -> bool {
if let Some(entry) = self.data.get(pkey) {
entry.get(lkey).is_some()
} else {
false
}
}
/// True if the set contains the `pkey`
pub fn contains_pkey(&self, pkey: &str) -> bool {
self.data.get(pkey).is_some()
}
/// Remove a `pkey`+`lkey`
pub fn remove(&mut self, pkey: &str, lkey: &str) {
if let Some(entry) = self.data.get_mut(pkey) {
entry.remove(lkey);
}
}
/// Remove the `pkey` and all `lkey`s under it
pub fn remove_pkey(&mut self, pkey: &str) {
self.data.remove(pkey);
}
}
impl Config {
/// parse command line options and return `Config`
pub fn new() -> Config {
let matches = App::new(NAME)
.version(VERSION)
.author("Brian Martin <bmartin@twitter.com>")
.about("high-resolution systems performance telemetry agent")
.arg(
Arg::with_name("listen")
.short("l")
.long("listen")
.required(true)
.takes_value(true)
.value_name("IP:PORT")
.help("Sets the listen address for metrics"),
)
.arg(
Arg::with_name("verbose")
.short("v")
.long("verbose")
.multiple(true)
.help("Increase verbosity by one level. Can be used more than once"),
)
.arg(
Arg::with_name("interval")
.long("interval")
.value_name("Seconds")
.help("Integration window duration and stats endpoint refresh time")
.takes_value(true),
)
.arg(
Arg::with_name("sample-rate")
.long("sample-rate")
.value_name("Hertz")
.help("Sets the sampling frequency for the counters")
.takes_value(true),
)
.arg(
Arg::with_name("sampler-timeout")
.long("sampler-timeout")
.value_name("MS")
.help("Sets the timeout for per-sampler execution")
.takes_value(true),
)
.arg(
Arg::with_name("max-sampler-timeouts")
.long("max-sampler-timeouts")
.value_name("MS")
.help("Sets the maximum number of consecutive sampler timeouts")
.takes_value(true),
)
.arg(
Arg::with_name("cpu")
.long("cpu")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from CPU subsystem"),
)
.arg(
Arg::with_name("disk")
.long("disk")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Disk subsystem"),
)
.arg(
Arg::with_name("ebpf")
.long("ebpf")
.takes_value(true)
.multiple(true)
.possible_value("all")
.possible_value("block")
.possible_value("ext4")
.possible_value("scheduler")
.possible_value("xfs")
.help("Enable statistics from eBPF"),
)
.arg(
Arg::with_name("network")
.long("network")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.help("Enable statistics from Network subsystem"),
)
.arg(
Arg::with_name("perf")
.long("perf")
.takes_value(true)
.multiple(true)
.possible_value("totals")
.possible_value("per-cgroup")
.help("Enable statistics from Perf Events subsystem"),
)
.arg(
Arg::with_name("memcache")
.long("memcache")
.required(false)
.takes_value(true)
.value_name("IP:PORT")
.help("Connect to the given memcache server and produce stats"),
)
.arg(
Arg::with_name("stats-log")
.long("stats-log")
.required(false)
.takes_value(true)
.value_name("LOG FILE")
.help("Enable logging of stats to file"),
)
.arg(
Arg::with_name("sidecar")
.long("sidecar")
.required(false)
.help("Enables Mesos sidecar mode, instrumenting the container"),
)
.get_matches();
let listen = matches
.value_of("listen")
.unwrap()
.parse()
.unwrap_or_else(|_| {
println!("ERROR: listen address is malformed");
process::exit(1);
});
let memcache = if let Some(sock) = matches.value_of("memcache") {
let socket = sock.parse().unwrap_or_else(|_| {
println!("ERROR: memcache address is malformed");
process::exit(1);
});
Some(socket)
} else {
None
};
let sample_rate =
parse_float_arg(&matches, "sample-rate").unwrap_or(DEFAULT_SAMPLE_RATE_HZ);
let sampler_timeout = Duration::from_millis(
parse_numeric_arg(&matches, "sampler-timeout")
.unwrap_or(DEFAULT_SAMPLER_TIMEOUT_MILLISECONDS) as u64,
);
let max_sampler_timeouts = parse_numeric_arg(&matches, "max-sampler-timeouts")
.unwrap_or(DEFAULT_MAX_SAMPLER_TIMEOUTS);
let interval = parse_numeric_arg(&matches, "interval").unwrap_or(DEFAULT_INTERVAL_SECONDS)
as u64
* SECOND;
let cores = hardware_threads().unwrap_or(1);
let mut stats_enabled = Flags::new();
for subsystem in &["cpu", "disk", "ebpf", "network", "perf"] {
if let Some(values) = matches.values_of(subsystem) {
let flags: Vec<&str> = values.collect();
for flag in flags {
stats_enabled.insert(subsystem, flag);
}
}
}
let loglevel = match matches.occurrences_of("verbose") {
0 => Level::Info,
1 => Level::Debug,
_ => Level::Trace,
};
let stats_log = matches
.value_of("stats-log")
.map(std::string::ToString::to_string);
let sidecar = matches.is_present("sidecar");
Config {
cores,
flags: stats_enabled,
sample_rate,
sampler_timeout,
max_sampler_timeouts,
interval,
listen,
loglevel,
memcache,
stats_log,
sidecar,
}
}
/// what interval should the stats library latch on
pub fn interval(&self) -> u64 {
self.interval
}
/// what frequency the stats should be sampled on
pub fn sample_rate(&self) -> f64 {
self.sample_rate
}
/// the timeout for sampler execution
pub fn sampler_timeout(&self) -> Duration {
self.sampler_timeout
}
/// maximum consecutive sampler timeouts
pub fn max_sampler_timeouts(&self) -> usize {
self.max_sampler_timeouts
}
/// get listen address
pub fn listen(&self) -> SocketAddr {
self.listen
}
/// get log level
pub fn loglevel(&self) -> Level {
self.loglevel
}
/// how many cores on the host?
pub fn cores(&self) -> usize {
self.cores
}
pub fn memcache(&self) -> Option<SocketAddr> {
self.memcache
}
/// is a flag enabled for a subsystem?
pub fn is_enabled(&self, subsystem: &str, flag: &str) -> bool {
self.flags.contains(subsystem, flag)
}
pub fn is_subsystem_enabled(&self, subsystem: &str) -> bool {
self.flags.contains_pkey(subsystem)
}
pub fn stats_log(&self) -> Option<String> {
self.stats_log.clone()
}
}
/// a helper function to parse a numeric argument by name from `ArgMatches`
fn parse_numeric_arg(matches: &ArgMatches, key: &str) -> Option<usize> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1);
})
})
}
/// a helper function to parse a floating point argument by name from `ArgMatches`
fn parse_float_arg(matches: &ArgMatches, key: &str) -> Option<f64> {
matches.value_of(key).map(|f| {
f.parse().unwrap_or_else(|_| {
println!("ERROR: could not parse {}", key);
process::exit(1); | }
/// helper function to discover the number of hardware threads
pub fn hardware_threads() -> Result<usize, ()> {
let path = "/sys/devices/system/cpu/present";
let f = File::open(path).map_err(|e| error!("failed to open file ({:?}): {}", path, e))?;
let mut f = BufReader::new(f);
let mut line = String::new();
f.read_line(&mut line)
.map_err(|_| error!("failed to read line"))?;
let line = line.trim();
let a: Vec<&str> = line.split('-').collect();
a.last()
.unwrap_or(&"0")
.parse::<usize>()
.map_err(|e| error!("could not parse num cpus from file ({:?}): {}", path, e))
.map(|i| i + 1)
} | })
}) | random_line_split |
tag.rs | //! Utilities and constants for OpenType tags.
//!
//! See also the [`tag!`](../macro.tag.html) macro for creating tags from a byte string.
use crate::error::ParseError;
use std::{fmt, str};
/// Generate a 4-byte OpenType tag from byte string
///
/// Example:
///
/// ```
/// use allsorts::tag;
/// assert_eq!(tag!(b"glyf"), 0x676C7966);
/// ```
#[macro_export]
macro_rules! tag {
($w:expr) => {
u32::from_be_bytes(*$w)
};
}
/// Wrapper type for a tag that implements `Display`
///
/// Example:
///
/// ```
/// use allsorts::tag::{self, DisplayTag};
///
/// // ASCII tag comes out as a string
/// assert_eq!(&DisplayTag(tag::NAME).to_string(), "name");
/// // Non-ASCII tag comes out as hex
/// assert_eq!(&DisplayTag(0x12345678).to_string(), "0x12345678");
///
/// println!("DisplayTag is handy for printing a tag: '{}'", DisplayTag(tag::CFF));
/// ```
#[derive(PartialEq, Eq, Clone, Copy)]
pub struct DisplayTag(pub u32);
pub fn from_string(s: &str) -> Result<u32, ParseError> {
if s.len() > 4 {
return Err(ParseError::BadValue);
}
let mut tag: u32 = 0;
let mut count = 0;
for c in s.chars() {
if !c.is_ascii() || c.is_ascii_control() {
return Err(ParseError::BadValue);
}
tag = (tag << 8) | (c as u32);
count += 1;
}
while count < 4 {
tag = (tag << 8) | (' ' as u32);
count += 1;
}
Ok(tag)
}
impl fmt::Display for DisplayTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let tag = self.0;
let bytes = tag.to_be_bytes();
if bytes.iter().all(|c| c.is_ascii() && !c.is_ascii_control()) {
let s = str::from_utf8(&bytes).unwrap(); // unwrap safe due to above check
s.fmt(f)
} else {
write!(f, "0x{:08x}", tag)
}
}
}
impl fmt::Debug for DisplayTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self, f)
}
}
/// `abvf`
pub const ABVF: u32 = tag!(b"abvf");
/// `abvm`
pub const ABVM: u32 = tag!(b"abvm");
/// `abvs`
pub const ABVS: u32 = tag!(b"abvs");
/// `acnt`
pub const ACNT: u32 = tag!(b"acnt");
/// `afrc`
pub const AFRC: u32 = tag!(b"afrc");
/// `akhn`
pub const AKHN: u32 = tag!(b"akhn");
/// `arab`
pub const ARAB: u32 = tag!(b"arab");
/// `avar`
pub const AVAR: u32 = tag!(b"avar");
/// `BASE`
pub const BASE: u32 = tag!(b"BASE");
/// `bdat`
pub const BDAT: u32 = tag!(b"bdat");
/// `beng`
pub const BENG: u32 = tag!(b"beng");
/// `bloc`
pub const BLOC: u32 = tag!(b"bloc");
/// `blwf`
pub const BLWF: u32 = tag!(b"blwf");
/// `blwm`
pub const BLWM: u32 = tag!(b"blwm");
/// `blws`
pub const BLWS: u32 = tag!(b"blws");
/// `bng2`
pub const BNG2: u32 = tag!(b"bng2");
/// `bsln`
pub const BSLN: u32 = tag!(b"bsln");
/// `c2sc`
pub const C2SC: u32 = tag!(b"c2sc");
/// `calt`
pub const CALT: u32 = tag!(b"calt");
/// `CBDT`
pub const CBDT: u32 = tag!(b"CBDT");
/// `CBLC`
pub const CBLC: u32 = tag!(b"CBLC");
/// `ccmp`
pub const CCMP: u32 = tag!(b"ccmp");
/// `cfar`
pub const CFAR: u32 = tag!(b"cfar");
/// `CFF `
pub const CFF: u32 = tag!(b"CFF ");
/// `cjct`
pub const CJCT: u32 = tag!(b"cjct");
/// `clig`
pub const CLIG: u32 = tag!(b"clig");
/// `cmap`
pub const CMAP: u32 = tag!(b"cmap");
/// `COLR`
pub const COLR: u32 = tag!(b"COLR");
/// `CPAL`
pub const CPAL: u32 = tag!(b"CPAL");
/// `curs`
pub const CURS: u32 = tag!(b"curs");
/// `cvar`
pub const CVAR: u32 = tag!(b"cvar");
/// `cvt `
pub const CVT: u32 = tag!(b"cvt ");
/// `cyrl`
pub const CYRL: u32 = tag!(b"cyrl");
/// `dev2`
pub const DEV2: u32 = tag!(b"dev2");
/// `deva`
pub const DEVA: u32 = tag!(b"deva");
/// `DFLT`
pub const DFLT: u32 = tag!(b"DFLT");
/// `dist`
pub const DIST: u32 = tag!(b"dist");
/// `dlig`
pub const DLIG: u32 = tag!(b"dlig");
/// `dupe`
pub const DUPE: u32 = tag!(b"dupe");
/// `EBDT`
pub const EBDT: u32 = tag!(b"EBDT");
/// `EBLC`
pub const EBLC: u32 = tag!(b"EBLC");
/// `EBSC`
pub const EBSC: u32 = tag!(b"EBSC");
/// `FAR `
pub const FAR: u32 = tag!(b"FAR ");
/// `fdsc`
pub const FDSC: u32 = tag!(b"fdsc");
/// `Feat`
pub const FEAT2: u32 = tag!(b"Feat");
/// `feat`
pub const FEAT: u32 = tag!(b"feat");
/// `fin2`
pub const FIN2: u32 = tag!(b"fin2");
/// `fin3`
pub const FIN3: u32 = tag!(b"fin3");
/// `fina`
pub const FINA: u32 = tag!(b"fina");
/// `fmtx`
pub const FMTX: u32 = tag!(b"fmtx");
/// `fpgm`
pub const FPGM: u32 = tag!(b"fpgm");
/// `frac`
pub const FRAC: u32 = tag!(b"frac");
/// `fvar`
pub const FVAR: u32 = tag!(b"fvar");
/// `gasp`
pub const GASP: u32 = tag!(b"gasp");
/// `GDEF`
pub const GDEF: u32 = tag!(b"GDEF");
/// `gjr2`
pub const GJR2: u32 = tag!(b"gjr2");
/// `Glat`
pub const GLAT: u32 = tag!(b"Glat");
/// `Gloc`
pub const GLOC: u32 = tag!(b"Gloc");
/// `glyf`
pub const GLYF: u32 = tag!(b"glyf");
/// `GPOS`
pub const GPOS: u32 = tag!(b"GPOS");
/// `grek`
pub const GREK: u32 = tag!(b"grek");
/// `GSUB`
pub const GSUB: u32 = tag!(b"GSUB");
/// `gujr`
pub const GUJR: u32 = tag!(b"gujr");
/// `gur2`
pub const GUR2: u32 = tag!(b"gur2");
/// `guru`
pub const GURU: u32 = tag!(b"guru");
/// `gvar`
pub const GVAR: u32 = tag!(b"gvar");
/// `half`
pub const HALF: u32 = tag!(b"half");
/// `haln`
pub const HALN: u32 = tag!(b"haln");
/// `hdmx`
pub const HDMX: u32 = tag!(b"hdmx");
/// `head`
pub const HEAD: u32 = tag!(b"head");
/// `hhea`
pub const HHEA: u32 = tag!(b"hhea");
/// `hlig`
pub const HLIG: u32 = tag!(b"hlig");
/// `hmtx`
pub const HMTX: u32 = tag!(b"hmtx");
/// `hsty`
pub const HSTY: u32 = tag!(b"hsty");
/// `init`
pub const INIT: u32 = tag!(b"init");
/// `isol`
pub const ISOL: u32 = tag!(b"isol");
/// `jpg `
pub const JPG: u32 = tag!(b"jpg ");
/// `JSTF`
pub const JSTF: u32 = tag!(b"JSTF");
/// `just`
pub const JUST: u32 = tag!(b"just");
/// `kern`
pub const KERN: u32 = tag!(b"kern");
/// `khmr`
pub const KHMR: u32 = tag!(b"khmr");
/// `knd2`
pub const KND2: u32 = tag!(b"knd2");
/// `knda`
pub const KNDA: u32 = tag!(b"knda");
/// `lao `
pub const LAO: u32 = tag!(b"lao ");
/// `latn`
pub const LATN: u32 = tag!(b"latn");
/// `lcar`
pub const LCAR: u32 = tag!(b"lcar");
/// `liga`
pub const LIGA: u32 = tag!(b"liga");
/// `lnum`
pub const LNUM: u32 = tag!(b"lnum");
/// `loca`
pub const LOCA: u32 = tag!(b"loca");
/// `locl`
pub const LOCL: u32 = tag!(b"locl");
/// `LTSH`
pub const LTSH: u32 = tag!(b"LTSH");
/// `mark`
pub const MARK: u32 = tag!(b"mark");
/// `MATH`
pub const MATH: u32 = tag!(b"MATH");
/// `maxp`
pub const MAXP: u32 = tag!(b"maxp");
/// `med2`
pub const MED2: u32 = tag!(b"med2");
/// `medi`
pub const MEDI: u32 = tag!(b"medi");
/// `mkmk`
pub const MKMK: u32 = tag!(b"mkmk");
/// `mlm2`
pub const MLM2: u32 = tag!(b"mlm2");
/// `mlym`
pub const MLYM: u32 = tag!(b"mlym");
/// `mort`
pub const MORT: u32 = tag!(b"mort");
/// `morx`
pub const MORX: u32 = tag!(b"morx");
/// `mset`
pub const MSET: u32 = tag!(b"mset");
/// `name`
pub const NAME: u32 = tag!(b"name");
/// `nukt`
pub const NUKT: u32 = tag!(b"nukt");
/// `onum`
pub const ONUM: u32 = tag!(b"onum");
/// `opbd`
pub const OPBD: u32 = tag!(b"opbd");
/// `ordn`
pub const ORDN: u32 = tag!(b"ordn");
/// `ory2`
pub const ORY2: u32 = tag!(b"ory2");
/// `orya`
pub const ORYA: u32 = tag!(b"orya");
/// `OS/2`
pub const OS_2: u32 = tag!(b"OS/2");
/// `OTTO`
pub const OTTO: u32 = tag!(b"OTTO");
/// `PCLT`
pub const PCLT: u32 = tag!(b"PCLT");
/// `pnum`
pub const PNUM: u32 = tag!(b"pnum");
/// `png `
pub const PNG: u32 = tag!(b"png ");
/// `post`
pub const POST: u32 = tag!(b"post");
/// `pref`
pub const PREF: u32 = tag!(b"pref");
/// `prep`
pub const PREP: u32 = tag!(b"prep");
/// `pres`
pub const PRES: u32 = tag!(b"pres");
/// `prop`
pub const PROP: u32 = tag!(b"prop");
/// `pstf`
pub const PSTF: u32 = tag!(b"pstf");
/// `psts`
pub const PSTS: u32 = tag!(b"psts");
/// `rclt`
pub const RCLT: u32 = tag!(b"rclt");
/// `rkrf`
pub const RKRF: u32 = tag!(b"rkrf");
/// `rlig`
pub const RLIG: u32 = tag!(b"rlig");
/// `rphf`
pub const RPHF: u32 = tag!(b"rphf");
/// `sbix`
pub const SBIX: u32 = tag!(b"sbix");
/// `Silf`
pub const SILF: u32 = tag!(b"Silf");
/// `Sill`
pub const SILL: u32 = tag!(b"Sill");
/// `sinh`
pub const SINH: u32 = tag!(b"sinh");
/// `smcp`
pub const SMCP: u32 = tag!(b"smcp");
/// `SND `
pub const SND: u32 = tag!(b"SND ");
/// `SVG `
pub const SVG: u32 = tag!(b"SVG ");
/// `syrc`
pub const SYRC: u32 = tag!(b"syrc");
/// `taml`
pub const TAML: u32 = tag!(b"taml");
/// `tel2`
pub const TEL2: u32 = tag!(b"tel2");
/// `telu`
pub const TELU: u32 = tag!(b"telu");
/// `thai`
pub const THAI: u32 = tag!(b"thai");
/// `tiff`
pub const TIFF: u32 = tag!(b"tiff");
/// `tml2`
pub const TML2: u32 = tag!(b"tml2");
/// `tnum`
pub const TNUM: u32 = tag!(b"tnum");
/// `trak`
pub const TRAK: u32 = tag!(b"trak");
/// `ttcf`
pub const TTCF: u32 = tag!(b"ttcf");
/// `URD `
pub const URD: u32 = tag!(b"URD ");
/// `vatu`
pub const VATU: u32 = tag!(b"vatu");
/// `VDMX`
pub const VDMX: u32 = tag!(b"VDMX");
/// `vert`
pub const VERT: u32 = tag!(b"vert");
/// `vhea`
pub const VHEA: u32 = tag!(b"vhea");
/// `vmtx`
pub const VMTX: u32 = tag!(b"vmtx");
/// `VORG`
pub const VORG: u32 = tag!(b"VORG");
/// `vrt2`
pub const VRT2: u32 = tag!(b"vrt2");
/// `Zapf`
pub const ZAPF: u32 = tag!(b"Zapf");
/// `zero`
pub const ZERO: u32 = tag!(b"zero");
#[cfg(test)]
mod tests {
use super::*;
mod from_string {
use super::*;
#[test]
fn test_four_chars() |
#[test]
fn test_three_chars() {
let tag = from_string("BEN").expect("invalid tag");
assert_eq!(tag, 1111838240);
}
}
mod display_tag {
use crate::tag::{DisplayTag, NAME};
#[test]
fn test_simple_ascii() {
assert_eq!(DisplayTag(NAME).to_string(), "name".to_string());
}
#[test]
fn test_non_ascii() {
assert_eq!(DisplayTag(0x12345678).to_string(), "0x12345678".to_string());
}
#[test]
fn test_debug() {
assert_eq!(format!("{:?}", DisplayTag(NAME)), "name".to_string());
}
}
}
| {
let tag = from_string("beng").expect("invalid tag");
assert_eq!(tag, 1650814567);
} | identifier_body |
tag.rs | //! Utilities and constants for OpenType tags.
//!
//! See also the [`tag!`](../macro.tag.html) macro for creating tags from a byte string.
use crate::error::ParseError;
use std::{fmt, str};
/// Generate a 4-byte OpenType tag from byte string
///
/// Example:
///
/// ```
/// use allsorts::tag;
/// assert_eq!(tag!(b"glyf"), 0x676C7966);
/// ```
#[macro_export]
macro_rules! tag {
($w:expr) => {
u32::from_be_bytes(*$w)
};
}
/// Wrapper type for a tag that implements `Display`
///
/// Example:
///
/// ```
/// use allsorts::tag::{self, DisplayTag};
///
/// // ASCII tag comes out as a string
/// assert_eq!(&DisplayTag(tag::NAME).to_string(), "name");
/// // Non-ASCII tag comes out as hex
/// assert_eq!(&DisplayTag(0x12345678).to_string(), "0x12345678");
///
/// println!("DisplayTag is handy for printing a tag: '{}'", DisplayTag(tag::CFF));
/// ```
#[derive(PartialEq, Eq, Clone, Copy)]
pub struct DisplayTag(pub u32);
pub fn from_string(s: &str) -> Result<u32, ParseError> {
if s.len() > 4 {
return Err(ParseError::BadValue);
}
let mut tag: u32 = 0;
let mut count = 0;
for c in s.chars() {
if !c.is_ascii() || c.is_ascii_control() {
return Err(ParseError::BadValue);
}
tag = (tag << 8) | (c as u32);
count += 1;
}
while count < 4 {
tag = (tag << 8) | (' ' as u32);
count += 1;
}
Ok(tag)
}
impl fmt::Display for DisplayTag {
fn | (&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let tag = self.0;
let bytes = tag.to_be_bytes();
if bytes.iter().all(|c| c.is_ascii() && !c.is_ascii_control()) {
let s = str::from_utf8(&bytes).unwrap(); // unwrap safe due to above check
s.fmt(f)
} else {
write!(f, "0x{:08x}", tag)
}
}
}
impl fmt::Debug for DisplayTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self, f)
}
}
/// `abvf`
pub const ABVF: u32 = tag!(b"abvf");
/// `abvm`
pub const ABVM: u32 = tag!(b"abvm");
/// `abvs`
pub const ABVS: u32 = tag!(b"abvs");
/// `acnt`
pub const ACNT: u32 = tag!(b"acnt");
/// `afrc`
pub const AFRC: u32 = tag!(b"afrc");
/// `akhn`
pub const AKHN: u32 = tag!(b"akhn");
/// `arab`
pub const ARAB: u32 = tag!(b"arab");
/// `avar`
pub const AVAR: u32 = tag!(b"avar");
/// `BASE`
pub const BASE: u32 = tag!(b"BASE");
/// `bdat`
pub const BDAT: u32 = tag!(b"bdat");
/// `beng`
pub const BENG: u32 = tag!(b"beng");
/// `bloc`
pub const BLOC: u32 = tag!(b"bloc");
/// `blwf`
pub const BLWF: u32 = tag!(b"blwf");
/// `blwm`
pub const BLWM: u32 = tag!(b"blwm");
/// `blws`
pub const BLWS: u32 = tag!(b"blws");
/// `bng2`
pub const BNG2: u32 = tag!(b"bng2");
/// `bsln`
pub const BSLN: u32 = tag!(b"bsln");
/// `c2sc`
pub const C2SC: u32 = tag!(b"c2sc");
/// `calt`
pub const CALT: u32 = tag!(b"calt");
/// `CBDT`
pub const CBDT: u32 = tag!(b"CBDT");
/// `CBLC`
pub const CBLC: u32 = tag!(b"CBLC");
/// `ccmp`
pub const CCMP: u32 = tag!(b"ccmp");
/// `cfar`
pub const CFAR: u32 = tag!(b"cfar");
/// `CFF `
pub const CFF: u32 = tag!(b"CFF ");
/// `cjct`
pub const CJCT: u32 = tag!(b"cjct");
/// `clig`
pub const CLIG: u32 = tag!(b"clig");
/// `cmap`
pub const CMAP: u32 = tag!(b"cmap");
/// `COLR`
pub const COLR: u32 = tag!(b"COLR");
/// `CPAL`
pub const CPAL: u32 = tag!(b"CPAL");
/// `curs`
pub const CURS: u32 = tag!(b"curs");
/// `cvar`
pub const CVAR: u32 = tag!(b"cvar");
/// `cvt `
pub const CVT: u32 = tag!(b"cvt ");
/// `cyrl`
pub const CYRL: u32 = tag!(b"cyrl");
/// `dev2`
pub const DEV2: u32 = tag!(b"dev2");
/// `deva`
pub const DEVA: u32 = tag!(b"deva");
/// `DFLT`
pub const DFLT: u32 = tag!(b"DFLT");
/// `dist`
pub const DIST: u32 = tag!(b"dist");
/// `dlig`
pub const DLIG: u32 = tag!(b"dlig");
/// `dupe`
pub const DUPE: u32 = tag!(b"dupe");
/// `EBDT`
pub const EBDT: u32 = tag!(b"EBDT");
/// `EBLC`
pub const EBLC: u32 = tag!(b"EBLC");
/// `EBSC`
pub const EBSC: u32 = tag!(b"EBSC");
/// `FAR `
pub const FAR: u32 = tag!(b"FAR ");
/// `fdsc`
pub const FDSC: u32 = tag!(b"fdsc");
/// `Feat`
pub const FEAT2: u32 = tag!(b"Feat");
/// `feat`
pub const FEAT: u32 = tag!(b"feat");
/// `fin2`
pub const FIN2: u32 = tag!(b"fin2");
/// `fin3`
pub const FIN3: u32 = tag!(b"fin3");
/// `fina`
pub const FINA: u32 = tag!(b"fina");
/// `fmtx`
pub const FMTX: u32 = tag!(b"fmtx");
/// `fpgm`
pub const FPGM: u32 = tag!(b"fpgm");
/// `frac`
pub const FRAC: u32 = tag!(b"frac");
/// `fvar`
pub const FVAR: u32 = tag!(b"fvar");
/// `gasp`
pub const GASP: u32 = tag!(b"gasp");
/// `GDEF`
pub const GDEF: u32 = tag!(b"GDEF");
/// `gjr2`
pub const GJR2: u32 = tag!(b"gjr2");
/// `Glat`
pub const GLAT: u32 = tag!(b"Glat");
/// `Gloc`
pub const GLOC: u32 = tag!(b"Gloc");
/// `glyf`
pub const GLYF: u32 = tag!(b"glyf");
/// `GPOS`
pub const GPOS: u32 = tag!(b"GPOS");
/// `grek`
pub const GREK: u32 = tag!(b"grek");
/// `GSUB`
pub const GSUB: u32 = tag!(b"GSUB");
/// `gujr`
pub const GUJR: u32 = tag!(b"gujr");
/// `gur2`
pub const GUR2: u32 = tag!(b"gur2");
/// `guru`
pub const GURU: u32 = tag!(b"guru");
/// `gvar`
pub const GVAR: u32 = tag!(b"gvar");
/// `half`
pub const HALF: u32 = tag!(b"half");
/// `haln`
pub const HALN: u32 = tag!(b"haln");
/// `hdmx`
pub const HDMX: u32 = tag!(b"hdmx");
/// `head`
pub const HEAD: u32 = tag!(b"head");
/// `hhea`
pub const HHEA: u32 = tag!(b"hhea");
/// `hlig`
pub const HLIG: u32 = tag!(b"hlig");
/// `hmtx`
pub const HMTX: u32 = tag!(b"hmtx");
/// `hsty`
pub const HSTY: u32 = tag!(b"hsty");
/// `init`
pub const INIT: u32 = tag!(b"init");
/// `isol`
pub const ISOL: u32 = tag!(b"isol");
/// `jpg `
pub const JPG: u32 = tag!(b"jpg ");
/// `JSTF`
pub const JSTF: u32 = tag!(b"JSTF");
/// `just`
pub const JUST: u32 = tag!(b"just");
/// `kern`
pub const KERN: u32 = tag!(b"kern");
/// `khmr`
pub const KHMR: u32 = tag!(b"khmr");
/// `knd2`
pub const KND2: u32 = tag!(b"knd2");
/// `knda`
pub const KNDA: u32 = tag!(b"knda");
/// `lao `
pub const LAO: u32 = tag!(b"lao ");
/// `latn`
pub const LATN: u32 = tag!(b"latn");
/// `lcar`
pub const LCAR: u32 = tag!(b"lcar");
/// `liga`
pub const LIGA: u32 = tag!(b"liga");
/// `lnum`
pub const LNUM: u32 = tag!(b"lnum");
/// `loca`
pub const LOCA: u32 = tag!(b"loca");
/// `locl`
pub const LOCL: u32 = tag!(b"locl");
/// `LTSH`
pub const LTSH: u32 = tag!(b"LTSH");
/// `mark`
pub const MARK: u32 = tag!(b"mark");
/// `MATH`
pub const MATH: u32 = tag!(b"MATH");
/// `maxp`
pub const MAXP: u32 = tag!(b"maxp");
/// `med2`
pub const MED2: u32 = tag!(b"med2");
/// `medi`
pub const MEDI: u32 = tag!(b"medi");
/// `mkmk`
pub const MKMK: u32 = tag!(b"mkmk");
/// `mlm2`
pub const MLM2: u32 = tag!(b"mlm2");
/// `mlym`
pub const MLYM: u32 = tag!(b"mlym");
/// `mort`
pub const MORT: u32 = tag!(b"mort");
/// `morx`
pub const MORX: u32 = tag!(b"morx");
/// `mset`
pub const MSET: u32 = tag!(b"mset");
/// `name`
pub const NAME: u32 = tag!(b"name");
/// `nukt`
pub const NUKT: u32 = tag!(b"nukt");
/// `onum`
pub const ONUM: u32 = tag!(b"onum");
/// `opbd`
pub const OPBD: u32 = tag!(b"opbd");
/// `ordn`
pub const ORDN: u32 = tag!(b"ordn");
/// `ory2`
pub const ORY2: u32 = tag!(b"ory2");
/// `orya`
pub const ORYA: u32 = tag!(b"orya");
/// `OS/2`
pub const OS_2: u32 = tag!(b"OS/2");
/// `OTTO`
pub const OTTO: u32 = tag!(b"OTTO");
/// `PCLT`
pub const PCLT: u32 = tag!(b"PCLT");
/// `pnum`
pub const PNUM: u32 = tag!(b"pnum");
/// `png `
pub const PNG: u32 = tag!(b"png ");
/// `post`
pub const POST: u32 = tag!(b"post");
/// `pref`
pub const PREF: u32 = tag!(b"pref");
/// `prep`
pub const PREP: u32 = tag!(b"prep");
/// `pres`
pub const PRES: u32 = tag!(b"pres");
/// `prop`
pub const PROP: u32 = tag!(b"prop");
/// `pstf`
pub const PSTF: u32 = tag!(b"pstf");
/// `psts`
pub const PSTS: u32 = tag!(b"psts");
/// `rclt`
pub const RCLT: u32 = tag!(b"rclt");
/// `rkrf`
pub const RKRF: u32 = tag!(b"rkrf");
/// `rlig`
pub const RLIG: u32 = tag!(b"rlig");
/// `rphf`
pub const RPHF: u32 = tag!(b"rphf");
/// `sbix`
pub const SBIX: u32 = tag!(b"sbix");
/// `Silf`
pub const SILF: u32 = tag!(b"Silf");
/// `Sill`
pub const SILL: u32 = tag!(b"Sill");
/// `sinh`
pub const SINH: u32 = tag!(b"sinh");
/// `smcp`
pub const SMCP: u32 = tag!(b"smcp");
/// `SND `
pub const SND: u32 = tag!(b"SND ");
/// `SVG `
pub const SVG: u32 = tag!(b"SVG ");
/// `syrc`
pub const SYRC: u32 = tag!(b"syrc");
/// `taml`
pub const TAML: u32 = tag!(b"taml");
/// `tel2`
pub const TEL2: u32 = tag!(b"tel2");
/// `telu`
pub const TELU: u32 = tag!(b"telu");
/// `thai`
pub const THAI: u32 = tag!(b"thai");
/// `tiff`
pub const TIFF: u32 = tag!(b"tiff");
/// `tml2`
pub const TML2: u32 = tag!(b"tml2");
/// `tnum`
pub const TNUM: u32 = tag!(b"tnum");
/// `trak`
pub const TRAK: u32 = tag!(b"trak");
/// `ttcf`
pub const TTCF: u32 = tag!(b"ttcf");
/// `URD `
pub const URD: u32 = tag!(b"URD ");
/// `vatu`
pub const VATU: u32 = tag!(b"vatu");
/// `VDMX`
pub const VDMX: u32 = tag!(b"VDMX");
/// `vert`
pub const VERT: u32 = tag!(b"vert");
/// `vhea`
pub const VHEA: u32 = tag!(b"vhea");
/// `vmtx`
pub const VMTX: u32 = tag!(b"vmtx");
/// `VORG`
pub const VORG: u32 = tag!(b"VORG");
/// `vrt2`
pub const VRT2: u32 = tag!(b"vrt2");
/// `Zapf`
pub const ZAPF: u32 = tag!(b"Zapf");
/// `zero`
pub const ZERO: u32 = tag!(b"zero");
#[cfg(test)]
mod tests {
use super::*;
mod from_string {
use super::*;
#[test]
fn test_four_chars() {
let tag = from_string("beng").expect("invalid tag");
assert_eq!(tag, 1650814567);
}
#[test]
fn test_three_chars() {
let tag = from_string("BEN").expect("invalid tag");
assert_eq!(tag, 1111838240);
}
}
mod display_tag {
use crate::tag::{DisplayTag, NAME};
#[test]
fn test_simple_ascii() {
assert_eq!(DisplayTag(NAME).to_string(), "name".to_string());
}
#[test]
fn test_non_ascii() {
assert_eq!(DisplayTag(0x12345678).to_string(), "0x12345678".to_string());
}
#[test]
fn test_debug() {
assert_eq!(format!("{:?}", DisplayTag(NAME)), "name".to_string());
}
}
}
| fmt | identifier_name |
tag.rs | //! Utilities and constants for OpenType tags.
//!
//! See also the [`tag!`](../macro.tag.html) macro for creating tags from a byte string.
use crate::error::ParseError;
use std::{fmt, str};
/// Generate a 4-byte OpenType tag from byte string
///
/// Example:
///
/// ```
/// use allsorts::tag;
/// assert_eq!(tag!(b"glyf"), 0x676C7966);
/// ```
#[macro_export]
macro_rules! tag {
($w:expr) => {
u32::from_be_bytes(*$w)
};
}
/// Wrapper type for a tag that implements `Display`
///
/// Example:
///
/// ```
/// use allsorts::tag::{self, DisplayTag};
///
/// // ASCII tag comes out as a string
/// assert_eq!(&DisplayTag(tag::NAME).to_string(), "name");
/// // Non-ASCII tag comes out as hex
/// assert_eq!(&DisplayTag(0x12345678).to_string(), "0x12345678");
///
/// println!("DisplayTag is handy for printing a tag: '{}'", DisplayTag(tag::CFF));
/// ```
#[derive(PartialEq, Eq, Clone, Copy)]
pub struct DisplayTag(pub u32);
pub fn from_string(s: &str) -> Result<u32, ParseError> {
if s.len() > 4 {
return Err(ParseError::BadValue);
}
let mut tag: u32 = 0;
let mut count = 0;
for c in s.chars() {
if !c.is_ascii() || c.is_ascii_control() {
return Err(ParseError::BadValue);
}
tag = (tag << 8) | (c as u32);
count += 1;
}
while count < 4 {
tag = (tag << 8) | (' ' as u32);
count += 1;
}
Ok(tag)
}
impl fmt::Display for DisplayTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let tag = self.0;
let bytes = tag.to_be_bytes();
if bytes.iter().all(|c| c.is_ascii() && !c.is_ascii_control()) {
let s = str::from_utf8(&bytes).unwrap(); // unwrap safe due to above check
s.fmt(f)
} else {
write!(f, "0x{:08x}", tag)
}
}
}
impl fmt::Debug for DisplayTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self, f)
}
}
/// `abvf`
pub const ABVF: u32 = tag!(b"abvf");
/// `abvm`
pub const ABVM: u32 = tag!(b"abvm");
/// `abvs`
pub const ABVS: u32 = tag!(b"abvs");
/// `acnt`
pub const ACNT: u32 = tag!(b"acnt");
/// `afrc`
pub const AFRC: u32 = tag!(b"afrc");
/// `akhn`
pub const AKHN: u32 = tag!(b"akhn");
/// `arab`
pub const ARAB: u32 = tag!(b"arab");
/// `avar`
pub const AVAR: u32 = tag!(b"avar");
/// `BASE`
pub const BASE: u32 = tag!(b"BASE");
/// `bdat`
pub const BDAT: u32 = tag!(b"bdat");
/// `beng`
pub const BENG: u32 = tag!(b"beng");
/// `bloc`
pub const BLOC: u32 = tag!(b"bloc");
/// `blwf`
pub const BLWF: u32 = tag!(b"blwf");
/// `blwm`
pub const BLWM: u32 = tag!(b"blwm");
/// `blws`
pub const BLWS: u32 = tag!(b"blws");
/// `bng2`
pub const BNG2: u32 = tag!(b"bng2");
/// `bsln`
pub const BSLN: u32 = tag!(b"bsln");
/// `c2sc`
pub const C2SC: u32 = tag!(b"c2sc");
/// `calt`
pub const CALT: u32 = tag!(b"calt");
/// `CBDT`
pub const CBDT: u32 = tag!(b"CBDT");
/// `CBLC`
pub const CBLC: u32 = tag!(b"CBLC");
/// `ccmp`
pub const CCMP: u32 = tag!(b"ccmp");
/// `cfar`
pub const CFAR: u32 = tag!(b"cfar");
/// `CFF `
pub const CFF: u32 = tag!(b"CFF ");
/// `cjct`
pub const CJCT: u32 = tag!(b"cjct");
/// `clig`
pub const CLIG: u32 = tag!(b"clig");
/// `cmap`
pub const CMAP: u32 = tag!(b"cmap");
/// `COLR`
pub const COLR: u32 = tag!(b"COLR");
/// `CPAL`
pub const CPAL: u32 = tag!(b"CPAL");
/// `curs`
pub const CURS: u32 = tag!(b"curs");
/// `cvar`
pub const CVAR: u32 = tag!(b"cvar");
/// `cvt `
pub const CVT: u32 = tag!(b"cvt ");
/// `cyrl`
pub const CYRL: u32 = tag!(b"cyrl");
/// `dev2`
pub const DEV2: u32 = tag!(b"dev2");
/// `deva`
pub const DEVA: u32 = tag!(b"deva");
/// `DFLT`
pub const DFLT: u32 = tag!(b"DFLT");
/// `dist`
pub const DIST: u32 = tag!(b"dist");
/// `dlig`
pub const DLIG: u32 = tag!(b"dlig");
/// `dupe`
pub const DUPE: u32 = tag!(b"dupe");
/// `EBDT`
pub const EBDT: u32 = tag!(b"EBDT");
/// `EBLC`
pub const EBLC: u32 = tag!(b"EBLC");
/// `EBSC`
pub const EBSC: u32 = tag!(b"EBSC");
/// `FAR `
pub const FAR: u32 = tag!(b"FAR ");
/// `fdsc`
pub const FDSC: u32 = tag!(b"fdsc");
/// `Feat`
pub const FEAT2: u32 = tag!(b"Feat");
/// `feat`
pub const FEAT: u32 = tag!(b"feat");
/// `fin2`
pub const FIN2: u32 = tag!(b"fin2");
/// `fin3`
pub const FIN3: u32 = tag!(b"fin3");
/// `fina`
pub const FINA: u32 = tag!(b"fina");
/// `fmtx`
pub const FMTX: u32 = tag!(b"fmtx");
/// `fpgm`
pub const FPGM: u32 = tag!(b"fpgm");
/// `frac`
pub const FRAC: u32 = tag!(b"frac");
/// `fvar`
pub const FVAR: u32 = tag!(b"fvar");
/// `gasp`
pub const GASP: u32 = tag!(b"gasp");
/// `GDEF`
pub const GDEF: u32 = tag!(b"GDEF");
/// `gjr2`
pub const GJR2: u32 = tag!(b"gjr2");
/// `Glat`
pub const GLAT: u32 = tag!(b"Glat");
/// `Gloc`
pub const GLOC: u32 = tag!(b"Gloc");
/// `glyf`
pub const GLYF: u32 = tag!(b"glyf");
/// `GPOS`
pub const GPOS: u32 = tag!(b"GPOS");
/// `grek`
pub const GREK: u32 = tag!(b"grek");
/// `GSUB`
pub const GSUB: u32 = tag!(b"GSUB");
/// `gujr`
pub const GUJR: u32 = tag!(b"gujr");
/// `gur2`
pub const GUR2: u32 = tag!(b"gur2");
/// `guru`
pub const GURU: u32 = tag!(b"guru");
/// `gvar`
pub const GVAR: u32 = tag!(b"gvar");
/// `half`
pub const HALF: u32 = tag!(b"half");
/// `haln`
pub const HALN: u32 = tag!(b"haln");
/// `hdmx`
pub const HDMX: u32 = tag!(b"hdmx");
/// `head`
pub const HEAD: u32 = tag!(b"head");
/// `hhea`
pub const HHEA: u32 = tag!(b"hhea");
/// `hlig`
pub const HLIG: u32 = tag!(b"hlig");
/// `hmtx`
pub const HMTX: u32 = tag!(b"hmtx");
/// `hsty`
pub const HSTY: u32 = tag!(b"hsty");
/// `init`
pub const INIT: u32 = tag!(b"init");
/// `isol`
pub const ISOL: u32 = tag!(b"isol");
/// `jpg `
pub const JPG: u32 = tag!(b"jpg ");
/// `JSTF`
pub const JSTF: u32 = tag!(b"JSTF");
/// `just`
pub const JUST: u32 = tag!(b"just");
/// `kern`
pub const KERN: u32 = tag!(b"kern");
/// `khmr`
pub const KHMR: u32 = tag!(b"khmr");
/// `knd2`
pub const KND2: u32 = tag!(b"knd2");
/// `knda`
pub const KNDA: u32 = tag!(b"knda");
/// `lao `
pub const LAO: u32 = tag!(b"lao ");
/// `latn`
pub const LATN: u32 = tag!(b"latn");
/// `lcar`
pub const LCAR: u32 = tag!(b"lcar");
/// `liga`
pub const LIGA: u32 = tag!(b"liga");
/// `lnum`
pub const LNUM: u32 = tag!(b"lnum");
/// `loca`
pub const LOCA: u32 = tag!(b"loca");
/// `locl`
pub const LOCL: u32 = tag!(b"locl");
/// `LTSH`
pub const LTSH: u32 = tag!(b"LTSH");
/// `mark`
pub const MARK: u32 = tag!(b"mark");
/// `MATH`
pub const MATH: u32 = tag!(b"MATH");
/// `maxp`
pub const MAXP: u32 = tag!(b"maxp");
/// `med2`
pub const MED2: u32 = tag!(b"med2");
/// `medi` | pub const MKMK: u32 = tag!(b"mkmk");
/// `mlm2`
pub const MLM2: u32 = tag!(b"mlm2");
/// `mlym`
pub const MLYM: u32 = tag!(b"mlym");
/// `mort`
pub const MORT: u32 = tag!(b"mort");
/// `morx`
pub const MORX: u32 = tag!(b"morx");
/// `mset`
pub const MSET: u32 = tag!(b"mset");
/// `name`
pub const NAME: u32 = tag!(b"name");
/// `nukt`
pub const NUKT: u32 = tag!(b"nukt");
/// `onum`
pub const ONUM: u32 = tag!(b"onum");
/// `opbd`
pub const OPBD: u32 = tag!(b"opbd");
/// `ordn`
pub const ORDN: u32 = tag!(b"ordn");
/// `ory2`
pub const ORY2: u32 = tag!(b"ory2");
/// `orya`
pub const ORYA: u32 = tag!(b"orya");
/// `OS/2`
pub const OS_2: u32 = tag!(b"OS/2");
/// `OTTO`
pub const OTTO: u32 = tag!(b"OTTO");
/// `PCLT`
pub const PCLT: u32 = tag!(b"PCLT");
/// `pnum`
pub const PNUM: u32 = tag!(b"pnum");
/// `png `
pub const PNG: u32 = tag!(b"png ");
/// `post`
pub const POST: u32 = tag!(b"post");
/// `pref`
pub const PREF: u32 = tag!(b"pref");
/// `prep`
pub const PREP: u32 = tag!(b"prep");
/// `pres`
pub const PRES: u32 = tag!(b"pres");
/// `prop`
pub const PROP: u32 = tag!(b"prop");
/// `pstf`
pub const PSTF: u32 = tag!(b"pstf");
/// `psts`
pub const PSTS: u32 = tag!(b"psts");
/// `rclt`
pub const RCLT: u32 = tag!(b"rclt");
/// `rkrf`
pub const RKRF: u32 = tag!(b"rkrf");
/// `rlig`
pub const RLIG: u32 = tag!(b"rlig");
/// `rphf`
pub const RPHF: u32 = tag!(b"rphf");
/// `sbix`
pub const SBIX: u32 = tag!(b"sbix");
/// `Silf`
pub const SILF: u32 = tag!(b"Silf");
/// `Sill`
pub const SILL: u32 = tag!(b"Sill");
/// `sinh`
pub const SINH: u32 = tag!(b"sinh");
/// `smcp`
pub const SMCP: u32 = tag!(b"smcp");
/// `SND `
pub const SND: u32 = tag!(b"SND ");
/// `SVG `
pub const SVG: u32 = tag!(b"SVG ");
/// `syrc`
pub const SYRC: u32 = tag!(b"syrc");
/// `taml`
pub const TAML: u32 = tag!(b"taml");
/// `tel2`
pub const TEL2: u32 = tag!(b"tel2");
/// `telu`
pub const TELU: u32 = tag!(b"telu");
/// `thai`
pub const THAI: u32 = tag!(b"thai");
/// `tiff`
pub const TIFF: u32 = tag!(b"tiff");
/// `tml2`
pub const TML2: u32 = tag!(b"tml2");
/// `tnum`
pub const TNUM: u32 = tag!(b"tnum");
/// `trak`
pub const TRAK: u32 = tag!(b"trak");
/// `ttcf`
pub const TTCF: u32 = tag!(b"ttcf");
/// `URD `
pub const URD: u32 = tag!(b"URD ");
/// `vatu`
pub const VATU: u32 = tag!(b"vatu");
/// `VDMX`
pub const VDMX: u32 = tag!(b"VDMX");
/// `vert`
pub const VERT: u32 = tag!(b"vert");
/// `vhea`
pub const VHEA: u32 = tag!(b"vhea");
/// `vmtx`
pub const VMTX: u32 = tag!(b"vmtx");
/// `VORG`
pub const VORG: u32 = tag!(b"VORG");
/// `vrt2`
pub const VRT2: u32 = tag!(b"vrt2");
/// `Zapf`
pub const ZAPF: u32 = tag!(b"Zapf");
/// `zero`
pub const ZERO: u32 = tag!(b"zero");
#[cfg(test)]
mod tests {
use super::*;
mod from_string {
use super::*;
#[test]
fn test_four_chars() {
let tag = from_string("beng").expect("invalid tag");
assert_eq!(tag, 1650814567);
}
#[test]
fn test_three_chars() {
let tag = from_string("BEN").expect("invalid tag");
assert_eq!(tag, 1111838240);
}
}
mod display_tag {
use crate::tag::{DisplayTag, NAME};
#[test]
fn test_simple_ascii() {
assert_eq!(DisplayTag(NAME).to_string(), "name".to_string());
}
#[test]
fn test_non_ascii() {
assert_eq!(DisplayTag(0x12345678).to_string(), "0x12345678".to_string());
}
#[test]
fn test_debug() {
assert_eq!(format!("{:?}", DisplayTag(NAME)), "name".to_string());
}
}
} | pub const MEDI: u32 = tag!(b"medi");
/// `mkmk` | random_line_split |
tag.rs | //! Utilities and constants for OpenType tags.
//!
//! See also the [`tag!`](../macro.tag.html) macro for creating tags from a byte string.
use crate::error::ParseError;
use std::{fmt, str};
/// Generate a 4-byte OpenType tag from byte string
///
/// Example:
///
/// ```
/// use allsorts::tag;
/// assert_eq!(tag!(b"glyf"), 0x676C7966);
/// ```
#[macro_export]
macro_rules! tag {
($w:expr) => {
u32::from_be_bytes(*$w)
};
}
/// Wrapper type for a tag that implements `Display`
///
/// Example:
///
/// ```
/// use allsorts::tag::{self, DisplayTag};
///
/// // ASCII tag comes out as a string
/// assert_eq!(&DisplayTag(tag::NAME).to_string(), "name");
/// // Non-ASCII tag comes out as hex
/// assert_eq!(&DisplayTag(0x12345678).to_string(), "0x12345678");
///
/// println!("DisplayTag is handy for printing a tag: '{}'", DisplayTag(tag::CFF));
/// ```
#[derive(PartialEq, Eq, Clone, Copy)]
pub struct DisplayTag(pub u32);
pub fn from_string(s: &str) -> Result<u32, ParseError> {
if s.len() > 4 {
return Err(ParseError::BadValue);
}
let mut tag: u32 = 0;
let mut count = 0;
for c in s.chars() {
if !c.is_ascii() || c.is_ascii_control() |
tag = (tag << 8) | (c as u32);
count += 1;
}
while count < 4 {
tag = (tag << 8) | (' ' as u32);
count += 1;
}
Ok(tag)
}
impl fmt::Display for DisplayTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let tag = self.0;
let bytes = tag.to_be_bytes();
if bytes.iter().all(|c| c.is_ascii() && !c.is_ascii_control()) {
let s = str::from_utf8(&bytes).unwrap(); // unwrap safe due to above check
s.fmt(f)
} else {
write!(f, "0x{:08x}", tag)
}
}
}
impl fmt::Debug for DisplayTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self, f)
}
}
/// `abvf`
pub const ABVF: u32 = tag!(b"abvf");
/// `abvm`
pub const ABVM: u32 = tag!(b"abvm");
/// `abvs`
pub const ABVS: u32 = tag!(b"abvs");
/// `acnt`
pub const ACNT: u32 = tag!(b"acnt");
/// `afrc`
pub const AFRC: u32 = tag!(b"afrc");
/// `akhn`
pub const AKHN: u32 = tag!(b"akhn");
/// `arab`
pub const ARAB: u32 = tag!(b"arab");
/// `avar`
pub const AVAR: u32 = tag!(b"avar");
/// `BASE`
pub const BASE: u32 = tag!(b"BASE");
/// `bdat`
pub const BDAT: u32 = tag!(b"bdat");
/// `beng`
pub const BENG: u32 = tag!(b"beng");
/// `bloc`
pub const BLOC: u32 = tag!(b"bloc");
/// `blwf`
pub const BLWF: u32 = tag!(b"blwf");
/// `blwm`
pub const BLWM: u32 = tag!(b"blwm");
/// `blws`
pub const BLWS: u32 = tag!(b"blws");
/// `bng2`
pub const BNG2: u32 = tag!(b"bng2");
/// `bsln`
pub const BSLN: u32 = tag!(b"bsln");
/// `c2sc`
pub const C2SC: u32 = tag!(b"c2sc");
/// `calt`
pub const CALT: u32 = tag!(b"calt");
/// `CBDT`
pub const CBDT: u32 = tag!(b"CBDT");
/// `CBLC`
pub const CBLC: u32 = tag!(b"CBLC");
/// `ccmp`
pub const CCMP: u32 = tag!(b"ccmp");
/// `cfar`
pub const CFAR: u32 = tag!(b"cfar");
/// `CFF `
pub const CFF: u32 = tag!(b"CFF ");
/// `cjct`
pub const CJCT: u32 = tag!(b"cjct");
/// `clig`
pub const CLIG: u32 = tag!(b"clig");
/// `cmap`
pub const CMAP: u32 = tag!(b"cmap");
/// `COLR`
pub const COLR: u32 = tag!(b"COLR");
/// `CPAL`
pub const CPAL: u32 = tag!(b"CPAL");
/// `curs`
pub const CURS: u32 = tag!(b"curs");
/// `cvar`
pub const CVAR: u32 = tag!(b"cvar");
/// `cvt `
pub const CVT: u32 = tag!(b"cvt ");
/// `cyrl`
pub const CYRL: u32 = tag!(b"cyrl");
/// `dev2`
pub const DEV2: u32 = tag!(b"dev2");
/// `deva`
pub const DEVA: u32 = tag!(b"deva");
/// `DFLT`
pub const DFLT: u32 = tag!(b"DFLT");
/// `dist`
pub const DIST: u32 = tag!(b"dist");
/// `dlig`
pub const DLIG: u32 = tag!(b"dlig");
/// `dupe`
pub const DUPE: u32 = tag!(b"dupe");
/// `EBDT`
pub const EBDT: u32 = tag!(b"EBDT");
/// `EBLC`
pub const EBLC: u32 = tag!(b"EBLC");
/// `EBSC`
pub const EBSC: u32 = tag!(b"EBSC");
/// `FAR `
pub const FAR: u32 = tag!(b"FAR ");
/// `fdsc`
pub const FDSC: u32 = tag!(b"fdsc");
/// `Feat`
pub const FEAT2: u32 = tag!(b"Feat");
/// `feat`
pub const FEAT: u32 = tag!(b"feat");
/// `fin2`
pub const FIN2: u32 = tag!(b"fin2");
/// `fin3`
pub const FIN3: u32 = tag!(b"fin3");
/// `fina`
pub const FINA: u32 = tag!(b"fina");
/// `fmtx`
pub const FMTX: u32 = tag!(b"fmtx");
/// `fpgm`
pub const FPGM: u32 = tag!(b"fpgm");
/// `frac`
pub const FRAC: u32 = tag!(b"frac");
/// `fvar`
pub const FVAR: u32 = tag!(b"fvar");
/// `gasp`
pub const GASP: u32 = tag!(b"gasp");
/// `GDEF`
pub const GDEF: u32 = tag!(b"GDEF");
/// `gjr2`
pub const GJR2: u32 = tag!(b"gjr2");
/// `Glat`
pub const GLAT: u32 = tag!(b"Glat");
/// `Gloc`
pub const GLOC: u32 = tag!(b"Gloc");
/// `glyf`
pub const GLYF: u32 = tag!(b"glyf");
/// `GPOS`
pub const GPOS: u32 = tag!(b"GPOS");
/// `grek`
pub const GREK: u32 = tag!(b"grek");
/// `GSUB`
pub const GSUB: u32 = tag!(b"GSUB");
/// `gujr`
pub const GUJR: u32 = tag!(b"gujr");
/// `gur2`
pub const GUR2: u32 = tag!(b"gur2");
/// `guru`
pub const GURU: u32 = tag!(b"guru");
/// `gvar`
pub const GVAR: u32 = tag!(b"gvar");
/// `half`
pub const HALF: u32 = tag!(b"half");
/// `haln`
pub const HALN: u32 = tag!(b"haln");
/// `hdmx`
pub const HDMX: u32 = tag!(b"hdmx");
/// `head`
pub const HEAD: u32 = tag!(b"head");
/// `hhea`
pub const HHEA: u32 = tag!(b"hhea");
/// `hlig`
pub const HLIG: u32 = tag!(b"hlig");
/// `hmtx`
pub const HMTX: u32 = tag!(b"hmtx");
/// `hsty`
pub const HSTY: u32 = tag!(b"hsty");
/// `init`
pub const INIT: u32 = tag!(b"init");
/// `isol`
pub const ISOL: u32 = tag!(b"isol");
/// `jpg `
pub const JPG: u32 = tag!(b"jpg ");
/// `JSTF`
pub const JSTF: u32 = tag!(b"JSTF");
/// `just`
pub const JUST: u32 = tag!(b"just");
/// `kern`
pub const KERN: u32 = tag!(b"kern");
/// `khmr`
pub const KHMR: u32 = tag!(b"khmr");
/// `knd2`
pub const KND2: u32 = tag!(b"knd2");
/// `knda`
pub const KNDA: u32 = tag!(b"knda");
/// `lao `
pub const LAO: u32 = tag!(b"lao ");
/// `latn`
pub const LATN: u32 = tag!(b"latn");
/// `lcar`
pub const LCAR: u32 = tag!(b"lcar");
/// `liga`
pub const LIGA: u32 = tag!(b"liga");
/// `lnum`
pub const LNUM: u32 = tag!(b"lnum");
/// `loca`
pub const LOCA: u32 = tag!(b"loca");
/// `locl`
pub const LOCL: u32 = tag!(b"locl");
/// `LTSH`
pub const LTSH: u32 = tag!(b"LTSH");
/// `mark`
pub const MARK: u32 = tag!(b"mark");
/// `MATH`
pub const MATH: u32 = tag!(b"MATH");
/// `maxp`
pub const MAXP: u32 = tag!(b"maxp");
/// `med2`
pub const MED2: u32 = tag!(b"med2");
/// `medi`
pub const MEDI: u32 = tag!(b"medi");
/// `mkmk`
pub const MKMK: u32 = tag!(b"mkmk");
/// `mlm2`
pub const MLM2: u32 = tag!(b"mlm2");
/// `mlym`
pub const MLYM: u32 = tag!(b"mlym");
/// `mort`
pub const MORT: u32 = tag!(b"mort");
/// `morx`
pub const MORX: u32 = tag!(b"morx");
/// `mset`
pub const MSET: u32 = tag!(b"mset");
/// `name`
pub const NAME: u32 = tag!(b"name");
/// `nukt`
pub const NUKT: u32 = tag!(b"nukt");
/// `onum`
pub const ONUM: u32 = tag!(b"onum");
/// `opbd`
pub const OPBD: u32 = tag!(b"opbd");
/// `ordn`
pub const ORDN: u32 = tag!(b"ordn");
/// `ory2`
pub const ORY2: u32 = tag!(b"ory2");
/// `orya`
pub const ORYA: u32 = tag!(b"orya");
/// `OS/2`
pub const OS_2: u32 = tag!(b"OS/2");
/// `OTTO`
pub const OTTO: u32 = tag!(b"OTTO");
/// `PCLT`
pub const PCLT: u32 = tag!(b"PCLT");
/// `pnum`
pub const PNUM: u32 = tag!(b"pnum");
/// `png `
pub const PNG: u32 = tag!(b"png ");
/// `post`
pub const POST: u32 = tag!(b"post");
/// `pref`
pub const PREF: u32 = tag!(b"pref");
/// `prep`
pub const PREP: u32 = tag!(b"prep");
/// `pres`
pub const PRES: u32 = tag!(b"pres");
/// `prop`
pub const PROP: u32 = tag!(b"prop");
/// `pstf`
pub const PSTF: u32 = tag!(b"pstf");
/// `psts`
pub const PSTS: u32 = tag!(b"psts");
/// `rclt`
pub const RCLT: u32 = tag!(b"rclt");
/// `rkrf`
pub const RKRF: u32 = tag!(b"rkrf");
/// `rlig`
pub const RLIG: u32 = tag!(b"rlig");
/// `rphf`
pub const RPHF: u32 = tag!(b"rphf");
/// `sbix`
pub const SBIX: u32 = tag!(b"sbix");
/// `Silf`
pub const SILF: u32 = tag!(b"Silf");
/// `Sill`
pub const SILL: u32 = tag!(b"Sill");
/// `sinh`
pub const SINH: u32 = tag!(b"sinh");
/// `smcp`
pub const SMCP: u32 = tag!(b"smcp");
/// `SND `
pub const SND: u32 = tag!(b"SND ");
/// `SVG `
pub const SVG: u32 = tag!(b"SVG ");
/// `syrc`
pub const SYRC: u32 = tag!(b"syrc");
/// `taml`
pub const TAML: u32 = tag!(b"taml");
/// `tel2`
pub const TEL2: u32 = tag!(b"tel2");
/// `telu`
pub const TELU: u32 = tag!(b"telu");
/// `thai`
pub const THAI: u32 = tag!(b"thai");
/// `tiff`
pub const TIFF: u32 = tag!(b"tiff");
/// `tml2`
pub const TML2: u32 = tag!(b"tml2");
/// `tnum`
pub const TNUM: u32 = tag!(b"tnum");
/// `trak`
pub const TRAK: u32 = tag!(b"trak");
/// `ttcf`
pub const TTCF: u32 = tag!(b"ttcf");
/// `URD `
pub const URD: u32 = tag!(b"URD ");
/// `vatu`
pub const VATU: u32 = tag!(b"vatu");
/// `VDMX`
pub const VDMX: u32 = tag!(b"VDMX");
/// `vert`
pub const VERT: u32 = tag!(b"vert");
/// `vhea`
pub const VHEA: u32 = tag!(b"vhea");
/// `vmtx`
pub const VMTX: u32 = tag!(b"vmtx");
/// `VORG`
pub const VORG: u32 = tag!(b"VORG");
/// `vrt2`
pub const VRT2: u32 = tag!(b"vrt2");
/// `Zapf`
pub const ZAPF: u32 = tag!(b"Zapf");
/// `zero`
pub const ZERO: u32 = tag!(b"zero");
#[cfg(test)]
mod tests {
use super::*;
mod from_string {
use super::*;
#[test]
fn test_four_chars() {
let tag = from_string("beng").expect("invalid tag");
assert_eq!(tag, 1650814567);
}
#[test]
fn test_three_chars() {
let tag = from_string("BEN").expect("invalid tag");
assert_eq!(tag, 1111838240);
}
}
mod display_tag {
use crate::tag::{DisplayTag, NAME};
#[test]
fn test_simple_ascii() {
assert_eq!(DisplayTag(NAME).to_string(), "name".to_string());
}
#[test]
fn test_non_ascii() {
assert_eq!(DisplayTag(0x12345678).to_string(), "0x12345678".to_string());
}
#[test]
fn test_debug() {
assert_eq!(format!("{:?}", DisplayTag(NAME)), "name".to_string());
}
}
}
| {
return Err(ParseError::BadValue);
} | conditional_block |
lib.rs | /*!
* This library provides an API client for Diffbot.
*
* Making API requests
* -------------------
*
* There are a handful of different ways to make API calls:
*
* 1. The most basic way to make a request is with the ``call()`` function.
* Everything must be specified for each request.
*
* 2. Use the ``Diffbot`` struct to keep track of your token and API version
* and then use its ``.call()`` method to make API calls. This has the
* advantage that you can specify those things just once and they'll be
* retained.
*
* 3. Instead of making a request in one step, you can make it two steps with
* the ``prepare_request()`` function. This allows you to specify to Diffbot
* certain details of how *it* should make the request. That gives you a
* ``Request`` object.
*
* 4. In the same manner, if you have a ``Diffbot`` struct you can call the
* ``.prepare_request()`` method on it.
*
* Prepared requests
* -----------------
*
* If you use the ``prepare_request()`` function or method, you can tweak the
* request that will be sent to Diffbot. You can alter the User-Agent, Referer
* or Cookie headers that it will send and then call ``.call()`` to make the
* request, or you can call ``.post_body()`` to send the HTML yourself, if it
* is not publicly available to the wider Internet.
*
* Getting data out of the result
* ------------------------------
*
* At present, the successful return value of a request is simply a JSON object,
* a tree map. This *will* make it moderately difficult to work with, but if
* you're determined, it's possible. You'll end up with results like these:
*
* // First of all, you must, of course, have a response to work on.
* let mut response: TreeMap<~str, Json>
* = diffbot::call(..., "article", ...).unwrap();
*
* // Get the title of the article
* let title = match response.pop(&~"title").unwrap() {
* json::String(s) => s,
* _ => unreachable!(),
* };
*
* // Get the URL of each image
* let image_urls: ~[Url] = match response.pop(&~"images").unwrap() {
* json::List(images) => images.move_iter().map(|image| match image {
* json::Object(~mut o) => {
* match o.pop(&~"url").unwrap() {
* json::String(ref s) => from_str(s),
* _ => unreachable!(),
* }
* },
* _ => unreachable!(),
* }),
* _ => unreachable!(),
* }.collect();
*
* (Yep, I'll freely admit that these are clumsier than they might be in another
* language, which might allow something like this:
*
* let response = ...;
*
* let title = response.title;
* let image_urls = [from_str(image.url) for image in response.images];
*
* In time we may get strongly typed interfaces which would be much nicer, but
* for now, you'd need to do that yourself. It can be done with the tools in
* ``extra::serialize``, by the way.)
*/
#[crate_id = "diffbot#1.0"];
#[crate_type = "dylib"];
#[crate_type = "rlib"];
#[doc(html_logo_url = "diffy-d.png",
html_favicon_url = "http://www.diffbot.com/favicon.ico")];
extern mod extra = "extra#0.10-pre";
extern mod http = "http#0.1-pre";
use std::io::net::tcp::TcpStream;
use extra::json;
use extra::url::Url;
use http::client::RequestWriter;
use http::method::{Get, Post};
use http::headers::content_type::MediaType;
/// A convenience type which simply keeps track of a developer token and version
/// number.
///
/// There is no necessity to use this type; you can call ``call()`` directly
/// should you so desire.
#[deriving(Eq, Clone)]
pub struct Diffbot {
/// The developer's token
token: ~str,
/// The API version number
version: uint,
}
// Basic methods
impl Diffbot {
/// Construct a new ``Diffbot`` instance from the passed parameters.
pub fn new(token: ~str, version: uint) -> Diffbot {
Diffbot {
token: token,
version: version,
}
}
/// Make a call to any Diffbot API with the stored token and API version.
///
/// See the ``call()`` function for an explanation of the parameters.
pub fn | (&self, url: &Url, api: &str, fields: &[&str])
-> Result<json::Object, Error> {
call(url, self.token, api, fields, self.version)
}
/// Prepare a request to any Diffbot API with the stored token and API version.
///
/// See the ``call()`` function for an explanation of the parameters.
pub fn prepare_request(&self, url: &Url, api: &str, fields: &[&str])
-> Request {
prepare_request(url, self.token, api, fields, self.version)
}
}
/// An in-progress Diffbot API call.
pub struct Request {
priv request: RequestWriter<TcpStream>,
}
impl Request {
/// Set the value for Diffbot to send as the ``User-Agent`` header when
/// making your request.
pub fn user_agent(&mut self, user_agent: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-User-Agent",
user_agent);
}
/// Set the value for Diffbot to send as the ``Referer`` header when
/// making your request.
pub fn referer(&mut self, referer: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-Referer",
referer);
}
/// Set the value for Diffbot to send as the ``Cookie`` header when
/// making your request.
pub fn cookie(&mut self, cookie: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-Cookie",
cookie);
}
/// Set Diffbot's timeout, in milliseconds. The default is five seconds.
pub fn timeout(&mut self, milliseconds: u64) {
self.request.url.query.push((~"timeout", milliseconds.to_str()));
}
/// Execute the request and get the results.
pub fn call(self) -> Result<json::Object, Error> {
let mut response = match self.request.read_response() {
Ok(response) => response,
Err(_request) => return Err(IoError), // Request failed
};
let json = match json::from_reader(&mut response as &mut Reader) {
Ok(json) => json,
Err(error) => return Err(JsonError(error)), // It... wasn't JSON!?
};
// Now let's see if this is an API error or not.
// API errors are of the form {"error":"Invalid API.","errorCode":500}
match json {
json::Object(~mut o) => {
match o.pop(&~"errorCode") {
Some(json::Number(num)) => {
let num = num as uint;
let msg = match o.pop(&~"error")
.expect("JSON had errorCode but not error") {
json::String(s) => s,
uh_oh => fail!("error was {} instead of a string", uh_oh.to_str()),
};
Err(ApiError(msg, num))
},
Some(uh_oh) => fail!("errorCode was {} instead of a number", uh_oh.to_str()),
None => Ok(o),
}
},
// All API responses must be objects.
// If it's not, there's something screwy going on.
_ => fail!("API return value wasn't a JSON object"),
}
}
/// Execute the request as a POST request, sending it through with the given
/// text/html entity body.
///
/// This has the effect that Diffbot will skip requesting the URL and will
/// instead take the passed body as the HTML it is to check. This is mainly
/// useful for non-public websites.
pub fn post_body(mut self, body: &[u8]) -> Result<json::Object, Error> {
self.request.method = Post;
self.request.headers.content_type = Some(MediaType(~"text", ~"html", ~[]));
self.request.headers.content_length = Some(body.len());
// Calling write_headers is an extra and unnecessary safety guard which
// will cause the task to fail if the request has already started to be
// sent (which would render the three statements above ineffectual)
self.request.write_headers();
self.request.write(body);
self.call()
}
}
/// Error code: "unauthorized token"
pub static UNAUTHORIZED_TOKEN: uint = 401;
/// Error code: "requested page not found"
pub static REQUESTED_PAGE_NOT_FOUND: uint = 404;
/// Error code: "your token has exceeded the allowed number of calls, or has
/// otherwise been throttled for API abuse."
pub static TOKEN_EXCEEDED_OR_THROTTLED: uint = 429;
/// Error code: "error processing the page. Specific information will be
/// returned in the JSON response."
pub static ERROR_PROCESSING: uint = 500;
/// Something went wrong with the Diffbot API call.
#[deriving(Eq)]
pub enum Error {
/// An error code returned by the Diffbot API, with message and code.
/// Refer to http://www.diffbot.com/dev/docs/error/ for an explanation of
/// the error codes.
///
/// When comparing the error code, you should use these constants:
///
/// - ``UNAUTHORIZED_TOKEN``: "unauthorized token"
/// - ``REQUESTED_PAGE_NOT_FOUND``: "requested page not found"
/// - ``TOKEN_EXCEEDED_OR_THROTTLED``: "your token has exceeded the allowed
/// number of calls, or has otherwise been throttled for API abuse."
/// - ``ERROR_PROCESSING``: "error processing the page. Specific information
/// will be returned in the JSON response."
ApiError(~str, uint),
/// The JSON was not valid. This is one of those ones that *should* never
/// happen; you know...
///
/// Actually, I can percieve that it might happen if a document returned
/// included invalid UTF-8, but this case has not been tested.
JsonError(json::Error),
/// An I/O error occurred and the condition was trapped somewhere (by you).
IoError,
}
impl ToStr for Error {
fn to_str(&self) -> ~str {
match *self {
ApiError(ref msg, code) => format!("API error {}: {}", code, *msg),
JsonError(ref error) => format!("JSON error: {}", error.to_str()),
IoError => format!("I/O error (already handled)"),
}
}
}
/// Make a simple Diffbot API call.
///
/// For more complex requests, use ``Diffbot`` or ``prepare_request()``.
///
/// Arguments
/// =========
///
/// - ``url`` is the URL that you wish Diffbot to operate upon. If this is a
/// publicly-inaccessible URL, you should use ``post_body()`` on a prepared
/// request instead of ``call()``.
///
/// - ``token`` is the developer's token.
///
/// - ``api`` is the name of the API endpoint, e.g. "article", "product".
///
/// - ``fields`` is the set of fields you want the API call to return; it
/// follows the form specified by the Diffbot API and so should have values
/// like "*", "meta", "querystring", "images(*)".
///
/// - ``version`` is the Diffbot API version number.
pub fn call(url: &Url, token: &str, api: &str, fields: &[&str], version: uint)
-> Result<json::Object, Error> {
prepare_request(url, token, api, fields, version).call()
}
/// Prepare, but do not send, a request.
///
/// This allows you to use some of the more advanced features of the API like
/// setting certain headers for Diffbot to use, or uploading a private document
/// for it.
pub fn prepare_request(url: &Url, token: &str, api: &str, fields: &[&str],
version: uint)
-> Request {
// First of all we must calculate the GET parameters.
let mut query = ~[(~"token", token.to_owned()),
(~"url", url.to_str())];
if fields.len() > 0 {
query.push((~"fields", fields.connect(",")));
}
// Now that we've got that, we can figure out the complete URL.
let url = Url::new(~"http", // scheme
None, // user
~"api.diffbot.com", // host
None, // port
format!("/v{}/{}", version, api), // path
query, // query
None); // fragment
// And with that, we can now make the request. Whee!
Request {
request: RequestWriter::new(Get, url)
}
}
| call | identifier_name |
lib.rs | /*!
* This library provides an API client for Diffbot.
*
* Making API requests
* -------------------
*
* There are a handful of different ways to make API calls:
*
* 1. The most basic way to make a request is with the ``call()`` function.
* Everything must be specified for each request.
*
* 2. Use the ``Diffbot`` struct to keep track of your token and API version
* and then use its ``.call()`` method to make API calls. This has the
* advantage that you can specify those things just once and they'll be
* retained.
*
* 3. Instead of making a request in one step, you can make it two steps with
* the ``prepare_request()`` function. This allows you to specify to Diffbot
* certain details of how *it* should make the request. That gives you a
* ``Request`` object.
*
* 4. In the same manner, if you have a ``Diffbot`` struct you can call the
* ``.prepare_request()`` method on it.
*
* Prepared requests
* -----------------
*
* If you use the ``prepare_request()`` function or method, you can tweak the
* request that will be sent to Diffbot. You can alter the User-Agent, Referer
* or Cookie headers that it will send and then call ``.call()`` to make the
* request, or you can call ``.post_body()`` to send the HTML yourself, if it
* is not publicly available to the wider Internet.
*
* Getting data out of the result
* ------------------------------
*
* At present, the successful return value of a request is simply a JSON object,
* a tree map. This *will* make it moderately difficult to work with, but if
* you're determined, it's possible. You'll end up with results like these:
*
* // First of all, you must, of course, have a response to work on.
* let mut response: TreeMap<~str, Json>
* = diffbot::call(..., "article", ...).unwrap();
*
* // Get the title of the article
* let title = match response.pop(&~"title").unwrap() {
* json::String(s) => s,
* _ => unreachable!(),
* };
*
* // Get the URL of each image
* let image_urls: ~[Url] = match response.pop(&~"images").unwrap() {
* json::List(images) => images.move_iter().map(|image| match image {
* json::Object(~mut o) => {
* match o.pop(&~"url").unwrap() {
* json::String(ref s) => from_str(s),
* _ => unreachable!(),
* }
* },
* _ => unreachable!(),
* }),
* _ => unreachable!(),
* }.collect();
*
* (Yep, I'll freely admit that these are clumsier than they might be in another
* language, which might allow something like this:
*
* let response = ...;
*
* let title = response.title;
* let image_urls = [from_str(image.url) for image in response.images];
*
* In time we may get strongly typed interfaces which would be much nicer, but
* for now, you'd need to do that yourself. It can be done with the tools in
* ``extra::serialize``, by the way.)
*/
#[crate_id = "diffbot#1.0"];
#[crate_type = "dylib"];
#[crate_type = "rlib"];
#[doc(html_logo_url = "diffy-d.png",
html_favicon_url = "http://www.diffbot.com/favicon.ico")];
extern mod extra = "extra#0.10-pre";
extern mod http = "http#0.1-pre";
use std::io::net::tcp::TcpStream;
use extra::json;
use extra::url::Url;
use http::client::RequestWriter;
use http::method::{Get, Post};
use http::headers::content_type::MediaType;
/// A convenience type which simply keeps track of a developer token and version
/// number.
///
/// There is no necessity to use this type; you can call ``call()`` directly
/// should you so desire.
#[deriving(Eq, Clone)]
pub struct Diffbot {
/// The developer's token
token: ~str,
/// The API version number
version: uint,
}
// Basic methods
impl Diffbot {
/// Construct a new ``Diffbot`` instance from the passed parameters.
pub fn new(token: ~str, version: uint) -> Diffbot {
Diffbot {
token: token,
version: version,
}
}
/// Make a call to any Diffbot API with the stored token and API version.
///
/// See the ``call()`` function for an explanation of the parameters.
pub fn call(&self, url: &Url, api: &str, fields: &[&str])
-> Result<json::Object, Error> {
call(url, self.token, api, fields, self.version)
}
/// Prepare a request to any Diffbot API with the stored token and API version.
///
/// See the ``call()`` function for an explanation of the parameters.
pub fn prepare_request(&self, url: &Url, api: &str, fields: &[&str])
-> Request {
prepare_request(url, self.token, api, fields, self.version)
}
}
/// An in-progress Diffbot API call.
pub struct Request {
priv request: RequestWriter<TcpStream>,
}
impl Request {
/// Set the value for Diffbot to send as the ``User-Agent`` header when
/// making your request.
pub fn user_agent(&mut self, user_agent: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-User-Agent",
user_agent);
}
/// Set the value for Diffbot to send as the ``Referer`` header when
/// making your request.
pub fn referer(&mut self, referer: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-Referer",
referer);
}
/// Set the value for Diffbot to send as the ``Cookie`` header when
/// making your request.
pub fn cookie(&mut self, cookie: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-Cookie",
cookie);
}
/// Set Diffbot's timeout, in milliseconds. The default is five seconds.
pub fn timeout(&mut self, milliseconds: u64) {
self.request.url.query.push((~"timeout", milliseconds.to_str()));
}
/// Execute the request and get the results.
pub fn call(self) -> Result<json::Object, Error> {
let mut response = match self.request.read_response() {
Ok(response) => response,
Err(_request) => return Err(IoError), // Request failed
};
let json = match json::from_reader(&mut response as &mut Reader) {
Ok(json) => json,
Err(error) => return Err(JsonError(error)), // It... wasn't JSON!?
};
// Now let's see if this is an API error or not.
// API errors are of the form {"error":"Invalid API.","errorCode":500} | let num = num as uint;
let msg = match o.pop(&~"error")
.expect("JSON had errorCode but not error") {
json::String(s) => s,
uh_oh => fail!("error was {} instead of a string", uh_oh.to_str()),
};
Err(ApiError(msg, num))
},
Some(uh_oh) => fail!("errorCode was {} instead of a number", uh_oh.to_str()),
None => Ok(o),
}
},
// All API responses must be objects.
// If it's not, there's something screwy going on.
_ => fail!("API return value wasn't a JSON object"),
}
}
/// Execute the request as a POST request, sending it through with the given
/// text/html entity body.
///
/// This has the effect that Diffbot will skip requesting the URL and will
/// instead take the passed body as the HTML it is to check. This is mainly
/// useful for non-public websites.
pub fn post_body(mut self, body: &[u8]) -> Result<json::Object, Error> {
self.request.method = Post;
self.request.headers.content_type = Some(MediaType(~"text", ~"html", ~[]));
self.request.headers.content_length = Some(body.len());
// Calling write_headers is an extra and unnecessary safety guard which
// will cause the task to fail if the request has already started to be
// sent (which would render the three statements above ineffectual)
self.request.write_headers();
self.request.write(body);
self.call()
}
}
/// Error code: "unauthorized token"
pub static UNAUTHORIZED_TOKEN: uint = 401;
/// Error code: "requested page not found"
pub static REQUESTED_PAGE_NOT_FOUND: uint = 404;
/// Error code: "your token has exceeded the allowed number of calls, or has
/// otherwise been throttled for API abuse."
pub static TOKEN_EXCEEDED_OR_THROTTLED: uint = 429;
/// Error code: "error processing the page. Specific information will be
/// returned in the JSON response."
pub static ERROR_PROCESSING: uint = 500;
/// Something went wrong with the Diffbot API call.
#[deriving(Eq)]
pub enum Error {
/// An error code returned by the Diffbot API, with message and code.
/// Refer to http://www.diffbot.com/dev/docs/error/ for an explanation of
/// the error codes.
///
/// When comparing the error code, you should use these constants:
///
/// - ``UNAUTHORIZED_TOKEN``: "unauthorized token"
/// - ``REQUESTED_PAGE_NOT_FOUND``: "requested page not found"
/// - ``TOKEN_EXCEEDED_OR_THROTTLED``: "your token has exceeded the allowed
/// number of calls, or has otherwise been throttled for API abuse."
/// - ``ERROR_PROCESSING``: "error processing the page. Specific information
/// will be returned in the JSON response."
ApiError(~str, uint),
/// The JSON was not valid. This is one of those ones that *should* never
/// happen; you know...
///
/// Actually, I can percieve that it might happen if a document returned
/// included invalid UTF-8, but this case has not been tested.
JsonError(json::Error),
/// An I/O error occurred and the condition was trapped somewhere (by you).
IoError,
}
impl ToStr for Error {
fn to_str(&self) -> ~str {
match *self {
ApiError(ref msg, code) => format!("API error {}: {}", code, *msg),
JsonError(ref error) => format!("JSON error: {}", error.to_str()),
IoError => format!("I/O error (already handled)"),
}
}
}
/// Make a simple Diffbot API call.
///
/// For more complex requests, use ``Diffbot`` or ``prepare_request()``.
///
/// Arguments
/// =========
///
/// - ``url`` is the URL that you wish Diffbot to operate upon. If this is a
/// publicly-inaccessible URL, you should use ``post_body()`` on a prepared
/// request instead of ``call()``.
///
/// - ``token`` is the developer's token.
///
/// - ``api`` is the name of the API endpoint, e.g. "article", "product".
///
/// - ``fields`` is the set of fields you want the API call to return; it
/// follows the form specified by the Diffbot API and so should have values
/// like "*", "meta", "querystring", "images(*)".
///
/// - ``version`` is the Diffbot API version number.
pub fn call(url: &Url, token: &str, api: &str, fields: &[&str], version: uint)
-> Result<json::Object, Error> {
prepare_request(url, token, api, fields, version).call()
}
/// Prepare, but do not send, a request.
///
/// This allows you to use some of the more advanced features of the API like
/// setting certain headers for Diffbot to use, or uploading a private document
/// for it.
pub fn prepare_request(url: &Url, token: &str, api: &str, fields: &[&str],
version: uint)
-> Request {
// First of all we must calculate the GET parameters.
let mut query = ~[(~"token", token.to_owned()),
(~"url", url.to_str())];
if fields.len() > 0 {
query.push((~"fields", fields.connect(",")));
}
// Now that we've got that, we can figure out the complete URL.
let url = Url::new(~"http", // scheme
None, // user
~"api.diffbot.com", // host
None, // port
format!("/v{}/{}", version, api), // path
query, // query
None); // fragment
// And with that, we can now make the request. Whee!
Request {
request: RequestWriter::new(Get, url)
}
} | match json {
json::Object(~mut o) => {
match o.pop(&~"errorCode") {
Some(json::Number(num)) => { | random_line_split |
lib.rs | /*!
* This library provides an API client for Diffbot.
*
* Making API requests
* -------------------
*
* There are a handful of different ways to make API calls:
*
* 1. The most basic way to make a request is with the ``call()`` function.
* Everything must be specified for each request.
*
* 2. Use the ``Diffbot`` struct to keep track of your token and API version
* and then use its ``.call()`` method to make API calls. This has the
* advantage that you can specify those things just once and they'll be
* retained.
*
* 3. Instead of making a request in one step, you can make it two steps with
* the ``prepare_request()`` function. This allows you to specify to Diffbot
* certain details of how *it* should make the request. That gives you a
* ``Request`` object.
*
* 4. In the same manner, if you have a ``Diffbot`` struct you can call the
* ``.prepare_request()`` method on it.
*
* Prepared requests
* -----------------
*
* If you use the ``prepare_request()`` function or method, you can tweak the
* request that will be sent to Diffbot. You can alter the User-Agent, Referer
* or Cookie headers that it will send and then call ``.call()`` to make the
* request, or you can call ``.post_body()`` to send the HTML yourself, if it
* is not publicly available to the wider Internet.
*
* Getting data out of the result
* ------------------------------
*
* At present, the successful return value of a request is simply a JSON object,
* a tree map. This *will* make it moderately difficult to work with, but if
* you're determined, it's possible. You'll end up with results like these:
*
* // First of all, you must, of course, have a response to work on.
* let mut response: TreeMap<~str, Json>
* = diffbot::call(..., "article", ...).unwrap();
*
* // Get the title of the article
* let title = match response.pop(&~"title").unwrap() {
* json::String(s) => s,
* _ => unreachable!(),
* };
*
* // Get the URL of each image
* let image_urls: ~[Url] = match response.pop(&~"images").unwrap() {
* json::List(images) => images.move_iter().map(|image| match image {
* json::Object(~mut o) => {
* match o.pop(&~"url").unwrap() {
* json::String(ref s) => from_str(s),
* _ => unreachable!(),
* }
* },
* _ => unreachable!(),
* }),
* _ => unreachable!(),
* }.collect();
*
* (Yep, I'll freely admit that these are clumsier than they might be in another
* language, which might allow something like this:
*
* let response = ...;
*
* let title = response.title;
* let image_urls = [from_str(image.url) for image in response.images];
*
* In time we may get strongly typed interfaces which would be much nicer, but
* for now, you'd need to do that yourself. It can be done with the tools in
* ``extra::serialize``, by the way.)
*/
#[crate_id = "diffbot#1.0"];
#[crate_type = "dylib"];
#[crate_type = "rlib"];
#[doc(html_logo_url = "diffy-d.png",
html_favicon_url = "http://www.diffbot.com/favicon.ico")];
extern mod extra = "extra#0.10-pre";
extern mod http = "http#0.1-pre";
use std::io::net::tcp::TcpStream;
use extra::json;
use extra::url::Url;
use http::client::RequestWriter;
use http::method::{Get, Post};
use http::headers::content_type::MediaType;
/// A convenience type which simply keeps track of a developer token and version
/// number.
///
/// There is no necessity to use this type; you can call ``call()`` directly
/// should you so desire.
#[deriving(Eq, Clone)]
pub struct Diffbot {
/// The developer's token
token: ~str,
/// The API version number
version: uint,
}
// Basic methods
impl Diffbot {
/// Construct a new ``Diffbot`` instance from the passed parameters.
pub fn new(token: ~str, version: uint) -> Diffbot {
Diffbot {
token: token,
version: version,
}
}
/// Make a call to any Diffbot API with the stored token and API version.
///
/// See the ``call()`` function for an explanation of the parameters.
pub fn call(&self, url: &Url, api: &str, fields: &[&str])
-> Result<json::Object, Error> {
call(url, self.token, api, fields, self.version)
}
/// Prepare a request to any Diffbot API with the stored token and API version.
///
/// See the ``call()`` function for an explanation of the parameters.
pub fn prepare_request(&self, url: &Url, api: &str, fields: &[&str])
-> Request |
}
/// An in-progress Diffbot API call.
pub struct Request {
priv request: RequestWriter<TcpStream>,
}
impl Request {
/// Set the value for Diffbot to send as the ``User-Agent`` header when
/// making your request.
pub fn user_agent(&mut self, user_agent: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-User-Agent",
user_agent);
}
/// Set the value for Diffbot to send as the ``Referer`` header when
/// making your request.
pub fn referer(&mut self, referer: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-Referer",
referer);
}
/// Set the value for Diffbot to send as the ``Cookie`` header when
/// making your request.
pub fn cookie(&mut self, cookie: ~str) {
self.request.headers.extensions.insert(~"X-Forwarded-Cookie",
cookie);
}
/// Set Diffbot's timeout, in milliseconds. The default is five seconds.
pub fn timeout(&mut self, milliseconds: u64) {
self.request.url.query.push((~"timeout", milliseconds.to_str()));
}
/// Execute the request and get the results.
pub fn call(self) -> Result<json::Object, Error> {
let mut response = match self.request.read_response() {
Ok(response) => response,
Err(_request) => return Err(IoError), // Request failed
};
let json = match json::from_reader(&mut response as &mut Reader) {
Ok(json) => json,
Err(error) => return Err(JsonError(error)), // It... wasn't JSON!?
};
// Now let's see if this is an API error or not.
// API errors are of the form {"error":"Invalid API.","errorCode":500}
match json {
json::Object(~mut o) => {
match o.pop(&~"errorCode") {
Some(json::Number(num)) => {
let num = num as uint;
let msg = match o.pop(&~"error")
.expect("JSON had errorCode but not error") {
json::String(s) => s,
uh_oh => fail!("error was {} instead of a string", uh_oh.to_str()),
};
Err(ApiError(msg, num))
},
Some(uh_oh) => fail!("errorCode was {} instead of a number", uh_oh.to_str()),
None => Ok(o),
}
},
// All API responses must be objects.
// If it's not, there's something screwy going on.
_ => fail!("API return value wasn't a JSON object"),
}
}
/// Execute the request as a POST request, sending it through with the given
/// text/html entity body.
///
/// This has the effect that Diffbot will skip requesting the URL and will
/// instead take the passed body as the HTML it is to check. This is mainly
/// useful for non-public websites.
pub fn post_body(mut self, body: &[u8]) -> Result<json::Object, Error> {
self.request.method = Post;
self.request.headers.content_type = Some(MediaType(~"text", ~"html", ~[]));
self.request.headers.content_length = Some(body.len());
// Calling write_headers is an extra and unnecessary safety guard which
// will cause the task to fail if the request has already started to be
// sent (which would render the three statements above ineffectual)
self.request.write_headers();
self.request.write(body);
self.call()
}
}
/// Error code: "unauthorized token"
pub static UNAUTHORIZED_TOKEN: uint = 401;
/// Error code: "requested page not found"
pub static REQUESTED_PAGE_NOT_FOUND: uint = 404;
/// Error code: "your token has exceeded the allowed number of calls, or has
/// otherwise been throttled for API abuse."
pub static TOKEN_EXCEEDED_OR_THROTTLED: uint = 429;
/// Error code: "error processing the page. Specific information will be
/// returned in the JSON response."
pub static ERROR_PROCESSING: uint = 500;
/// Something went wrong with the Diffbot API call.
#[deriving(Eq)]
pub enum Error {
/// An error code returned by the Diffbot API, with message and code.
/// Refer to http://www.diffbot.com/dev/docs/error/ for an explanation of
/// the error codes.
///
/// When comparing the error code, you should use these constants:
///
/// - ``UNAUTHORIZED_TOKEN``: "unauthorized token"
/// - ``REQUESTED_PAGE_NOT_FOUND``: "requested page not found"
/// - ``TOKEN_EXCEEDED_OR_THROTTLED``: "your token has exceeded the allowed
/// number of calls, or has otherwise been throttled for API abuse."
/// - ``ERROR_PROCESSING``: "error processing the page. Specific information
/// will be returned in the JSON response."
ApiError(~str, uint),
/// The JSON was not valid. This is one of those ones that *should* never
/// happen; you know...
///
/// Actually, I can percieve that it might happen if a document returned
/// included invalid UTF-8, but this case has not been tested.
JsonError(json::Error),
/// An I/O error occurred and the condition was trapped somewhere (by you).
IoError,
}
impl ToStr for Error {
fn to_str(&self) -> ~str {
match *self {
ApiError(ref msg, code) => format!("API error {}: {}", code, *msg),
JsonError(ref error) => format!("JSON error: {}", error.to_str()),
IoError => format!("I/O error (already handled)"),
}
}
}
/// Make a simple Diffbot API call.
///
/// For more complex requests, use ``Diffbot`` or ``prepare_request()``.
///
/// Arguments
/// =========
///
/// - ``url`` is the URL that you wish Diffbot to operate upon. If this is a
/// publicly-inaccessible URL, you should use ``post_body()`` on a prepared
/// request instead of ``call()``.
///
/// - ``token`` is the developer's token.
///
/// - ``api`` is the name of the API endpoint, e.g. "article", "product".
///
/// - ``fields`` is the set of fields you want the API call to return; it
/// follows the form specified by the Diffbot API and so should have values
/// like "*", "meta", "querystring", "images(*)".
///
/// - ``version`` is the Diffbot API version number.
pub fn call(url: &Url, token: &str, api: &str, fields: &[&str], version: uint)
-> Result<json::Object, Error> {
prepare_request(url, token, api, fields, version).call()
}
/// Prepare, but do not send, a request.
///
/// This allows you to use some of the more advanced features of the API like
/// setting certain headers for Diffbot to use, or uploading a private document
/// for it.
pub fn prepare_request(url: &Url, token: &str, api: &str, fields: &[&str],
version: uint)
-> Request {
// First of all we must calculate the GET parameters.
let mut query = ~[(~"token", token.to_owned()),
(~"url", url.to_str())];
if fields.len() > 0 {
query.push((~"fields", fields.connect(",")));
}
// Now that we've got that, we can figure out the complete URL.
let url = Url::new(~"http", // scheme
None, // user
~"api.diffbot.com", // host
None, // port
format!("/v{}/{}", version, api), // path
query, // query
None); // fragment
// And with that, we can now make the request. Whee!
Request {
request: RequestWriter::new(Get, url)
}
}
| {
prepare_request(url, self.token, api, fields, self.version)
} | identifier_body |
main.rs | use std::time;
use vulkano::instance::Instance;
use vulkano::instance::PhysicalDevice;
use vulkano::pipeline::GraphicsPipeline;
use vulkano::pipeline::viewport::Viewport;
use vulkano::device::Device;
use vulkano::device::Features;
use vulkano::device::RawDeviceExtensions;
use vulkano::framebuffer::{
Framebuffer,
FramebufferAbstract,
Subpass,
RenderPassAbstract
};
use vulkano::image::SwapchainImage;
use vulkano::sampler::{
Sampler,
SamplerAddressMode,
Filter,
MipmapMode
};
use vulkano::buffer::BufferUsage;
use vulkano::buffer::CpuAccessibleBuffer;
use vulkano::command_buffer::{
AutoCommandBufferBuilder,
DynamicState
};
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use std::sync::Arc;
// use vulkano::pipeline::ComputePipeline;
use vulkano::sync;
use vulkano::sync::{
GpuFuture,
FlushError
};
use vulkano::format::Format;
use vulkano::image::{
Dimensions,
ImmutableImage,
};
// use rand::{
// thread_rng,
// Rng
// };
use image::{
GenericImageView,
};
use vulkano_win::VkSurfaceBuild;
use winit::{
EventsLoop,
WindowBuilder,
Window,
Event,
WindowEvent
};
use vulkano::swapchain;
use vulkano::swapchain::{
AcquireError,
Swapchain,
SurfaceTransform,
PresentMode,
SwapchainCreationError
};
mod cs {
vulkano_shaders::shader! {
ty: "compute",
path: "./src/shader/particle_update.cp.glsl"
}
}
#[derive(Copy, Clone, Debug)]
struct Particle {
pos: [f32; 2],
speed: [f32; 2],
tail: [f32; 2],
prev_pos: [f32; 2],
prev_tail: [f32; 2],
}
// struct ImageDataIterator<P> {
// originalIterator: image::buffer::Pie,
// length: usize
// }
//
// impl<T> ImageDataIterator<T> {
// fn from_dynamic_image(img: &DynamicImage) -> ImageDataIterator<T> {
// let dimensions = img.dimensions();
//
// ImageDataIterator {
// originalIterator: img.to_rgba().pixels(),
// length: ( dimensions.0 * dimensions.1 ) as usize
// }
// }
// }
//
// impl<'a, T> Iterator for ImageDataIterator<'a, T> {
// type Item = [u8; 4];
// fn next(&mut self) -> Option<[u8; 4]> {
// return match self.originalIterator.next() {
// Some(pixel) => {
// let rgba = pixel.2;
// let data: [u8; 4] = [ rgba[0], rgba[1], rgba[2], rgba[3] ];
// return Some(data);
// },
// None => None
// }
// }
// }
//
// impl<'a, T> ExactSizeIterator for ImageDataIterator<'a, T> {
// fn len(&self) -> usize {
// return self.length;
// }
// }
fn | () {
let img = match image::open("./media/autumn.png") {
Ok(image) => image,
Err(err) => panic!("{:?}", err)
};
{ // stdout image info
println!("color {:?}", img.color());
println!("dimensions {:?}", img.dimensions());
// println!("first pixel {:?}", img.pixels().next().unwrap());
// println!("first pixel {:?}", img.pixels().next().map(|item| item.2).unwrap());
}
let instance = {
let inst_exts = vulkano_win::required_extensions();
Instance::new(None, &inst_exts, None).expect("failed to create instance")
};
//TODO: list devices, choose based on user input
for p in PhysicalDevice::enumerate(&instance) {
print!("{}", p.name());
println!(", driver version: {}", p.driver_version());
}
let physical = PhysicalDevice::enumerate(&instance)
.next()
.expect("no device available");
let queue_family = physical
.queue_families()
.find(|&q| q.supports_graphics())
.expect("couldn't find a graphical queue family");
let (device, mut queues) = {
let unraw_dev_exts = vulkano::device::DeviceExtensions {
khr_swapchain: true,
.. vulkano::device::DeviceExtensions::none()
};
let mut all_dev_exts = RawDeviceExtensions::from(&unraw_dev_exts);
all_dev_exts.insert(std::ffi::CString::new("VK_KHR_storage_buffer_storage_class").unwrap());
Device::new(
physical,
&Features::none(),
all_dev_exts,
[(queue_family, 0.5)].iter().cloned(),
)
.expect("failed to create device")
};
let queue = queues.next().unwrap();
// let particles = init_particles_buffer();
// let particles_buffer =
// CpuAccessibleBuffer::from_data(device.clone(), BufferUsage::all(), particles)
// .expect("failed to create buffer");
// let shader = cs::Shader::load(device.clone()).expect("failed to create shader module");
// let compute_pipeline = Arc::new(
// ComputePipeline::new(device.clone(), &shader.main_entry_point(), &())
// .expect("failed to create compute pipeline"),
// );
// let set = Arc::new(
// PersistentDescriptorSet::start(compute_pipeline.clone(), 0)
// .add_buffer(particles_buffer.clone())
// .unwrap()
// .build()
// .unwrap(),
// );
// let command_buffer = AutoCommandBufferBuilder::new(device.clone(), queue.family())
// .unwrap()
// .dispatch([PARTICLE_COUNT as u32 / 32, 1, 1], compute_pipeline.clone(), set.clone(), ())
// .unwrap()
// .build()
// .unwrap();
let mut events_loop = EventsLoop::new();
let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap();
let window = surface.window();
let (mut swapchain, images) = {
let caps = surface.capabilities(physical)
.expect("failed to get surface capabilities");
let usage = caps.supported_usage_flags;
let alpha = caps.supported_composite_alpha.iter().next().unwrap();
let format = caps.supported_formats[0].0;
caps.supported_formats.iter().for_each(|sth| println!("{:?}", sth));
let initial_dimensions = if let Some(dimensions) = window.get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} else {
return;
};
Swapchain::new(device.clone(), surface.clone(),
caps.min_image_count, format, initial_dimensions, 1, usage, &queue,
SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None)
.expect("failed to create swapchain")
};
#[derive(Default, Debug, Clone)]
struct Vertex {
position: [f32; 2]
}
let vertex_buffer = {
vulkano::impl_vertex!(Vertex, position);
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), [
Vertex { position: [-0.5, -0.5] },
Vertex { position: [ 0.5, -0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, 0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, -0.5] },
].iter().cloned()).unwrap()
};
// texture
let img_dim = img.dimensions();
let (autumn_texture, autumn_texture_future) = match ImmutableImage::from_iter(
img.as_rgba8().unwrap().pixels().map(|rgba| {
let bytes : [u8; 4] = [rgba[0], rgba[1], rgba[2], rgba[3]];
bytes
}),
Dimensions::Dim2d { width: img_dim.0, height: img_dim.1 },
Format::R8G8B8A8Unorm,
queue.clone()
) {
Ok(i) => i,
Err(err) => panic!("{:?}", err)
};
let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
mod square_vs {
vulkano_shaders::shader!{
ty: "vertex",
path: "./src/shader/square.vs.glsl"
}
}
mod square_fs {
vulkano_shaders::shader!{
ty: "fragment",
path: "./src/shader/square.fs.glsl"
}
}
let square_vs = square_vs::Shader::load(device.clone()).unwrap();
let square_fs = square_fs::Shader::load(device.clone()).unwrap();
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
device.clone(),
attachments: {
color: {
load: Clear,
store: Store,
format: swapchain.format(),
samples: 1,
}
},
pass: {
color: [color],
depth_stencil: {}
}
).unwrap());
let pipeline = Arc::new(GraphicsPipeline::start()
.vertex_input_single_buffer::<Vertex>()
.vertex_shader(square_vs.main_entry_point(), ())
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.fragment_shader(square_fs.main_entry_point(), ())
.blend_alpha_blending()
.render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
.build(device.clone())
.unwrap());
let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0)
.add_sampled_image(autumn_texture.clone(), sampler.clone()).unwrap()
.build().unwrap()
);
let mut dynamic_state = DynamicState {
line_width: None,
viewports: None,
scissors: None,
compare_mask: None,
write_mask: None,
reference: None
};
let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut dynamic_state);
let mut recreate_swapchain = false;
let mut previous_frame_end = Box::new(sync::now(device.clone()).join(autumn_texture_future)) as Box<dyn GpuFuture>;
let t0 = time::SystemTime::now();
let mut now = t0;
let mut then;
loop {
previous_frame_end.cleanup_finished();
if recreate_swapchain {
let dimensions = if let Some(dimensions) = window.get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} else {
return ;
};
let (new_swapchain, new_images) = match swapchain.recreate_with_dimension(dimensions) {
Ok(r) => r,
Err(SwapchainCreationError::UnsupportedDimensions) => continue,
Err(err) => panic!("{:?}", err)
};
swapchain = new_swapchain;
framebuffers = window_size_dependent_setup(&new_images, render_pass.clone(), &mut dynamic_state);
recreate_swapchain = false;
}
let (image_num, acquire_future) = match swapchain::acquire_next_image(swapchain.clone(), None){
Ok(r) => r,
Err(AcquireError::OutOfDate) => {
recreate_swapchain = true;
continue;
},
Err(err) => panic!("{:?}", err)
};
if image_num > 2 {
recreate_swapchain = true;
continue;
} // ugly workaround for a situation when image_num is out of bounds
then = now;
now = time::SystemTime::now();
let time = now.duration_since(t0).unwrap().as_millis() as i32;
let dtime = now.duration_since(then).unwrap().as_millis() as i32;
let push_constants = square_fs::ty::PushConstantData {
time,
dtime
};
let clear_values = vec!([0.0, 0.0, 0.0, 1.0].into());
let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(
device.clone(),
queue.family()
)
.unwrap()
.begin_render_pass(framebuffers[image_num].clone(), false, clear_values)
.unwrap()
.draw(
pipeline.clone(),
&dynamic_state,
vertex_buffer.clone(),
set.clone(),
push_constants)
.unwrap()
.end_render_pass()
.unwrap()
.build()
.unwrap();
let future = previous_frame_end.join(acquire_future)
.then_execute(queue.clone(), command_buffer).unwrap()
.then_swapchain_present(queue.clone(), swapchain.clone(), image_num)
.then_signal_fence_and_flush();
match future {
Ok(future) => {
future.wait(None).unwrap();
previous_frame_end = Box::new(future) as Box<_>;
}
Err(FlushError::OutOfDate) => {
recreate_swapchain = true;
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
Err(e) => {
println!("{:?}", e);
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
}
let mut done = false;
events_loop.poll_events(|event| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true,
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true,
_ => ()
}
});
if done { return; }
}
}
// fn init_particles_buffer() -> [Particle; PARTICLE_COUNT] {
// let mut rng = thread_rng();
// let mut particles = [Particle {
// pos: [0.0, 0.0],
// tail: [0.0, 0.0],
// speed: [0.0, 0.0],
// prev_pos: [0.0, 0.0],
// prev_tail: [0.0, 0.0],
// }; PARTICLE_COUNT];
// for i in 0..particles.len() {
// particles[i].pos = [rng.gen_range(-1.0, 1.0), rng.gen_range(-1.0, 1.0)];
// particles[i].tail = particles[i].pos.clone();
// particles[i].speed = [rng.gen_range(-0.1, 0.1), rng.gen_range(-0.1, 0.1)];
// }
// return particles;
// }
fn window_size_dependent_setup(
images: &[Arc<SwapchainImage<Window>>],
render_pass: Arc<dyn RenderPassAbstract + Send + Sync>,
dynamic_state: &mut DynamicState
) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
let dimensions = images[0].dimensions();
let viewport = Viewport {
origin: [0.0, 0.0],
dimensions: [dimensions[0] as f32, dimensions[1] as f32],
depth_range: 0.0 .. 1.0,
};
dynamic_state.viewports = Some(vec!(viewport));
images.iter().map(|image| {
Arc::new(
Framebuffer::start(render_pass.clone())
.add(image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>
}).collect::<Vec<_>>()
}
| main | identifier_name |
main.rs | use std::time;
use vulkano::instance::Instance;
use vulkano::instance::PhysicalDevice;
use vulkano::pipeline::GraphicsPipeline;
use vulkano::pipeline::viewport::Viewport;
use vulkano::device::Device;
use vulkano::device::Features;
use vulkano::device::RawDeviceExtensions;
use vulkano::framebuffer::{
Framebuffer,
FramebufferAbstract,
Subpass,
RenderPassAbstract
};
use vulkano::image::SwapchainImage;
use vulkano::sampler::{
Sampler,
SamplerAddressMode,
Filter,
MipmapMode
};
use vulkano::buffer::BufferUsage;
use vulkano::buffer::CpuAccessibleBuffer;
use vulkano::command_buffer::{
AutoCommandBufferBuilder,
DynamicState
};
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use std::sync::Arc;
// use vulkano::pipeline::ComputePipeline;
use vulkano::sync;
use vulkano::sync::{
GpuFuture,
FlushError
};
use vulkano::format::Format;
use vulkano::image::{
Dimensions,
ImmutableImage,
};
// use rand::{
// thread_rng,
// Rng
// };
use image::{
GenericImageView,
};
use vulkano_win::VkSurfaceBuild;
use winit::{
EventsLoop,
WindowBuilder,
Window,
Event,
WindowEvent
};
use vulkano::swapchain;
use vulkano::swapchain::{
AcquireError,
Swapchain,
SurfaceTransform,
PresentMode,
SwapchainCreationError
};
mod cs {
vulkano_shaders::shader! {
ty: "compute",
path: "./src/shader/particle_update.cp.glsl"
}
}
#[derive(Copy, Clone, Debug)]
struct Particle {
pos: [f32; 2],
speed: [f32; 2],
tail: [f32; 2],
prev_pos: [f32; 2],
prev_tail: [f32; 2],
}
// struct ImageDataIterator<P> {
// originalIterator: image::buffer::Pie,
// length: usize
// }
//
// impl<T> ImageDataIterator<T> {
// fn from_dynamic_image(img: &DynamicImage) -> ImageDataIterator<T> {
// let dimensions = img.dimensions();
//
// ImageDataIterator {
// originalIterator: img.to_rgba().pixels(),
// length: ( dimensions.0 * dimensions.1 ) as usize
// }
// }
// }
//
// impl<'a, T> Iterator for ImageDataIterator<'a, T> {
// type Item = [u8; 4];
// fn next(&mut self) -> Option<[u8; 4]> {
// return match self.originalIterator.next() {
// Some(pixel) => {
// let rgba = pixel.2;
// let data: [u8; 4] = [ rgba[0], rgba[1], rgba[2], rgba[3] ];
// return Some(data);
// },
// None => None
// }
// }
// }
//
// impl<'a, T> ExactSizeIterator for ImageDataIterator<'a, T> {
// fn len(&self) -> usize {
// return self.length;
// }
// }
fn main() {
let img = match image::open("./media/autumn.png") {
Ok(image) => image,
Err(err) => panic!("{:?}", err)
};
{ // stdout image info
println!("color {:?}", img.color());
println!("dimensions {:?}", img.dimensions());
// println!("first pixel {:?}", img.pixels().next().unwrap());
// println!("first pixel {:?}", img.pixels().next().map(|item| item.2).unwrap());
}
let instance = {
let inst_exts = vulkano_win::required_extensions();
Instance::new(None, &inst_exts, None).expect("failed to create instance")
};
//TODO: list devices, choose based on user input
for p in PhysicalDevice::enumerate(&instance) {
print!("{}", p.name());
println!(", driver version: {}", p.driver_version());
}
let physical = PhysicalDevice::enumerate(&instance)
.next()
.expect("no device available");
let queue_family = physical
.queue_families()
.find(|&q| q.supports_graphics())
.expect("couldn't find a graphical queue family");
let (device, mut queues) = {
let unraw_dev_exts = vulkano::device::DeviceExtensions {
khr_swapchain: true,
.. vulkano::device::DeviceExtensions::none()
};
let mut all_dev_exts = RawDeviceExtensions::from(&unraw_dev_exts);
all_dev_exts.insert(std::ffi::CString::new("VK_KHR_storage_buffer_storage_class").unwrap());
Device::new(
physical,
&Features::none(),
all_dev_exts,
[(queue_family, 0.5)].iter().cloned(),
)
.expect("failed to create device")
};
let queue = queues.next().unwrap();
// let particles = init_particles_buffer();
// let particles_buffer =
// CpuAccessibleBuffer::from_data(device.clone(), BufferUsage::all(), particles)
// .expect("failed to create buffer");
// let shader = cs::Shader::load(device.clone()).expect("failed to create shader module");
// let compute_pipeline = Arc::new(
// ComputePipeline::new(device.clone(), &shader.main_entry_point(), &())
// .expect("failed to create compute pipeline"),
// );
// let set = Arc::new(
// PersistentDescriptorSet::start(compute_pipeline.clone(), 0)
// .add_buffer(particles_buffer.clone())
// .unwrap()
// .build()
// .unwrap(),
// );
// let command_buffer = AutoCommandBufferBuilder::new(device.clone(), queue.family())
// .unwrap()
// .dispatch([PARTICLE_COUNT as u32 / 32, 1, 1], compute_pipeline.clone(), set.clone(), ())
// .unwrap()
// .build()
// .unwrap();
let mut events_loop = EventsLoop::new();
let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap();
let window = surface.window();
let (mut swapchain, images) = {
let caps = surface.capabilities(physical)
.expect("failed to get surface capabilities");
let usage = caps.supported_usage_flags;
let alpha = caps.supported_composite_alpha.iter().next().unwrap();
let format = caps.supported_formats[0].0;
caps.supported_formats.iter().for_each(|sth| println!("{:?}", sth));
let initial_dimensions = if let Some(dimensions) = window.get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} else {
return;
};
Swapchain::new(device.clone(), surface.clone(),
caps.min_image_count, format, initial_dimensions, 1, usage, &queue,
SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None)
.expect("failed to create swapchain")
};
#[derive(Default, Debug, Clone)]
struct Vertex {
position: [f32; 2]
}
let vertex_buffer = {
vulkano::impl_vertex!(Vertex, position);
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), [
Vertex { position: [-0.5, -0.5] },
Vertex { position: [ 0.5, -0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, 0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, -0.5] },
].iter().cloned()).unwrap()
};
// texture
let img_dim = img.dimensions();
let (autumn_texture, autumn_texture_future) = match ImmutableImage::from_iter(
img.as_rgba8().unwrap().pixels().map(|rgba| {
let bytes : [u8; 4] = [rgba[0], rgba[1], rgba[2], rgba[3]];
bytes
}),
Dimensions::Dim2d { width: img_dim.0, height: img_dim.1 },
Format::R8G8B8A8Unorm,
queue.clone()
) {
Ok(i) => i,
Err(err) => panic!("{:?}", err)
};
let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
mod square_vs {
vulkano_shaders::shader!{
ty: "vertex",
path: "./src/shader/square.vs.glsl"
}
}
mod square_fs {
vulkano_shaders::shader!{
ty: "fragment",
path: "./src/shader/square.fs.glsl"
}
}
let square_vs = square_vs::Shader::load(device.clone()).unwrap();
let square_fs = square_fs::Shader::load(device.clone()).unwrap();
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
device.clone(),
attachments: {
color: {
load: Clear,
store: Store,
format: swapchain.format(),
samples: 1,
}
},
pass: {
color: [color],
depth_stencil: {}
}
).unwrap());
let pipeline = Arc::new(GraphicsPipeline::start()
.vertex_input_single_buffer::<Vertex>()
.vertex_shader(square_vs.main_entry_point(), ())
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.fragment_shader(square_fs.main_entry_point(), ())
.blend_alpha_blending()
.render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
.build(device.clone())
.unwrap());
let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0)
.add_sampled_image(autumn_texture.clone(), sampler.clone()).unwrap()
.build().unwrap()
);
let mut dynamic_state = DynamicState {
line_width: None,
viewports: None,
scissors: None,
compare_mask: None,
write_mask: None,
reference: None
};
let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut dynamic_state);
let mut recreate_swapchain = false;
let mut previous_frame_end = Box::new(sync::now(device.clone()).join(autumn_texture_future)) as Box<dyn GpuFuture>;
let t0 = time::SystemTime::now();
let mut now = t0;
let mut then;
loop {
previous_frame_end.cleanup_finished();
if recreate_swapchain {
let dimensions = if let Some(dimensions) = window.get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} else {
return ;
};
let (new_swapchain, new_images) = match swapchain.recreate_with_dimension(dimensions) {
Ok(r) => r,
Err(SwapchainCreationError::UnsupportedDimensions) => continue, |
swapchain = new_swapchain;
framebuffers = window_size_dependent_setup(&new_images, render_pass.clone(), &mut dynamic_state);
recreate_swapchain = false;
}
let (image_num, acquire_future) = match swapchain::acquire_next_image(swapchain.clone(), None){
Ok(r) => r,
Err(AcquireError::OutOfDate) => {
recreate_swapchain = true;
continue;
},
Err(err) => panic!("{:?}", err)
};
if image_num > 2 {
recreate_swapchain = true;
continue;
} // ugly workaround for a situation when image_num is out of bounds
then = now;
now = time::SystemTime::now();
let time = now.duration_since(t0).unwrap().as_millis() as i32;
let dtime = now.duration_since(then).unwrap().as_millis() as i32;
let push_constants = square_fs::ty::PushConstantData {
time,
dtime
};
let clear_values = vec!([0.0, 0.0, 0.0, 1.0].into());
let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(
device.clone(),
queue.family()
)
.unwrap()
.begin_render_pass(framebuffers[image_num].clone(), false, clear_values)
.unwrap()
.draw(
pipeline.clone(),
&dynamic_state,
vertex_buffer.clone(),
set.clone(),
push_constants)
.unwrap()
.end_render_pass()
.unwrap()
.build()
.unwrap();
let future = previous_frame_end.join(acquire_future)
.then_execute(queue.clone(), command_buffer).unwrap()
.then_swapchain_present(queue.clone(), swapchain.clone(), image_num)
.then_signal_fence_and_flush();
match future {
Ok(future) => {
future.wait(None).unwrap();
previous_frame_end = Box::new(future) as Box<_>;
}
Err(FlushError::OutOfDate) => {
recreate_swapchain = true;
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
Err(e) => {
println!("{:?}", e);
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
}
let mut done = false;
events_loop.poll_events(|event| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true,
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true,
_ => ()
}
});
if done { return; }
}
}
// fn init_particles_buffer() -> [Particle; PARTICLE_COUNT] {
// let mut rng = thread_rng();
// let mut particles = [Particle {
// pos: [0.0, 0.0],
// tail: [0.0, 0.0],
// speed: [0.0, 0.0],
// prev_pos: [0.0, 0.0],
// prev_tail: [0.0, 0.0],
// }; PARTICLE_COUNT];
// for i in 0..particles.len() {
// particles[i].pos = [rng.gen_range(-1.0, 1.0), rng.gen_range(-1.0, 1.0)];
// particles[i].tail = particles[i].pos.clone();
// particles[i].speed = [rng.gen_range(-0.1, 0.1), rng.gen_range(-0.1, 0.1)];
// }
// return particles;
// }
fn window_size_dependent_setup(
images: &[Arc<SwapchainImage<Window>>],
render_pass: Arc<dyn RenderPassAbstract + Send + Sync>,
dynamic_state: &mut DynamicState
) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
let dimensions = images[0].dimensions();
let viewport = Viewport {
origin: [0.0, 0.0],
dimensions: [dimensions[0] as f32, dimensions[1] as f32],
depth_range: 0.0 .. 1.0,
};
dynamic_state.viewports = Some(vec!(viewport));
images.iter().map(|image| {
Arc::new(
Framebuffer::start(render_pass.clone())
.add(image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>
}).collect::<Vec<_>>()
} | Err(err) => panic!("{:?}", err)
}; | random_line_split |
main.rs | use std::time;
use vulkano::instance::Instance;
use vulkano::instance::PhysicalDevice;
use vulkano::pipeline::GraphicsPipeline;
use vulkano::pipeline::viewport::Viewport;
use vulkano::device::Device;
use vulkano::device::Features;
use vulkano::device::RawDeviceExtensions;
use vulkano::framebuffer::{
Framebuffer,
FramebufferAbstract,
Subpass,
RenderPassAbstract
};
use vulkano::image::SwapchainImage;
use vulkano::sampler::{
Sampler,
SamplerAddressMode,
Filter,
MipmapMode
};
use vulkano::buffer::BufferUsage;
use vulkano::buffer::CpuAccessibleBuffer;
use vulkano::command_buffer::{
AutoCommandBufferBuilder,
DynamicState
};
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use std::sync::Arc;
// use vulkano::pipeline::ComputePipeline;
use vulkano::sync;
use vulkano::sync::{
GpuFuture,
FlushError
};
use vulkano::format::Format;
use vulkano::image::{
Dimensions,
ImmutableImage,
};
// use rand::{
// thread_rng,
// Rng
// };
use image::{
GenericImageView,
};
use vulkano_win::VkSurfaceBuild;
use winit::{
EventsLoop,
WindowBuilder,
Window,
Event,
WindowEvent
};
use vulkano::swapchain;
use vulkano::swapchain::{
AcquireError,
Swapchain,
SurfaceTransform,
PresentMode,
SwapchainCreationError
};
mod cs {
vulkano_shaders::shader! {
ty: "compute",
path: "./src/shader/particle_update.cp.glsl"
}
}
#[derive(Copy, Clone, Debug)]
struct Particle {
pos: [f32; 2],
speed: [f32; 2],
tail: [f32; 2],
prev_pos: [f32; 2],
prev_tail: [f32; 2],
}
// struct ImageDataIterator<P> {
// originalIterator: image::buffer::Pie,
// length: usize
// }
//
// impl<T> ImageDataIterator<T> {
// fn from_dynamic_image(img: &DynamicImage) -> ImageDataIterator<T> {
// let dimensions = img.dimensions();
//
// ImageDataIterator {
// originalIterator: img.to_rgba().pixels(),
// length: ( dimensions.0 * dimensions.1 ) as usize
// }
// }
// }
//
// impl<'a, T> Iterator for ImageDataIterator<'a, T> {
// type Item = [u8; 4];
// fn next(&mut self) -> Option<[u8; 4]> {
// return match self.originalIterator.next() {
// Some(pixel) => {
// let rgba = pixel.2;
// let data: [u8; 4] = [ rgba[0], rgba[1], rgba[2], rgba[3] ];
// return Some(data);
// },
// None => None
// }
// }
// }
//
// impl<'a, T> ExactSizeIterator for ImageDataIterator<'a, T> {
// fn len(&self) -> usize {
// return self.length;
// }
// }
fn main() |
// fn init_particles_buffer() -> [Particle; PARTICLE_COUNT] {
// let mut rng = thread_rng();
// let mut particles = [Particle {
// pos: [0.0, 0.0],
// tail: [0.0, 0.0],
// speed: [0.0, 0.0],
// prev_pos: [0.0, 0.0],
// prev_tail: [0.0, 0.0],
// }; PARTICLE_COUNT];
// for i in 0..particles.len() {
// particles[i].pos = [rng.gen_range(-1.0, 1.0), rng.gen_range(-1.0, 1.0)];
// particles[i].tail = particles[i].pos.clone();
// particles[i].speed = [rng.gen_range(-0.1, 0.1), rng.gen_range(-0.1, 0.1)];
// }
// return particles;
// }
fn window_size_dependent_setup(
images: &[Arc<SwapchainImage<Window>>],
render_pass: Arc<dyn RenderPassAbstract + Send + Sync>,
dynamic_state: &mut DynamicState
) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
let dimensions = images[0].dimensions();
let viewport = Viewport {
origin: [0.0, 0.0],
dimensions: [dimensions[0] as f32, dimensions[1] as f32],
depth_range: 0.0 .. 1.0,
};
dynamic_state.viewports = Some(vec!(viewport));
images.iter().map(|image| {
Arc::new(
Framebuffer::start(render_pass.clone())
.add(image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>
}).collect::<Vec<_>>()
}
| {
let img = match image::open("./media/autumn.png") {
Ok(image) => image,
Err(err) => panic!("{:?}", err)
};
{ // stdout image info
println!("color {:?}", img.color());
println!("dimensions {:?}", img.dimensions());
// println!("first pixel {:?}", img.pixels().next().unwrap());
// println!("first pixel {:?}", img.pixels().next().map(|item| item.2).unwrap());
}
let instance = {
let inst_exts = vulkano_win::required_extensions();
Instance::new(None, &inst_exts, None).expect("failed to create instance")
};
//TODO: list devices, choose based on user input
for p in PhysicalDevice::enumerate(&instance) {
print!("{}", p.name());
println!(", driver version: {}", p.driver_version());
}
let physical = PhysicalDevice::enumerate(&instance)
.next()
.expect("no device available");
let queue_family = physical
.queue_families()
.find(|&q| q.supports_graphics())
.expect("couldn't find a graphical queue family");
let (device, mut queues) = {
let unraw_dev_exts = vulkano::device::DeviceExtensions {
khr_swapchain: true,
.. vulkano::device::DeviceExtensions::none()
};
let mut all_dev_exts = RawDeviceExtensions::from(&unraw_dev_exts);
all_dev_exts.insert(std::ffi::CString::new("VK_KHR_storage_buffer_storage_class").unwrap());
Device::new(
physical,
&Features::none(),
all_dev_exts,
[(queue_family, 0.5)].iter().cloned(),
)
.expect("failed to create device")
};
let queue = queues.next().unwrap();
// let particles = init_particles_buffer();
// let particles_buffer =
// CpuAccessibleBuffer::from_data(device.clone(), BufferUsage::all(), particles)
// .expect("failed to create buffer");
// let shader = cs::Shader::load(device.clone()).expect("failed to create shader module");
// let compute_pipeline = Arc::new(
// ComputePipeline::new(device.clone(), &shader.main_entry_point(), &())
// .expect("failed to create compute pipeline"),
// );
// let set = Arc::new(
// PersistentDescriptorSet::start(compute_pipeline.clone(), 0)
// .add_buffer(particles_buffer.clone())
// .unwrap()
// .build()
// .unwrap(),
// );
// let command_buffer = AutoCommandBufferBuilder::new(device.clone(), queue.family())
// .unwrap()
// .dispatch([PARTICLE_COUNT as u32 / 32, 1, 1], compute_pipeline.clone(), set.clone(), ())
// .unwrap()
// .build()
// .unwrap();
let mut events_loop = EventsLoop::new();
let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap();
let window = surface.window();
let (mut swapchain, images) = {
let caps = surface.capabilities(physical)
.expect("failed to get surface capabilities");
let usage = caps.supported_usage_flags;
let alpha = caps.supported_composite_alpha.iter().next().unwrap();
let format = caps.supported_formats[0].0;
caps.supported_formats.iter().for_each(|sth| println!("{:?}", sth));
let initial_dimensions = if let Some(dimensions) = window.get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} else {
return;
};
Swapchain::new(device.clone(), surface.clone(),
caps.min_image_count, format, initial_dimensions, 1, usage, &queue,
SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None)
.expect("failed to create swapchain")
};
#[derive(Default, Debug, Clone)]
struct Vertex {
position: [f32; 2]
}
let vertex_buffer = {
vulkano::impl_vertex!(Vertex, position);
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), [
Vertex { position: [-0.5, -0.5] },
Vertex { position: [ 0.5, -0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, 0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, -0.5] },
].iter().cloned()).unwrap()
};
// texture
let img_dim = img.dimensions();
let (autumn_texture, autumn_texture_future) = match ImmutableImage::from_iter(
img.as_rgba8().unwrap().pixels().map(|rgba| {
let bytes : [u8; 4] = [rgba[0], rgba[1], rgba[2], rgba[3]];
bytes
}),
Dimensions::Dim2d { width: img_dim.0, height: img_dim.1 },
Format::R8G8B8A8Unorm,
queue.clone()
) {
Ok(i) => i,
Err(err) => panic!("{:?}", err)
};
let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
mod square_vs {
vulkano_shaders::shader!{
ty: "vertex",
path: "./src/shader/square.vs.glsl"
}
}
mod square_fs {
vulkano_shaders::shader!{
ty: "fragment",
path: "./src/shader/square.fs.glsl"
}
}
let square_vs = square_vs::Shader::load(device.clone()).unwrap();
let square_fs = square_fs::Shader::load(device.clone()).unwrap();
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
device.clone(),
attachments: {
color: {
load: Clear,
store: Store,
format: swapchain.format(),
samples: 1,
}
},
pass: {
color: [color],
depth_stencil: {}
}
).unwrap());
let pipeline = Arc::new(GraphicsPipeline::start()
.vertex_input_single_buffer::<Vertex>()
.vertex_shader(square_vs.main_entry_point(), ())
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.fragment_shader(square_fs.main_entry_point(), ())
.blend_alpha_blending()
.render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
.build(device.clone())
.unwrap());
let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0)
.add_sampled_image(autumn_texture.clone(), sampler.clone()).unwrap()
.build().unwrap()
);
let mut dynamic_state = DynamicState {
line_width: None,
viewports: None,
scissors: None,
compare_mask: None,
write_mask: None,
reference: None
};
let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut dynamic_state);
let mut recreate_swapchain = false;
let mut previous_frame_end = Box::new(sync::now(device.clone()).join(autumn_texture_future)) as Box<dyn GpuFuture>;
let t0 = time::SystemTime::now();
let mut now = t0;
let mut then;
loop {
previous_frame_end.cleanup_finished();
if recreate_swapchain {
let dimensions = if let Some(dimensions) = window.get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} else {
return ;
};
let (new_swapchain, new_images) = match swapchain.recreate_with_dimension(dimensions) {
Ok(r) => r,
Err(SwapchainCreationError::UnsupportedDimensions) => continue,
Err(err) => panic!("{:?}", err)
};
swapchain = new_swapchain;
framebuffers = window_size_dependent_setup(&new_images, render_pass.clone(), &mut dynamic_state);
recreate_swapchain = false;
}
let (image_num, acquire_future) = match swapchain::acquire_next_image(swapchain.clone(), None){
Ok(r) => r,
Err(AcquireError::OutOfDate) => {
recreate_swapchain = true;
continue;
},
Err(err) => panic!("{:?}", err)
};
if image_num > 2 {
recreate_swapchain = true;
continue;
} // ugly workaround for a situation when image_num is out of bounds
then = now;
now = time::SystemTime::now();
let time = now.duration_since(t0).unwrap().as_millis() as i32;
let dtime = now.duration_since(then).unwrap().as_millis() as i32;
let push_constants = square_fs::ty::PushConstantData {
time,
dtime
};
let clear_values = vec!([0.0, 0.0, 0.0, 1.0].into());
let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(
device.clone(),
queue.family()
)
.unwrap()
.begin_render_pass(framebuffers[image_num].clone(), false, clear_values)
.unwrap()
.draw(
pipeline.clone(),
&dynamic_state,
vertex_buffer.clone(),
set.clone(),
push_constants)
.unwrap()
.end_render_pass()
.unwrap()
.build()
.unwrap();
let future = previous_frame_end.join(acquire_future)
.then_execute(queue.clone(), command_buffer).unwrap()
.then_swapchain_present(queue.clone(), swapchain.clone(), image_num)
.then_signal_fence_and_flush();
match future {
Ok(future) => {
future.wait(None).unwrap();
previous_frame_end = Box::new(future) as Box<_>;
}
Err(FlushError::OutOfDate) => {
recreate_swapchain = true;
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
Err(e) => {
println!("{:?}", e);
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
}
let mut done = false;
events_loop.poll_events(|event| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true,
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true,
_ => ()
}
});
if done { return; }
}
} | identifier_body |
main.rs | use std::time;
use vulkano::instance::Instance;
use vulkano::instance::PhysicalDevice;
use vulkano::pipeline::GraphicsPipeline;
use vulkano::pipeline::viewport::Viewport;
use vulkano::device::Device;
use vulkano::device::Features;
use vulkano::device::RawDeviceExtensions;
use vulkano::framebuffer::{
Framebuffer,
FramebufferAbstract,
Subpass,
RenderPassAbstract
};
use vulkano::image::SwapchainImage;
use vulkano::sampler::{
Sampler,
SamplerAddressMode,
Filter,
MipmapMode
};
use vulkano::buffer::BufferUsage;
use vulkano::buffer::CpuAccessibleBuffer;
use vulkano::command_buffer::{
AutoCommandBufferBuilder,
DynamicState
};
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use std::sync::Arc;
// use vulkano::pipeline::ComputePipeline;
use vulkano::sync;
use vulkano::sync::{
GpuFuture,
FlushError
};
use vulkano::format::Format;
use vulkano::image::{
Dimensions,
ImmutableImage,
};
// use rand::{
// thread_rng,
// Rng
// };
use image::{
GenericImageView,
};
use vulkano_win::VkSurfaceBuild;
use winit::{
EventsLoop,
WindowBuilder,
Window,
Event,
WindowEvent
};
use vulkano::swapchain;
use vulkano::swapchain::{
AcquireError,
Swapchain,
SurfaceTransform,
PresentMode,
SwapchainCreationError
};
mod cs {
vulkano_shaders::shader! {
ty: "compute",
path: "./src/shader/particle_update.cp.glsl"
}
}
#[derive(Copy, Clone, Debug)]
struct Particle {
pos: [f32; 2],
speed: [f32; 2],
tail: [f32; 2],
prev_pos: [f32; 2],
prev_tail: [f32; 2],
}
// struct ImageDataIterator<P> {
// originalIterator: image::buffer::Pie,
// length: usize
// }
//
// impl<T> ImageDataIterator<T> {
// fn from_dynamic_image(img: &DynamicImage) -> ImageDataIterator<T> {
// let dimensions = img.dimensions();
//
// ImageDataIterator {
// originalIterator: img.to_rgba().pixels(),
// length: ( dimensions.0 * dimensions.1 ) as usize
// }
// }
// }
//
// impl<'a, T> Iterator for ImageDataIterator<'a, T> {
// type Item = [u8; 4];
// fn next(&mut self) -> Option<[u8; 4]> {
// return match self.originalIterator.next() {
// Some(pixel) => {
// let rgba = pixel.2;
// let data: [u8; 4] = [ rgba[0], rgba[1], rgba[2], rgba[3] ];
// return Some(data);
// },
// None => None
// }
// }
// }
//
// impl<'a, T> ExactSizeIterator for ImageDataIterator<'a, T> {
// fn len(&self) -> usize {
// return self.length;
// }
// }
fn main() {
let img = match image::open("./media/autumn.png") {
Ok(image) => image,
Err(err) => panic!("{:?}", err)
};
{ // stdout image info
println!("color {:?}", img.color());
println!("dimensions {:?}", img.dimensions());
// println!("first pixel {:?}", img.pixels().next().unwrap());
// println!("first pixel {:?}", img.pixels().next().map(|item| item.2).unwrap());
}
let instance = {
let inst_exts = vulkano_win::required_extensions();
Instance::new(None, &inst_exts, None).expect("failed to create instance")
};
//TODO: list devices, choose based on user input
for p in PhysicalDevice::enumerate(&instance) {
print!("{}", p.name());
println!(", driver version: {}", p.driver_version());
}
let physical = PhysicalDevice::enumerate(&instance)
.next()
.expect("no device available");
let queue_family = physical
.queue_families()
.find(|&q| q.supports_graphics())
.expect("couldn't find a graphical queue family");
let (device, mut queues) = {
let unraw_dev_exts = vulkano::device::DeviceExtensions {
khr_swapchain: true,
.. vulkano::device::DeviceExtensions::none()
};
let mut all_dev_exts = RawDeviceExtensions::from(&unraw_dev_exts);
all_dev_exts.insert(std::ffi::CString::new("VK_KHR_storage_buffer_storage_class").unwrap());
Device::new(
physical,
&Features::none(),
all_dev_exts,
[(queue_family, 0.5)].iter().cloned(),
)
.expect("failed to create device")
};
let queue = queues.next().unwrap();
// let particles = init_particles_buffer();
// let particles_buffer =
// CpuAccessibleBuffer::from_data(device.clone(), BufferUsage::all(), particles)
// .expect("failed to create buffer");
// let shader = cs::Shader::load(device.clone()).expect("failed to create shader module");
// let compute_pipeline = Arc::new(
// ComputePipeline::new(device.clone(), &shader.main_entry_point(), &())
// .expect("failed to create compute pipeline"),
// );
// let set = Arc::new(
// PersistentDescriptorSet::start(compute_pipeline.clone(), 0)
// .add_buffer(particles_buffer.clone())
// .unwrap()
// .build()
// .unwrap(),
// );
// let command_buffer = AutoCommandBufferBuilder::new(device.clone(), queue.family())
// .unwrap()
// .dispatch([PARTICLE_COUNT as u32 / 32, 1, 1], compute_pipeline.clone(), set.clone(), ())
// .unwrap()
// .build()
// .unwrap();
let mut events_loop = EventsLoop::new();
let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap();
let window = surface.window();
let (mut swapchain, images) = {
let caps = surface.capabilities(physical)
.expect("failed to get surface capabilities");
let usage = caps.supported_usage_flags;
let alpha = caps.supported_composite_alpha.iter().next().unwrap();
let format = caps.supported_formats[0].0;
caps.supported_formats.iter().for_each(|sth| println!("{:?}", sth));
let initial_dimensions = if let Some(dimensions) = window.get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} else {
return;
};
Swapchain::new(device.clone(), surface.clone(),
caps.min_image_count, format, initial_dimensions, 1, usage, &queue,
SurfaceTransform::Identity, alpha, PresentMode::Fifo, true, None)
.expect("failed to create swapchain")
};
#[derive(Default, Debug, Clone)]
struct Vertex {
position: [f32; 2]
}
let vertex_buffer = {
vulkano::impl_vertex!(Vertex, position);
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), [
Vertex { position: [-0.5, -0.5] },
Vertex { position: [ 0.5, -0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, 0.5] },
Vertex { position: [-0.5, 0.5] },
Vertex { position: [ 0.5, -0.5] },
].iter().cloned()).unwrap()
};
// texture
let img_dim = img.dimensions();
let (autumn_texture, autumn_texture_future) = match ImmutableImage::from_iter(
img.as_rgba8().unwrap().pixels().map(|rgba| {
let bytes : [u8; 4] = [rgba[0], rgba[1], rgba[2], rgba[3]];
bytes
}),
Dimensions::Dim2d { width: img_dim.0, height: img_dim.1 },
Format::R8G8B8A8Unorm,
queue.clone()
) {
Ok(i) => i,
Err(err) => panic!("{:?}", err)
};
let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
mod square_vs {
vulkano_shaders::shader!{
ty: "vertex",
path: "./src/shader/square.vs.glsl"
}
}
mod square_fs {
vulkano_shaders::shader!{
ty: "fragment",
path: "./src/shader/square.fs.glsl"
}
}
let square_vs = square_vs::Shader::load(device.clone()).unwrap();
let square_fs = square_fs::Shader::load(device.clone()).unwrap();
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
device.clone(),
attachments: {
color: {
load: Clear,
store: Store,
format: swapchain.format(),
samples: 1,
}
},
pass: {
color: [color],
depth_stencil: {}
}
).unwrap());
let pipeline = Arc::new(GraphicsPipeline::start()
.vertex_input_single_buffer::<Vertex>()
.vertex_shader(square_vs.main_entry_point(), ())
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.fragment_shader(square_fs.main_entry_point(), ())
.blend_alpha_blending()
.render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
.build(device.clone())
.unwrap());
let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0)
.add_sampled_image(autumn_texture.clone(), sampler.clone()).unwrap()
.build().unwrap()
);
let mut dynamic_state = DynamicState {
line_width: None,
viewports: None,
scissors: None,
compare_mask: None,
write_mask: None,
reference: None
};
let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut dynamic_state);
let mut recreate_swapchain = false;
let mut previous_frame_end = Box::new(sync::now(device.clone()).join(autumn_texture_future)) as Box<dyn GpuFuture>;
let t0 = time::SystemTime::now();
let mut now = t0;
let mut then;
loop {
previous_frame_end.cleanup_finished();
if recreate_swapchain {
let dimensions = if let Some(dimensions) = window.get_inner_size() | else {
return ;
};
let (new_swapchain, new_images) = match swapchain.recreate_with_dimension(dimensions) {
Ok(r) => r,
Err(SwapchainCreationError::UnsupportedDimensions) => continue,
Err(err) => panic!("{:?}", err)
};
swapchain = new_swapchain;
framebuffers = window_size_dependent_setup(&new_images, render_pass.clone(), &mut dynamic_state);
recreate_swapchain = false;
}
let (image_num, acquire_future) = match swapchain::acquire_next_image(swapchain.clone(), None){
Ok(r) => r,
Err(AcquireError::OutOfDate) => {
recreate_swapchain = true;
continue;
},
Err(err) => panic!("{:?}", err)
};
if image_num > 2 {
recreate_swapchain = true;
continue;
} // ugly workaround for a situation when image_num is out of bounds
then = now;
now = time::SystemTime::now();
let time = now.duration_since(t0).unwrap().as_millis() as i32;
let dtime = now.duration_since(then).unwrap().as_millis() as i32;
let push_constants = square_fs::ty::PushConstantData {
time,
dtime
};
let clear_values = vec!([0.0, 0.0, 0.0, 1.0].into());
let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(
device.clone(),
queue.family()
)
.unwrap()
.begin_render_pass(framebuffers[image_num].clone(), false, clear_values)
.unwrap()
.draw(
pipeline.clone(),
&dynamic_state,
vertex_buffer.clone(),
set.clone(),
push_constants)
.unwrap()
.end_render_pass()
.unwrap()
.build()
.unwrap();
let future = previous_frame_end.join(acquire_future)
.then_execute(queue.clone(), command_buffer).unwrap()
.then_swapchain_present(queue.clone(), swapchain.clone(), image_num)
.then_signal_fence_and_flush();
match future {
Ok(future) => {
future.wait(None).unwrap();
previous_frame_end = Box::new(future) as Box<_>;
}
Err(FlushError::OutOfDate) => {
recreate_swapchain = true;
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
Err(e) => {
println!("{:?}", e);
previous_frame_end = Box::new(sync::now(device.clone())) as Box<_>;
}
}
let mut done = false;
events_loop.poll_events(|event| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => done = true,
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => recreate_swapchain = true,
_ => ()
}
});
if done { return; }
}
}
// fn init_particles_buffer() -> [Particle; PARTICLE_COUNT] {
// let mut rng = thread_rng();
// let mut particles = [Particle {
// pos: [0.0, 0.0],
// tail: [0.0, 0.0],
// speed: [0.0, 0.0],
// prev_pos: [0.0, 0.0],
// prev_tail: [0.0, 0.0],
// }; PARTICLE_COUNT];
// for i in 0..particles.len() {
// particles[i].pos = [rng.gen_range(-1.0, 1.0), rng.gen_range(-1.0, 1.0)];
// particles[i].tail = particles[i].pos.clone();
// particles[i].speed = [rng.gen_range(-0.1, 0.1), rng.gen_range(-0.1, 0.1)];
// }
// return particles;
// }
fn window_size_dependent_setup(
images: &[Arc<SwapchainImage<Window>>],
render_pass: Arc<dyn RenderPassAbstract + Send + Sync>,
dynamic_state: &mut DynamicState
) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
let dimensions = images[0].dimensions();
let viewport = Viewport {
origin: [0.0, 0.0],
dimensions: [dimensions[0] as f32, dimensions[1] as f32],
depth_range: 0.0 .. 1.0,
};
dynamic_state.viewports = Some(vec!(viewport));
images.iter().map(|image| {
Arc::new(
Framebuffer::start(render_pass.clone())
.add(image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>
}).collect::<Vec<_>>()
}
| {
let dimensions: (u32, u32) = dimensions.to_physical(window.get_hidpi_factor()).into();
[dimensions.0, dimensions.1]
} | conditional_block |
body.rs | #![allow(dead_code)]
#![allow(unused_doc_comments)]
/**
* body.rs contains the Body struct and implements methods for it. A body struct contains only the
* position and velocity vectors of the body, other parameters are calculated using methods. A body
* is instantiated using using the Body::new() method, which also determines the type of orbit the
* body has at the same time. orbit_type does not have to be given manually.
*/
use nalgebra::{Matrix3, Vector3};
use std::f64::consts::PI;
use colored::*;
const DAYTOSEC: f64 = 24.0 * 3600.0;
const SOLARGM: f64 = 1.328905188132376e11;
const PI2: f64 = 2.0 * PI;
/**
* OrbitType is used to abstract away some of the functions that depend on
* the type of orbit the body is in, like kepler's equation. That way, you
* can call one function and it will return the correct value
*/
#[derive(Debug)]
pub enum OrbitType {
Circular,
Elliptic,
Parabolic,
Hyperbolic,
}
impl OrbitType {
/// Return the orbit type given the eccentricity, Body::new
/// uses this function to set the orbit type when an instance
/// is constructed
pub fn new(eccentricity: f64) -> OrbitType {
if eccentricity == 0.0 {
return OrbitType::Circular;
} else if eccentricity < 1.0 && eccentricity > 0.0 {
return OrbitType::Elliptic;
} else if eccentricity == 1.0 {
return OrbitType::Parabolic;
} else {
return OrbitType::Hyperbolic;
}
}
}
#[derive(Debug)]
pub struct Body {
pub position: Vector3<f64>,
pub velocity: Vector3<f64>,
pub orbit_type: OrbitType,
}
/* Adds methods to Body struct */
impl Body {
pub fn new(position: Vector3<f64>, velocity: Vector3<f64>) -> Body {
// h and e are used for determining what kind of orbit the body is currently in
let h = position.cross(&velocity);
let e = ((velocity.cross(&h) / SOLARGM) - position.normalize()).norm();
Body {
position: position,
velocity: velocity,
orbit_type: OrbitType::new(e),
}
}
pub fn radial_velocity(&self) -> Vector3<f64> {
(self.velocity.dot(&self.position) / self.position.norm_squared()) * self.position
}
pub fn tangential_velocity(&self) -> Vector3<f64> {
self.omega().cross(&self.position)
}
pub fn true_anomaly(&self) -> f64 {
let e_vec = self.eccentricity_vector();
let posit = self.position.normalize();
let val = e_vec.dot(&posit) / (e_vec.norm() * posit.norm());
if posit.dot(&self.velocity.normalize()) < 0.0 {
return 2.0 * PI - val.acos();
} else {
return val.acos();
}
}
/* points from focus to perigee if I'm not mistaken */
pub fn eccentricity_vector(&self) -> Vector3<f64> {
let veloc = self.velocity;
let posit = self.position;
let h = self.angular_momentum();
(veloc.cross(&h) / SOLARGM) - posit.normalize()
}
pub fn angular_momentum(&self) -> Vector3<f64> {
self.position.cross(&self.velocity)
}
pub fn total_energy(&self) -> f64 {
let posit = self.position.norm();
let veloc = self.velocity.norm();
0.5 * veloc.powi(2) - (SOLARGM / posit)
}
pub fn omega(&self) -> Vector3<f64> {
self.angular_momentum() / self.position.norm_squared()
}
pub fn frame_rotation_rate(&self) -> f64 {
self.omega().norm()
}
pub fn position_at_angle(&self, angle: f64) -> Vector3<f64> {
let e = self.eccentricity();
let numer = self.angular_momentum().norm_squared() / SOLARGM;
let denom = 1_f64 + (e * (angle).cos());
let radius = numer / denom;
Vector3::new(radius, 0.0, 0.0)
}
pub fn velocity_at_angle(&self, angle: f64) -> Vector3<f64> {
let p = self.orbital_parameter();
let e = self.eccentricity();
let h = self.angular_momentum().norm_squared();
Vector3::new(
(h / p) * e * angle.sin(),
(h / p) * (1_f64 + e * angle.cos()),
0.0,
)
}
pub fn | (&self, angle: f64) -> (Vector3<f64>, Vector3<f64>) {
let r = self.position_at_angle(angle);
let v = self.velocity_at_angle(angle);
let tht = angle - self.true_anomaly();
let trans = Matrix3::from_rows(&[
Vector3::new(tht.cos(), -tht.sin(), 0.0).transpose(),
Vector3::new(tht.sin(), tht.cos(), 0.0).transpose(),
Vector3::new(0.0, 0.0, 1.0).transpose(),
]);
(trans * r, trans * v)
}
// Angle to other body, keep getting the wrong thing anyway, tried everything
pub fn angle_to(&self, other: &Body) -> f64 {
(self.position.dot(&other.position) / (self.position.norm() * other.position.norm())).acos()
}
/* Return a transformation matrix constructed from body's orbit in inertial frame */
pub fn make_frame(&self) -> Matrix3<f64> {
let e_r = self.position.normalize();
let e_h = self.angular_momentum().normalize();
let e_tht = e_h.cross(&e_r);
Matrix3::from_rows(&[e_r.transpose(), e_tht.transpose(), e_h.transpose()])
}
pub fn semi_major_axis(&self) -> f64 {
let ang_moment = self.angular_momentum().norm();
let e = self.eccentricity();
ang_moment.powi(2) / (SOLARGM * (1_f64 - e.powi(2)))
}
pub fn orbital_period(&self) -> f64 {
2_f64 * PI * (self.semi_major_axis().powi(3) / SOLARGM).sqrt()
}
pub fn orbital_parameter(&self) -> f64 {
let e = self.eccentricity();
self.semi_major_axis() * (1.0 - e.powi(2))
}
pub fn eccentric_anomaly(&self) -> f64 {
let e = self.eccentricity();
let theta = self.true_anomaly();
2.0 * ((theta / 2.0).tan() / ((1.0 + e) / (1.0 - e)).sqrt()).atan()
}
pub fn time_since_periapsis(&self) -> f64 {
let t_anom = self.true_anomaly();
let e_anom = self.true_to_eccentric(t_anom);
let a = self.semi_major_axis();
let e = self.eccentricity();
(a.powi(3) / SOLARGM).sqrt() * (e_anom - e * e_anom.sin())
}
pub fn eccentricity(&self) -> f64 {
self.eccentricity_vector().norm()
}
pub fn inclination(&self) -> f64 {
let h = self.angular_momentum();
(h[2] / h.norm()).acos() // h[2] is the z component of the vector
}
pub fn ascending_node(&self) -> Vector3<f64> {
let k = Vector3::new(0.0, 0.0, 1.0);
k.cross(&self.angular_momentum())
}
pub fn argument_of_periapsis(&self) -> f64 {
let n = self.ascending_node();
let e = self.eccentricity_vector();
let omega = (n.dot(&e) / (n.norm() * e.norm())).acos();
if e[2] < 0.0 {
PI2 - omega
} else {
omega
}
}
pub fn argument_of_ascending_node(&self) -> f64 {
let n = self.ascending_node();
let n_x = n[0];
let n_y = n[1];
if n_y >= 0.0 {
(n_x / n.norm()).acos()
} else {
PI2 - (n_x / n.norm()).acos()
}
}
pub fn true_to_eccentric(&self, t_anom: f64) -> f64 {
let a = self.semi_major_axis();
let e = self.eccentricity();
let b = a * (1.0 - e.powi(2)).sqrt();
let p = self.orbital_parameter();
let r = p / (1.0 + e * t_anom.cos());
let c = (a * e + r * t_anom.cos()) / a;
let s = (r / b) * t_anom.sin();
return s.atan2(c);
}
pub fn true_anomaly_at_time(&self, time: f64) -> f64 {
let t_peri = self.time_since_periapsis();
let m_anom = self.mean_anomaly((time * DAYTOSEC) + t_peri);
let angle = self.eccentric_from_mean(m_anom);
return PI2 - self.eccentric_to_true_anomaly(angle);
}
/// The eccentric anomaly at a certain time
pub fn eccentric_from_mean(&self, m_anom: f64) -> f64 {
match self.kepler(m_anom) {
Ok(num) => num,
Err(e) => {
eprintln!("{}: {}\n", "Invalid Orbit".red(), e);
return std::f64::NAN;
}
}
}
/// Return the eccentric anomaly using the appropriate Kepler equation
pub fn kepler(&self, m_anom: f64) -> Result<f64, &str> {
let e = self.eccentricity();
match &self.orbit_type {
OrbitType::Elliptic => Ok(elliptic_kepler(m_anom, e)),
OrbitType::Hyperbolic => Ok(hyper_kepler(m_anom, e)),
OrbitType::Circular => Err("cannot use Keler's equation with a circular orbit."),
OrbitType::Parabolic => Err("cannot use Kepler's equation with a parabolic orbit."),
}
}
pub fn eccentric_to_true_anomaly(&self, e_anom: f64) -> f64 {
let e = self.eccentricity();
// let sqrt_val = ((1.0 + e) / (1.0 - e)).sqrt();
// 2.0 * (sqrt_val * (e_anom / 2.0).tan()).atan() + PI2
((e_anom.cos() - e) / (1.0 - e * e_anom.cos())).acos()
}
/// Return the mean anomaly at a certain time from current position
pub fn mean_anomaly(&self, t: f64) -> f64 {
let n = (SOLARGM / self.semi_major_axis().powi(3)).sqrt();
n * t
}
}
/**
* Some of the kepler functions below. Body matches on its orbit type
* and uses the correct function to return the correct eccentric anomaly
*/
fn elliptic_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-200;
let kep = |e: f64| e - eccen * e.sin() - nt;
let kep_d = |e: f64| 1.0 - eccen * e.cos();
let mut e_0 = 0.0;
let mut e = e_0 - (kep(e_0) / kep_d(e_0));
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - (kep(e_0) / kep_d(e_0));
}
return e;
}
fn hyper_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-100;
let kep = |e: f64| eccen * e.sinh() - nt - e;
let kep_d = |e: f64| eccen * e.cosh() - 1.0;
let mut e_0 = nt;
let mut e = e_0 - kep(e_0) / kep_d(e_0);
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - kep(e_0) / kep_d(e_0);
}
return e;
}
pub fn three_one_three_transform(
arg_of_peri: f64,
inclination: f64,
arg_of_AN: f64,
) -> Matrix3<f64> {
let omega = arg_of_peri;
let inc = inclination;
let tht = arg_of_AN;
let m_c = Matrix3::new(
omega.cos(),
omega.sin(),
0.0,
-omega.sin(),
omega.cos(),
0.0,
0.0,
0.0,
1.0,
);
let m_b = Matrix3::new(
1.0,
0.0,
0.0,
0.0,
inc.cos(),
inc.sin(),
0.0,
-inc.sin(),
inc.cos(),
);
let m_a = Matrix3::new(
tht.cos(),
tht.sin(),
0.0,
-tht.sin(),
tht.cos(),
0.0,
0.0,
0.0,
1.0,
);
return m_c * m_b * m_a;
}
| position_and_velocity | identifier_name |
body.rs | #![allow(dead_code)]
#![allow(unused_doc_comments)]
/**
* body.rs contains the Body struct and implements methods for it. A body struct contains only the
* position and velocity vectors of the body, other parameters are calculated using methods. A body
* is instantiated using using the Body::new() method, which also determines the type of orbit the
* body has at the same time. orbit_type does not have to be given manually.
*/
use nalgebra::{Matrix3, Vector3};
use std::f64::consts::PI;
use colored::*;
const DAYTOSEC: f64 = 24.0 * 3600.0;
const SOLARGM: f64 = 1.328905188132376e11;
const PI2: f64 = 2.0 * PI;
/**
* OrbitType is used to abstract away some of the functions that depend on
* the type of orbit the body is in, like kepler's equation. That way, you
* can call one function and it will return the correct value
*/
#[derive(Debug)]
pub enum OrbitType {
Circular,
Elliptic,
Parabolic,
Hyperbolic,
}
impl OrbitType {
/// Return the orbit type given the eccentricity, Body::new
/// uses this function to set the orbit type when an instance
/// is constructed
pub fn new(eccentricity: f64) -> OrbitType {
if eccentricity == 0.0 {
return OrbitType::Circular;
} else if eccentricity < 1.0 && eccentricity > 0.0 {
return OrbitType::Elliptic;
} else if eccentricity == 1.0 {
return OrbitType::Parabolic;
} else {
return OrbitType::Hyperbolic;
}
}
}
#[derive(Debug)]
pub struct Body {
pub position: Vector3<f64>,
pub velocity: Vector3<f64>,
pub orbit_type: OrbitType,
}
/* Adds methods to Body struct */
impl Body {
pub fn new(position: Vector3<f64>, velocity: Vector3<f64>) -> Body {
// h and e are used for determining what kind of orbit the body is currently in
let h = position.cross(&velocity);
let e = ((velocity.cross(&h) / SOLARGM) - position.normalize()).norm();
Body {
position: position,
velocity: velocity,
orbit_type: OrbitType::new(e),
}
}
pub fn radial_velocity(&self) -> Vector3<f64> {
(self.velocity.dot(&self.position) / self.position.norm_squared()) * self.position
}
pub fn tangential_velocity(&self) -> Vector3<f64> {
self.omega().cross(&self.position)
}
pub fn true_anomaly(&self) -> f64 {
let e_vec = self.eccentricity_vector();
let posit = self.position.normalize();
let val = e_vec.dot(&posit) / (e_vec.norm() * posit.norm());
if posit.dot(&self.velocity.normalize()) < 0.0 {
return 2.0 * PI - val.acos();
} else |
}
/* points from focus to perigee if I'm not mistaken */
pub fn eccentricity_vector(&self) -> Vector3<f64> {
let veloc = self.velocity;
let posit = self.position;
let h = self.angular_momentum();
(veloc.cross(&h) / SOLARGM) - posit.normalize()
}
pub fn angular_momentum(&self) -> Vector3<f64> {
self.position.cross(&self.velocity)
}
pub fn total_energy(&self) -> f64 {
let posit = self.position.norm();
let veloc = self.velocity.norm();
0.5 * veloc.powi(2) - (SOLARGM / posit)
}
pub fn omega(&self) -> Vector3<f64> {
self.angular_momentum() / self.position.norm_squared()
}
pub fn frame_rotation_rate(&self) -> f64 {
self.omega().norm()
}
pub fn position_at_angle(&self, angle: f64) -> Vector3<f64> {
let e = self.eccentricity();
let numer = self.angular_momentum().norm_squared() / SOLARGM;
let denom = 1_f64 + (e * (angle).cos());
let radius = numer / denom;
Vector3::new(radius, 0.0, 0.0)
}
pub fn velocity_at_angle(&self, angle: f64) -> Vector3<f64> {
let p = self.orbital_parameter();
let e = self.eccentricity();
let h = self.angular_momentum().norm_squared();
Vector3::new(
(h / p) * e * angle.sin(),
(h / p) * (1_f64 + e * angle.cos()),
0.0,
)
}
pub fn position_and_velocity(&self, angle: f64) -> (Vector3<f64>, Vector3<f64>) {
let r = self.position_at_angle(angle);
let v = self.velocity_at_angle(angle);
let tht = angle - self.true_anomaly();
let trans = Matrix3::from_rows(&[
Vector3::new(tht.cos(), -tht.sin(), 0.0).transpose(),
Vector3::new(tht.sin(), tht.cos(), 0.0).transpose(),
Vector3::new(0.0, 0.0, 1.0).transpose(),
]);
(trans * r, trans * v)
}
// Angle to other body, keep getting the wrong thing anyway, tried everything
pub fn angle_to(&self, other: &Body) -> f64 {
(self.position.dot(&other.position) / (self.position.norm() * other.position.norm())).acos()
}
/* Return a transformation matrix constructed from body's orbit in inertial frame */
pub fn make_frame(&self) -> Matrix3<f64> {
let e_r = self.position.normalize();
let e_h = self.angular_momentum().normalize();
let e_tht = e_h.cross(&e_r);
Matrix3::from_rows(&[e_r.transpose(), e_tht.transpose(), e_h.transpose()])
}
pub fn semi_major_axis(&self) -> f64 {
let ang_moment = self.angular_momentum().norm();
let e = self.eccentricity();
ang_moment.powi(2) / (SOLARGM * (1_f64 - e.powi(2)))
}
pub fn orbital_period(&self) -> f64 {
2_f64 * PI * (self.semi_major_axis().powi(3) / SOLARGM).sqrt()
}
pub fn orbital_parameter(&self) -> f64 {
let e = self.eccentricity();
self.semi_major_axis() * (1.0 - e.powi(2))
}
pub fn eccentric_anomaly(&self) -> f64 {
let e = self.eccentricity();
let theta = self.true_anomaly();
2.0 * ((theta / 2.0).tan() / ((1.0 + e) / (1.0 - e)).sqrt()).atan()
}
pub fn time_since_periapsis(&self) -> f64 {
let t_anom = self.true_anomaly();
let e_anom = self.true_to_eccentric(t_anom);
let a = self.semi_major_axis();
let e = self.eccentricity();
(a.powi(3) / SOLARGM).sqrt() * (e_anom - e * e_anom.sin())
}
pub fn eccentricity(&self) -> f64 {
self.eccentricity_vector().norm()
}
pub fn inclination(&self) -> f64 {
let h = self.angular_momentum();
(h[2] / h.norm()).acos() // h[2] is the z component of the vector
}
pub fn ascending_node(&self) -> Vector3<f64> {
let k = Vector3::new(0.0, 0.0, 1.0);
k.cross(&self.angular_momentum())
}
pub fn argument_of_periapsis(&self) -> f64 {
let n = self.ascending_node();
let e = self.eccentricity_vector();
let omega = (n.dot(&e) / (n.norm() * e.norm())).acos();
if e[2] < 0.0 {
PI2 - omega
} else {
omega
}
}
pub fn argument_of_ascending_node(&self) -> f64 {
let n = self.ascending_node();
let n_x = n[0];
let n_y = n[1];
if n_y >= 0.0 {
(n_x / n.norm()).acos()
} else {
PI2 - (n_x / n.norm()).acos()
}
}
pub fn true_to_eccentric(&self, t_anom: f64) -> f64 {
let a = self.semi_major_axis();
let e = self.eccentricity();
let b = a * (1.0 - e.powi(2)).sqrt();
let p = self.orbital_parameter();
let r = p / (1.0 + e * t_anom.cos());
let c = (a * e + r * t_anom.cos()) / a;
let s = (r / b) * t_anom.sin();
return s.atan2(c);
}
pub fn true_anomaly_at_time(&self, time: f64) -> f64 {
let t_peri = self.time_since_periapsis();
let m_anom = self.mean_anomaly((time * DAYTOSEC) + t_peri);
let angle = self.eccentric_from_mean(m_anom);
return PI2 - self.eccentric_to_true_anomaly(angle);
}
/// The eccentric anomaly at a certain time
pub fn eccentric_from_mean(&self, m_anom: f64) -> f64 {
match self.kepler(m_anom) {
Ok(num) => num,
Err(e) => {
eprintln!("{}: {}\n", "Invalid Orbit".red(), e);
return std::f64::NAN;
}
}
}
/// Return the eccentric anomaly using the appropriate Kepler equation
pub fn kepler(&self, m_anom: f64) -> Result<f64, &str> {
let e = self.eccentricity();
match &self.orbit_type {
OrbitType::Elliptic => Ok(elliptic_kepler(m_anom, e)),
OrbitType::Hyperbolic => Ok(hyper_kepler(m_anom, e)),
OrbitType::Circular => Err("cannot use Keler's equation with a circular orbit."),
OrbitType::Parabolic => Err("cannot use Kepler's equation with a parabolic orbit."),
}
}
pub fn eccentric_to_true_anomaly(&self, e_anom: f64) -> f64 {
let e = self.eccentricity();
// let sqrt_val = ((1.0 + e) / (1.0 - e)).sqrt();
// 2.0 * (sqrt_val * (e_anom / 2.0).tan()).atan() + PI2
((e_anom.cos() - e) / (1.0 - e * e_anom.cos())).acos()
}
/// Return the mean anomaly at a certain time from current position
pub fn mean_anomaly(&self, t: f64) -> f64 {
let n = (SOLARGM / self.semi_major_axis().powi(3)).sqrt();
n * t
}
}
/**
* Some of the kepler functions below. Body matches on its orbit type
* and uses the correct function to return the correct eccentric anomaly
*/
fn elliptic_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-200;
let kep = |e: f64| e - eccen * e.sin() - nt;
let kep_d = |e: f64| 1.0 - eccen * e.cos();
let mut e_0 = 0.0;
let mut e = e_0 - (kep(e_0) / kep_d(e_0));
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - (kep(e_0) / kep_d(e_0));
}
return e;
}
fn hyper_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-100;
let kep = |e: f64| eccen * e.sinh() - nt - e;
let kep_d = |e: f64| eccen * e.cosh() - 1.0;
let mut e_0 = nt;
let mut e = e_0 - kep(e_0) / kep_d(e_0);
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - kep(e_0) / kep_d(e_0);
}
return e;
}
pub fn three_one_three_transform(
arg_of_peri: f64,
inclination: f64,
arg_of_AN: f64,
) -> Matrix3<f64> {
let omega = arg_of_peri;
let inc = inclination;
let tht = arg_of_AN;
let m_c = Matrix3::new(
omega.cos(),
omega.sin(),
0.0,
-omega.sin(),
omega.cos(),
0.0,
0.0,
0.0,
1.0,
);
let m_b = Matrix3::new(
1.0,
0.0,
0.0,
0.0,
inc.cos(),
inc.sin(),
0.0,
-inc.sin(),
inc.cos(),
);
let m_a = Matrix3::new(
tht.cos(),
tht.sin(),
0.0,
-tht.sin(),
tht.cos(),
0.0,
0.0,
0.0,
1.0,
);
return m_c * m_b * m_a;
}
| {
return val.acos();
} | conditional_block |
body.rs | #![allow(dead_code)]
#![allow(unused_doc_comments)]
/**
* body.rs contains the Body struct and implements methods for it. A body struct contains only the
* position and velocity vectors of the body, other parameters are calculated using methods. A body
* is instantiated using using the Body::new() method, which also determines the type of orbit the
* body has at the same time. orbit_type does not have to be given manually.
*/
use nalgebra::{Matrix3, Vector3};
use std::f64::consts::PI;
use colored::*;
const DAYTOSEC: f64 = 24.0 * 3600.0;
const SOLARGM: f64 = 1.328905188132376e11;
const PI2: f64 = 2.0 * PI;
/**
* OrbitType is used to abstract away some of the functions that depend on
* the type of orbit the body is in, like kepler's equation. That way, you
* can call one function and it will return the correct value
*/
#[derive(Debug)]
pub enum OrbitType {
Circular,
Elliptic,
Parabolic,
Hyperbolic,
}
impl OrbitType {
/// Return the orbit type given the eccentricity, Body::new
/// uses this function to set the orbit type when an instance
/// is constructed
pub fn new(eccentricity: f64) -> OrbitType {
if eccentricity == 0.0 {
return OrbitType::Circular;
} else if eccentricity < 1.0 && eccentricity > 0.0 {
return OrbitType::Elliptic;
} else if eccentricity == 1.0 {
return OrbitType::Parabolic;
} else {
return OrbitType::Hyperbolic;
}
}
}
#[derive(Debug)]
pub struct Body {
pub position: Vector3<f64>, | impl Body {
pub fn new(position: Vector3<f64>, velocity: Vector3<f64>) -> Body {
// h and e are used for determining what kind of orbit the body is currently in
let h = position.cross(&velocity);
let e = ((velocity.cross(&h) / SOLARGM) - position.normalize()).norm();
Body {
position: position,
velocity: velocity,
orbit_type: OrbitType::new(e),
}
}
pub fn radial_velocity(&self) -> Vector3<f64> {
(self.velocity.dot(&self.position) / self.position.norm_squared()) * self.position
}
pub fn tangential_velocity(&self) -> Vector3<f64> {
self.omega().cross(&self.position)
}
pub fn true_anomaly(&self) -> f64 {
let e_vec = self.eccentricity_vector();
let posit = self.position.normalize();
let val = e_vec.dot(&posit) / (e_vec.norm() * posit.norm());
if posit.dot(&self.velocity.normalize()) < 0.0 {
return 2.0 * PI - val.acos();
} else {
return val.acos();
}
}
/* points from focus to perigee if I'm not mistaken */
pub fn eccentricity_vector(&self) -> Vector3<f64> {
let veloc = self.velocity;
let posit = self.position;
let h = self.angular_momentum();
(veloc.cross(&h) / SOLARGM) - posit.normalize()
}
pub fn angular_momentum(&self) -> Vector3<f64> {
self.position.cross(&self.velocity)
}
pub fn total_energy(&self) -> f64 {
let posit = self.position.norm();
let veloc = self.velocity.norm();
0.5 * veloc.powi(2) - (SOLARGM / posit)
}
pub fn omega(&self) -> Vector3<f64> {
self.angular_momentum() / self.position.norm_squared()
}
pub fn frame_rotation_rate(&self) -> f64 {
self.omega().norm()
}
pub fn position_at_angle(&self, angle: f64) -> Vector3<f64> {
let e = self.eccentricity();
let numer = self.angular_momentum().norm_squared() / SOLARGM;
let denom = 1_f64 + (e * (angle).cos());
let radius = numer / denom;
Vector3::new(radius, 0.0, 0.0)
}
pub fn velocity_at_angle(&self, angle: f64) -> Vector3<f64> {
let p = self.orbital_parameter();
let e = self.eccentricity();
let h = self.angular_momentum().norm_squared();
Vector3::new(
(h / p) * e * angle.sin(),
(h / p) * (1_f64 + e * angle.cos()),
0.0,
)
}
pub fn position_and_velocity(&self, angle: f64) -> (Vector3<f64>, Vector3<f64>) {
let r = self.position_at_angle(angle);
let v = self.velocity_at_angle(angle);
let tht = angle - self.true_anomaly();
let trans = Matrix3::from_rows(&[
Vector3::new(tht.cos(), -tht.sin(), 0.0).transpose(),
Vector3::new(tht.sin(), tht.cos(), 0.0).transpose(),
Vector3::new(0.0, 0.0, 1.0).transpose(),
]);
(trans * r, trans * v)
}
// Angle to other body, keep getting the wrong thing anyway, tried everything
pub fn angle_to(&self, other: &Body) -> f64 {
(self.position.dot(&other.position) / (self.position.norm() * other.position.norm())).acos()
}
/* Return a transformation matrix constructed from body's orbit in inertial frame */
pub fn make_frame(&self) -> Matrix3<f64> {
let e_r = self.position.normalize();
let e_h = self.angular_momentum().normalize();
let e_tht = e_h.cross(&e_r);
Matrix3::from_rows(&[e_r.transpose(), e_tht.transpose(), e_h.transpose()])
}
pub fn semi_major_axis(&self) -> f64 {
let ang_moment = self.angular_momentum().norm();
let e = self.eccentricity();
ang_moment.powi(2) / (SOLARGM * (1_f64 - e.powi(2)))
}
pub fn orbital_period(&self) -> f64 {
2_f64 * PI * (self.semi_major_axis().powi(3) / SOLARGM).sqrt()
}
pub fn orbital_parameter(&self) -> f64 {
let e = self.eccentricity();
self.semi_major_axis() * (1.0 - e.powi(2))
}
pub fn eccentric_anomaly(&self) -> f64 {
let e = self.eccentricity();
let theta = self.true_anomaly();
2.0 * ((theta / 2.0).tan() / ((1.0 + e) / (1.0 - e)).sqrt()).atan()
}
pub fn time_since_periapsis(&self) -> f64 {
let t_anom = self.true_anomaly();
let e_anom = self.true_to_eccentric(t_anom);
let a = self.semi_major_axis();
let e = self.eccentricity();
(a.powi(3) / SOLARGM).sqrt() * (e_anom - e * e_anom.sin())
}
pub fn eccentricity(&self) -> f64 {
self.eccentricity_vector().norm()
}
pub fn inclination(&self) -> f64 {
let h = self.angular_momentum();
(h[2] / h.norm()).acos() // h[2] is the z component of the vector
}
pub fn ascending_node(&self) -> Vector3<f64> {
let k = Vector3::new(0.0, 0.0, 1.0);
k.cross(&self.angular_momentum())
}
pub fn argument_of_periapsis(&self) -> f64 {
let n = self.ascending_node();
let e = self.eccentricity_vector();
let omega = (n.dot(&e) / (n.norm() * e.norm())).acos();
if e[2] < 0.0 {
PI2 - omega
} else {
omega
}
}
pub fn argument_of_ascending_node(&self) -> f64 {
let n = self.ascending_node();
let n_x = n[0];
let n_y = n[1];
if n_y >= 0.0 {
(n_x / n.norm()).acos()
} else {
PI2 - (n_x / n.norm()).acos()
}
}
pub fn true_to_eccentric(&self, t_anom: f64) -> f64 {
let a = self.semi_major_axis();
let e = self.eccentricity();
let b = a * (1.0 - e.powi(2)).sqrt();
let p = self.orbital_parameter();
let r = p / (1.0 + e * t_anom.cos());
let c = (a * e + r * t_anom.cos()) / a;
let s = (r / b) * t_anom.sin();
return s.atan2(c);
}
pub fn true_anomaly_at_time(&self, time: f64) -> f64 {
let t_peri = self.time_since_periapsis();
let m_anom = self.mean_anomaly((time * DAYTOSEC) + t_peri);
let angle = self.eccentric_from_mean(m_anom);
return PI2 - self.eccentric_to_true_anomaly(angle);
}
/// The eccentric anomaly at a certain time
pub fn eccentric_from_mean(&self, m_anom: f64) -> f64 {
match self.kepler(m_anom) {
Ok(num) => num,
Err(e) => {
eprintln!("{}: {}\n", "Invalid Orbit".red(), e);
return std::f64::NAN;
}
}
}
/// Return the eccentric anomaly using the appropriate Kepler equation
pub fn kepler(&self, m_anom: f64) -> Result<f64, &str> {
let e = self.eccentricity();
match &self.orbit_type {
OrbitType::Elliptic => Ok(elliptic_kepler(m_anom, e)),
OrbitType::Hyperbolic => Ok(hyper_kepler(m_anom, e)),
OrbitType::Circular => Err("cannot use Keler's equation with a circular orbit."),
OrbitType::Parabolic => Err("cannot use Kepler's equation with a parabolic orbit."),
}
}
pub fn eccentric_to_true_anomaly(&self, e_anom: f64) -> f64 {
let e = self.eccentricity();
// let sqrt_val = ((1.0 + e) / (1.0 - e)).sqrt();
// 2.0 * (sqrt_val * (e_anom / 2.0).tan()).atan() + PI2
((e_anom.cos() - e) / (1.0 - e * e_anom.cos())).acos()
}
/// Return the mean anomaly at a certain time from current position
pub fn mean_anomaly(&self, t: f64) -> f64 {
let n = (SOLARGM / self.semi_major_axis().powi(3)).sqrt();
n * t
}
}
/**
* Some of the kepler functions below. Body matches on its orbit type
* and uses the correct function to return the correct eccentric anomaly
*/
fn elliptic_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-200;
let kep = |e: f64| e - eccen * e.sin() - nt;
let kep_d = |e: f64| 1.0 - eccen * e.cos();
let mut e_0 = 0.0;
let mut e = e_0 - (kep(e_0) / kep_d(e_0));
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - (kep(e_0) / kep_d(e_0));
}
return e;
}
fn hyper_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-100;
let kep = |e: f64| eccen * e.sinh() - nt - e;
let kep_d = |e: f64| eccen * e.cosh() - 1.0;
let mut e_0 = nt;
let mut e = e_0 - kep(e_0) / kep_d(e_0);
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - kep(e_0) / kep_d(e_0);
}
return e;
}
pub fn three_one_three_transform(
arg_of_peri: f64,
inclination: f64,
arg_of_AN: f64,
) -> Matrix3<f64> {
let omega = arg_of_peri;
let inc = inclination;
let tht = arg_of_AN;
let m_c = Matrix3::new(
omega.cos(),
omega.sin(),
0.0,
-omega.sin(),
omega.cos(),
0.0,
0.0,
0.0,
1.0,
);
let m_b = Matrix3::new(
1.0,
0.0,
0.0,
0.0,
inc.cos(),
inc.sin(),
0.0,
-inc.sin(),
inc.cos(),
);
let m_a = Matrix3::new(
tht.cos(),
tht.sin(),
0.0,
-tht.sin(),
tht.cos(),
0.0,
0.0,
0.0,
1.0,
);
return m_c * m_b * m_a;
} | pub velocity: Vector3<f64>,
pub orbit_type: OrbitType,
}
/* Adds methods to Body struct */ | random_line_split |
body.rs | #![allow(dead_code)]
#![allow(unused_doc_comments)]
/**
* body.rs contains the Body struct and implements methods for it. A body struct contains only the
* position and velocity vectors of the body, other parameters are calculated using methods. A body
* is instantiated using using the Body::new() method, which also determines the type of orbit the
* body has at the same time. orbit_type does not have to be given manually.
*/
use nalgebra::{Matrix3, Vector3};
use std::f64::consts::PI;
use colored::*;
const DAYTOSEC: f64 = 24.0 * 3600.0;
const SOLARGM: f64 = 1.328905188132376e11;
const PI2: f64 = 2.0 * PI;
/**
* OrbitType is used to abstract away some of the functions that depend on
* the type of orbit the body is in, like kepler's equation. That way, you
* can call one function and it will return the correct value
*/
#[derive(Debug)]
pub enum OrbitType {
Circular,
Elliptic,
Parabolic,
Hyperbolic,
}
impl OrbitType {
/// Return the orbit type given the eccentricity, Body::new
/// uses this function to set the orbit type when an instance
/// is constructed
pub fn new(eccentricity: f64) -> OrbitType {
if eccentricity == 0.0 {
return OrbitType::Circular;
} else if eccentricity < 1.0 && eccentricity > 0.0 {
return OrbitType::Elliptic;
} else if eccentricity == 1.0 {
return OrbitType::Parabolic;
} else {
return OrbitType::Hyperbolic;
}
}
}
#[derive(Debug)]
pub struct Body {
pub position: Vector3<f64>,
pub velocity: Vector3<f64>,
pub orbit_type: OrbitType,
}
/* Adds methods to Body struct */
impl Body {
pub fn new(position: Vector3<f64>, velocity: Vector3<f64>) -> Body {
// h and e are used for determining what kind of orbit the body is currently in
let h = position.cross(&velocity);
let e = ((velocity.cross(&h) / SOLARGM) - position.normalize()).norm();
Body {
position: position,
velocity: velocity,
orbit_type: OrbitType::new(e),
}
}
pub fn radial_velocity(&self) -> Vector3<f64> {
(self.velocity.dot(&self.position) / self.position.norm_squared()) * self.position
}
pub fn tangential_velocity(&self) -> Vector3<f64> |
pub fn true_anomaly(&self) -> f64 {
let e_vec = self.eccentricity_vector();
let posit = self.position.normalize();
let val = e_vec.dot(&posit) / (e_vec.norm() * posit.norm());
if posit.dot(&self.velocity.normalize()) < 0.0 {
return 2.0 * PI - val.acos();
} else {
return val.acos();
}
}
/* points from focus to perigee if I'm not mistaken */
pub fn eccentricity_vector(&self) -> Vector3<f64> {
let veloc = self.velocity;
let posit = self.position;
let h = self.angular_momentum();
(veloc.cross(&h) / SOLARGM) - posit.normalize()
}
pub fn angular_momentum(&self) -> Vector3<f64> {
self.position.cross(&self.velocity)
}
pub fn total_energy(&self) -> f64 {
let posit = self.position.norm();
let veloc = self.velocity.norm();
0.5 * veloc.powi(2) - (SOLARGM / posit)
}
pub fn omega(&self) -> Vector3<f64> {
self.angular_momentum() / self.position.norm_squared()
}
pub fn frame_rotation_rate(&self) -> f64 {
self.omega().norm()
}
pub fn position_at_angle(&self, angle: f64) -> Vector3<f64> {
let e = self.eccentricity();
let numer = self.angular_momentum().norm_squared() / SOLARGM;
let denom = 1_f64 + (e * (angle).cos());
let radius = numer / denom;
Vector3::new(radius, 0.0, 0.0)
}
pub fn velocity_at_angle(&self, angle: f64) -> Vector3<f64> {
let p = self.orbital_parameter();
let e = self.eccentricity();
let h = self.angular_momentum().norm_squared();
Vector3::new(
(h / p) * e * angle.sin(),
(h / p) * (1_f64 + e * angle.cos()),
0.0,
)
}
pub fn position_and_velocity(&self, angle: f64) -> (Vector3<f64>, Vector3<f64>) {
let r = self.position_at_angle(angle);
let v = self.velocity_at_angle(angle);
let tht = angle - self.true_anomaly();
let trans = Matrix3::from_rows(&[
Vector3::new(tht.cos(), -tht.sin(), 0.0).transpose(),
Vector3::new(tht.sin(), tht.cos(), 0.0).transpose(),
Vector3::new(0.0, 0.0, 1.0).transpose(),
]);
(trans * r, trans * v)
}
// Angle to other body, keep getting the wrong thing anyway, tried everything
pub fn angle_to(&self, other: &Body) -> f64 {
(self.position.dot(&other.position) / (self.position.norm() * other.position.norm())).acos()
}
/* Return a transformation matrix constructed from body's orbit in inertial frame */
pub fn make_frame(&self) -> Matrix3<f64> {
let e_r = self.position.normalize();
let e_h = self.angular_momentum().normalize();
let e_tht = e_h.cross(&e_r);
Matrix3::from_rows(&[e_r.transpose(), e_tht.transpose(), e_h.transpose()])
}
pub fn semi_major_axis(&self) -> f64 {
let ang_moment = self.angular_momentum().norm();
let e = self.eccentricity();
ang_moment.powi(2) / (SOLARGM * (1_f64 - e.powi(2)))
}
pub fn orbital_period(&self) -> f64 {
2_f64 * PI * (self.semi_major_axis().powi(3) / SOLARGM).sqrt()
}
pub fn orbital_parameter(&self) -> f64 {
let e = self.eccentricity();
self.semi_major_axis() * (1.0 - e.powi(2))
}
pub fn eccentric_anomaly(&self) -> f64 {
let e = self.eccentricity();
let theta = self.true_anomaly();
2.0 * ((theta / 2.0).tan() / ((1.0 + e) / (1.0 - e)).sqrt()).atan()
}
pub fn time_since_periapsis(&self) -> f64 {
let t_anom = self.true_anomaly();
let e_anom = self.true_to_eccentric(t_anom);
let a = self.semi_major_axis();
let e = self.eccentricity();
(a.powi(3) / SOLARGM).sqrt() * (e_anom - e * e_anom.sin())
}
pub fn eccentricity(&self) -> f64 {
self.eccentricity_vector().norm()
}
pub fn inclination(&self) -> f64 {
let h = self.angular_momentum();
(h[2] / h.norm()).acos() // h[2] is the z component of the vector
}
pub fn ascending_node(&self) -> Vector3<f64> {
let k = Vector3::new(0.0, 0.0, 1.0);
k.cross(&self.angular_momentum())
}
pub fn argument_of_periapsis(&self) -> f64 {
let n = self.ascending_node();
let e = self.eccentricity_vector();
let omega = (n.dot(&e) / (n.norm() * e.norm())).acos();
if e[2] < 0.0 {
PI2 - omega
} else {
omega
}
}
pub fn argument_of_ascending_node(&self) -> f64 {
let n = self.ascending_node();
let n_x = n[0];
let n_y = n[1];
if n_y >= 0.0 {
(n_x / n.norm()).acos()
} else {
PI2 - (n_x / n.norm()).acos()
}
}
pub fn true_to_eccentric(&self, t_anom: f64) -> f64 {
let a = self.semi_major_axis();
let e = self.eccentricity();
let b = a * (1.0 - e.powi(2)).sqrt();
let p = self.orbital_parameter();
let r = p / (1.0 + e * t_anom.cos());
let c = (a * e + r * t_anom.cos()) / a;
let s = (r / b) * t_anom.sin();
return s.atan2(c);
}
pub fn true_anomaly_at_time(&self, time: f64) -> f64 {
let t_peri = self.time_since_periapsis();
let m_anom = self.mean_anomaly((time * DAYTOSEC) + t_peri);
let angle = self.eccentric_from_mean(m_anom);
return PI2 - self.eccentric_to_true_anomaly(angle);
}
/// The eccentric anomaly at a certain time
pub fn eccentric_from_mean(&self, m_anom: f64) -> f64 {
match self.kepler(m_anom) {
Ok(num) => num,
Err(e) => {
eprintln!("{}: {}\n", "Invalid Orbit".red(), e);
return std::f64::NAN;
}
}
}
/// Return the eccentric anomaly using the appropriate Kepler equation
pub fn kepler(&self, m_anom: f64) -> Result<f64, &str> {
let e = self.eccentricity();
match &self.orbit_type {
OrbitType::Elliptic => Ok(elliptic_kepler(m_anom, e)),
OrbitType::Hyperbolic => Ok(hyper_kepler(m_anom, e)),
OrbitType::Circular => Err("cannot use Keler's equation with a circular orbit."),
OrbitType::Parabolic => Err("cannot use Kepler's equation with a parabolic orbit."),
}
}
pub fn eccentric_to_true_anomaly(&self, e_anom: f64) -> f64 {
let e = self.eccentricity();
// let sqrt_val = ((1.0 + e) / (1.0 - e)).sqrt();
// 2.0 * (sqrt_val * (e_anom / 2.0).tan()).atan() + PI2
((e_anom.cos() - e) / (1.0 - e * e_anom.cos())).acos()
}
/// Return the mean anomaly at a certain time from current position
pub fn mean_anomaly(&self, t: f64) -> f64 {
let n = (SOLARGM / self.semi_major_axis().powi(3)).sqrt();
n * t
}
}
/**
* Some of the kepler functions below. Body matches on its orbit type
* and uses the correct function to return the correct eccentric anomaly
*/
fn elliptic_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-200;
let kep = |e: f64| e - eccen * e.sin() - nt;
let kep_d = |e: f64| 1.0 - eccen * e.cos();
let mut e_0 = 0.0;
let mut e = e_0 - (kep(e_0) / kep_d(e_0));
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - (kep(e_0) / kep_d(e_0));
}
return e;
}
fn hyper_kepler(nt: f64, eccen: f64) -> f64 {
let tolerance = 1e-100;
let kep = |e: f64| eccen * e.sinh() - nt - e;
let kep_d = |e: f64| eccen * e.cosh() - 1.0;
let mut e_0 = nt;
let mut e = e_0 - kep(e_0) / kep_d(e_0);
while (e - e_0).abs() > tolerance {
e_0 = e;
e = e_0 - kep(e_0) / kep_d(e_0);
}
return e;
}
pub fn three_one_three_transform(
arg_of_peri: f64,
inclination: f64,
arg_of_AN: f64,
) -> Matrix3<f64> {
let omega = arg_of_peri;
let inc = inclination;
let tht = arg_of_AN;
let m_c = Matrix3::new(
omega.cos(),
omega.sin(),
0.0,
-omega.sin(),
omega.cos(),
0.0,
0.0,
0.0,
1.0,
);
let m_b = Matrix3::new(
1.0,
0.0,
0.0,
0.0,
inc.cos(),
inc.sin(),
0.0,
-inc.sin(),
inc.cos(),
);
let m_a = Matrix3::new(
tht.cos(),
tht.sin(),
0.0,
-tht.sin(),
tht.cos(),
0.0,
0.0,
0.0,
1.0,
);
return m_c * m_b * m_a;
}
| {
self.omega().cross(&self.position)
} | identifier_body |
thermald.py | #!/usr/bin/env python3.7
import os
import json
import copy
import datetime
from smbus2 import SMBus
from cereal import log
from common.basedir import BASEDIR
from common.params import Params
from common.realtime import sec_since_boot, DT_TRML
from common.numpy_fast import clip
from common.filter_simple import FirstOrderFilter
from selfdrive.version import terms_version, training_version
from selfdrive.swaglog import cloudlog
import selfdrive.messaging as messaging
from selfdrive.services import service_list
from selfdrive.loggerd.config import get_available_percent
ThermalStatus = log.ThermalData.ThermalStatus
CURRENT_TAU = 15. # 15s time constant
DAYS_NO_CONNECTIVITY_MAX = 7 # do not allow to engage after a week without internet
DAYS_NO_CONNECTIVITY_PROMPT = 4 # send an offroad prompt after 4 days with no internet
with open(BASEDIR + "/selfdrive/controls/lib/alerts_offroad.json") as json_file:
OFFROAD_ALERTS = json.load(json_file)
def read_tz(x):
with open("/sys/devices/virtual/thermal/thermal_zone%d/temp" % x) as f:
ret = max(0, int(f.read()))
return ret
def read_thermal():
dat = messaging.new_message()
dat.init('thermal')
dat.thermal.cpu0 = read_tz(5)
dat.thermal.cpu1 = read_tz(7)
dat.thermal.cpu2 = read_tz(10)
dat.thermal.cpu3 = read_tz(12)
dat.thermal.mem = read_tz(2)
dat.thermal.gpu = read_tz(16)
dat.thermal.bat = read_tz(29)
return dat
LEON = False
def setup_eon_fan():
global LEON
os.system("echo 2 > /sys/module/dwc3_msm/parameters/otg_switch")
bus = SMBus(7, force=True)
try:
bus.write_byte_data(0x21, 0x10, 0xf) # mask all interrupts
bus.write_byte_data(0x21, 0x03, 0x1) # set drive current and global interrupt disable
bus.write_byte_data(0x21, 0x02, 0x2) # needed?
bus.write_byte_data(0x21, 0x04, 0x4) # manual override source
except IOError:
print("LEON detected")
#os.system("echo 1 > /sys/devices/soc/6a00000.ssusb/power_supply/usb/usb_otg")
LEON = True
bus.close()
last_eon_fan_val = None
def set_eon_fan(val):
|
# temp thresholds to control fan speed - high hysteresis
_TEMP_THRS_H = [50., 65., 80., 10000]
# temp thresholds to control fan speed - low hysteresis
_TEMP_THRS_L = [42.5, 57.5, 72.5, 10000]
# fan speed options
_FAN_SPEEDS = [0, 16384, 32768, 65535]
# max fan speed only allowed if battery is hot
_BAT_TEMP_THERSHOLD = 45.
def handle_fan(max_cpu_temp, bat_temp, fan_speed):
new_speed_h = next(speed for speed, temp_h in zip(_FAN_SPEEDS, _TEMP_THRS_H) if temp_h > max_cpu_temp)
new_speed_l = next(speed for speed, temp_l in zip(_FAN_SPEEDS, _TEMP_THRS_L) if temp_l > max_cpu_temp)
if new_speed_h > fan_speed:
# update speed if using the high thresholds results in fan speed increment
fan_speed = new_speed_h
elif new_speed_l < fan_speed:
# update speed if using the low thresholds results in fan speed decrement
fan_speed = new_speed_l
if bat_temp < _BAT_TEMP_THERSHOLD:
# no max fan speed unless battery is hot
fan_speed = min(fan_speed, _FAN_SPEEDS[-2])
set_eon_fan(fan_speed//16384)
return fan_speed
def thermald_thread():
setup_eon_fan()
# prevent LEECO from undervoltage
BATT_PERC_OFF = 10 if LEON else 3
# now loop
thermal_sock = messaging.pub_sock(service_list['thermal'].port)
health_sock = messaging.sub_sock(service_list['health'].port)
location_sock = messaging.sub_sock(service_list['gpsLocation'].port)
fan_speed = 0
count = 0
off_ts = None
started_ts = None
started_seen = False
thermal_status = ThermalStatus.green
thermal_status_prev = ThermalStatus.green
usb_power = True
usb_power_prev = True
health_sock.RCVTIMEO = int(1000 * 2 * DT_TRML) # 2x the expected health frequency
current_filter = FirstOrderFilter(0., CURRENT_TAU, DT_TRML)
health_prev = None
current_connectivity_alert = None
params = Params()
while 1:
health = messaging.recv_sock(health_sock, wait=True)
location = messaging.recv_sock(location_sock)
location = location.gpsLocation if location else None
msg = read_thermal()
# clear car params when panda gets disconnected
if health is None and health_prev is not None:
params.panda_disconnect()
health_prev = health
if health is not None:
usb_power = health.health.usbPowerMode != log.HealthData.UsbPowerMode.client
# loggerd is gated based on free space
avail = get_available_percent() / 100.0
# thermal message now also includes free space
msg.thermal.freeSpace = avail
with open("/sys/class/power_supply/battery/capacity") as f:
msg.thermal.batteryPercent = int(f.read())
with open("/sys/class/power_supply/battery/status") as f:
msg.thermal.batteryStatus = f.read().strip()
with open("/sys/class/power_supply/battery/current_now") as f:
msg.thermal.batteryCurrent = int(f.read())
with open("/sys/class/power_supply/battery/voltage_now") as f:
msg.thermal.batteryVoltage = int(f.read())
with open("/sys/class/power_supply/usb/present") as f:
msg.thermal.usbOnline = bool(int(f.read()))
current_filter.update(msg.thermal.batteryCurrent / 1e6)
# TODO: add car battery voltage check
max_cpu_temp = max(msg.thermal.cpu0, msg.thermal.cpu1,
msg.thermal.cpu2, msg.thermal.cpu3) / 10.0
max_comp_temp = max(max_cpu_temp, msg.thermal.mem / 10., msg.thermal.gpu / 10.)
bat_temp = msg.thermal.bat/1000.
fan_speed = handle_fan(max_cpu_temp, bat_temp, fan_speed)
msg.thermal.fanSpeed = fan_speed
# thermal logic with hysterisis
if max_cpu_temp > 107. or bat_temp >= 63.:
# onroad not allowed
thermal_status = ThermalStatus.danger
elif max_comp_temp > 92.5 or bat_temp > 60.: # CPU throttling starts around ~90C
# hysteresis between onroad not allowed and engage not allowed
thermal_status = clip(thermal_status, ThermalStatus.red, ThermalStatus.danger)
elif max_cpu_temp > 87.5:
# hysteresis between engage not allowed and uploader not allowed
thermal_status = clip(thermal_status, ThermalStatus.yellow, ThermalStatus.red)
elif max_cpu_temp > 80.0:
# uploader not allowed
thermal_status = ThermalStatus.yellow
elif max_cpu_temp > 75.0:
# hysteresis between uploader not allowed and all good
thermal_status = clip(thermal_status, ThermalStatus.green, ThermalStatus.yellow)
else:
# all good
thermal_status = ThermalStatus.green
# **** starting logic ****
# Check for last update time and display alerts if needed
now = datetime.datetime.now()
try:
last_update = datetime.datetime.fromisoformat(params.get("LastUpdateTime", encoding='utf8'))
except (TypeError, ValueError):
last_update = now
dt = now - last_update
if dt.days > DAYS_NO_CONNECTIVITY_MAX:
if current_connectivity_alert != "expired":
current_connectivity_alert = "expired"
params.delete("Offroad_ConnectivityNeededPrompt")
params.put("Offroad_ConnectivityNeeded", json.dumps(OFFROAD_ALERTS["Offroad_ConnectivityNeeded"]))
elif dt.days > DAYS_NO_CONNECTIVITY_PROMPT:
remaining_time = str(DAYS_NO_CONNECTIVITY_MAX - dt.days)
if current_connectivity_alert != "prompt" + remaining_time:
current_connectivity_alert = "prompt" + remaining_time
alert_connectivity_prompt = copy.copy(OFFROAD_ALERTS["Offroad_ConnectivityNeededPrompt"])
alert_connectivity_prompt["text"] += remaining_time + " days."
params.delete("Offroad_ConnectivityNeeded")
params.put("Offroad_ConnectivityNeededPrompt", json.dumps(alert_connectivity_prompt))
elif current_connectivity_alert is not None:
current_connectivity_alert = None
params.delete("Offroad_ConnectivityNeeded")
params.delete("Offroad_ConnectivityNeededPrompt")
# start constellation of processes when the car starts
ignition = health is not None and health.health.started
do_uninstall = params.get("DoUninstall") == b"1"
accepted_terms = params.get("HasAcceptedTerms") == terms_version
completed_training = params.get("CompletedTrainingVersion") == training_version
should_start = ignition
# have we seen a panda?
passive = (params.get("Passive") == "1")
# with 2% left, we killall, otherwise the phone will take a long time to boot
should_start = should_start and msg.thermal.freeSpace > 0.02
# confirm we have completed training and aren't uninstalling
should_start = should_start and accepted_terms and (passive or completed_training) and (not do_uninstall)
# if any CPU gets above 107 or the battery gets above 63, kill all processes
# controls will warn with CPU above 95 or battery above 60
if thermal_status >= ThermalStatus.danger:
should_start = False
if thermal_status_prev < ThermalStatus.danger:
params.put("Offroad_TemperatureTooHigh", json.dumps(OFFROAD_ALERTS["Offroad_TemperatureTooHigh"]))
else:
if thermal_status_prev >= ThermalStatus.danger:
params.delete("Offroad_TemperatureTooHigh")
if should_start:
off_ts = None
if started_ts is None:
started_ts = sec_since_boot()
started_seen = True
os.system('echo performance > /sys/class/devfreq/soc:qcom,cpubw/governor')
else:
started_ts = None
if off_ts is None:
off_ts = sec_since_boot()
os.system('echo powersave > /sys/class/devfreq/soc:qcom,cpubw/governor')
# shutdown if the battery gets lower than 3%, it's discharging, we aren't running for
# more than a minute but we were running
if msg.thermal.batteryPercent < BATT_PERC_OFF and msg.thermal.batteryStatus == "Discharging" and \
started_seen and (sec_since_boot() - off_ts) > 60:
os.system('LD_LIBRARY_PATH="" svc power shutdown')
msg.thermal.chargingError = current_filter.x > 0. and msg.thermal.batteryPercent < 90 # if current is positive, then battery is being discharged
msg.thermal.started = started_ts is not None
msg.thermal.startedTs = int(1e9*(started_ts or 0))
msg.thermal.thermalStatus = thermal_status
thermal_sock.send(msg.to_bytes())
if usb_power_prev and not usb_power:
params.put("Offroad_ChargeDisabled", json.dumps(OFFROAD_ALERTS["Offroad_ChargeDisabled"]))
elif usb_power and not usb_power_prev:
params.delete("Offroad_ChargeDisabled")
thermal_status_prev = thermal_status
usb_power_prev = usb_power
print(msg)
# report to server once per minute
if (count % int(60. / DT_TRML)) == 0:
cloudlog.event("STATUS_PACKET",
count=count,
health=(health.to_dict() if health else None),
location=(location.to_dict() if location else None),
thermal=msg.to_dict())
count += 1
def main(gctx=None):
thermald_thread()
if __name__ == "__main__":
main()
| global LEON, last_eon_fan_val
if last_eon_fan_val is None or last_eon_fan_val != val:
bus = SMBus(7, force=True)
if LEON:
try:
i = [0x1, 0x3 | 0, 0x3 | 0x08, 0x3 | 0x10][val]
bus.write_i2c_block_data(0x3d, 0, [i])
except IOError:
# tusb320
if val == 0:
bus.write_i2c_block_data(0x67, 0xa, [0])
else:
bus.write_i2c_block_data(0x67, 0xa, [0x20])
bus.write_i2c_block_data(0x67, 0x8, [(val-1)<<6])
else:
bus.write_byte_data(0x21, 0x04, 0x2)
bus.write_byte_data(0x21, 0x03, (val*2)+1)
bus.write_byte_data(0x21, 0x04, 0x4)
bus.close()
last_eon_fan_val = val | identifier_body |
thermald.py | #!/usr/bin/env python3.7
import os
import json
import copy
import datetime
from smbus2 import SMBus
from cereal import log
from common.basedir import BASEDIR
from common.params import Params
from common.realtime import sec_since_boot, DT_TRML
from common.numpy_fast import clip
from common.filter_simple import FirstOrderFilter
from selfdrive.version import terms_version, training_version
from selfdrive.swaglog import cloudlog
import selfdrive.messaging as messaging
from selfdrive.services import service_list
from selfdrive.loggerd.config import get_available_percent
ThermalStatus = log.ThermalData.ThermalStatus
CURRENT_TAU = 15. # 15s time constant
DAYS_NO_CONNECTIVITY_MAX = 7 # do not allow to engage after a week without internet
DAYS_NO_CONNECTIVITY_PROMPT = 4 # send an offroad prompt after 4 days with no internet
with open(BASEDIR + "/selfdrive/controls/lib/alerts_offroad.json") as json_file:
OFFROAD_ALERTS = json.load(json_file)
def read_tz(x):
with open("/sys/devices/virtual/thermal/thermal_zone%d/temp" % x) as f:
ret = max(0, int(f.read()))
return ret
def read_thermal():
dat = messaging.new_message()
dat.init('thermal')
dat.thermal.cpu0 = read_tz(5)
dat.thermal.cpu1 = read_tz(7)
dat.thermal.cpu2 = read_tz(10)
dat.thermal.cpu3 = read_tz(12)
dat.thermal.mem = read_tz(2)
dat.thermal.gpu = read_tz(16)
dat.thermal.bat = read_tz(29)
return dat
LEON = False
def setup_eon_fan():
global LEON
os.system("echo 2 > /sys/module/dwc3_msm/parameters/otg_switch")
bus = SMBus(7, force=True)
try:
bus.write_byte_data(0x21, 0x10, 0xf) # mask all interrupts
bus.write_byte_data(0x21, 0x03, 0x1) # set drive current and global interrupt disable
bus.write_byte_data(0x21, 0x02, 0x2) # needed?
bus.write_byte_data(0x21, 0x04, 0x4) # manual override source
except IOError:
print("LEON detected")
#os.system("echo 1 > /sys/devices/soc/6a00000.ssusb/power_supply/usb/usb_otg")
LEON = True
bus.close()
last_eon_fan_val = None
def set_eon_fan(val):
global LEON, last_eon_fan_val
if last_eon_fan_val is None or last_eon_fan_val != val:
bus = SMBus(7, force=True)
if LEON:
try:
i = [0x1, 0x3 | 0, 0x3 | 0x08, 0x3 | 0x10][val]
bus.write_i2c_block_data(0x3d, 0, [i])
except IOError:
# tusb320
if val == 0:
bus.write_i2c_block_data(0x67, 0xa, [0])
else:
bus.write_i2c_block_data(0x67, 0xa, [0x20])
bus.write_i2c_block_data(0x67, 0x8, [(val-1)<<6])
else:
bus.write_byte_data(0x21, 0x04, 0x2)
bus.write_byte_data(0x21, 0x03, (val*2)+1)
bus.write_byte_data(0x21, 0x04, 0x4)
bus.close()
last_eon_fan_val = val
# temp thresholds to control fan speed - high hysteresis
_TEMP_THRS_H = [50., 65., 80., 10000]
# temp thresholds to control fan speed - low hysteresis
_TEMP_THRS_L = [42.5, 57.5, 72.5, 10000]
# fan speed options
_FAN_SPEEDS = [0, 16384, 32768, 65535]
# max fan speed only allowed if battery is hot
_BAT_TEMP_THERSHOLD = 45.
def handle_fan(max_cpu_temp, bat_temp, fan_speed):
new_speed_h = next(speed for speed, temp_h in zip(_FAN_SPEEDS, _TEMP_THRS_H) if temp_h > max_cpu_temp)
new_speed_l = next(speed for speed, temp_l in zip(_FAN_SPEEDS, _TEMP_THRS_L) if temp_l > max_cpu_temp)
if new_speed_h > fan_speed:
# update speed if using the high thresholds results in fan speed increment
fan_speed = new_speed_h
elif new_speed_l < fan_speed:
# update speed if using the low thresholds results in fan speed decrement
fan_speed = new_speed_l
if bat_temp < _BAT_TEMP_THERSHOLD:
# no max fan speed unless battery is hot
fan_speed = min(fan_speed, _FAN_SPEEDS[-2])
set_eon_fan(fan_speed//16384)
return fan_speed
def thermald_thread():
setup_eon_fan()
# prevent LEECO from undervoltage
BATT_PERC_OFF = 10 if LEON else 3
# now loop
thermal_sock = messaging.pub_sock(service_list['thermal'].port)
health_sock = messaging.sub_sock(service_list['health'].port)
location_sock = messaging.sub_sock(service_list['gpsLocation'].port)
fan_speed = 0
count = 0
off_ts = None
started_ts = None
started_seen = False
thermal_status = ThermalStatus.green
thermal_status_prev = ThermalStatus.green
usb_power = True
usb_power_prev = True
health_sock.RCVTIMEO = int(1000 * 2 * DT_TRML) # 2x the expected health frequency
current_filter = FirstOrderFilter(0., CURRENT_TAU, DT_TRML)
health_prev = None
current_connectivity_alert = None
params = Params()
while 1:
health = messaging.recv_sock(health_sock, wait=True)
location = messaging.recv_sock(location_sock)
location = location.gpsLocation if location else None
msg = read_thermal()
# clear car params when panda gets disconnected
if health is None and health_prev is not None:
params.panda_disconnect()
health_prev = health
if health is not None:
usb_power = health.health.usbPowerMode != log.HealthData.UsbPowerMode.client
# loggerd is gated based on free space
avail = get_available_percent() / 100.0
# thermal message now also includes free space
msg.thermal.freeSpace = avail
with open("/sys/class/power_supply/battery/capacity") as f:
msg.thermal.batteryPercent = int(f.read())
with open("/sys/class/power_supply/battery/status") as f:
msg.thermal.batteryStatus = f.read().strip()
with open("/sys/class/power_supply/battery/current_now") as f:
msg.thermal.batteryCurrent = int(f.read())
with open("/sys/class/power_supply/battery/voltage_now") as f:
msg.thermal.batteryVoltage = int(f.read())
with open("/sys/class/power_supply/usb/present") as f:
msg.thermal.usbOnline = bool(int(f.read()))
current_filter.update(msg.thermal.batteryCurrent / 1e6)
# TODO: add car battery voltage check
max_cpu_temp = max(msg.thermal.cpu0, msg.thermal.cpu1,
msg.thermal.cpu2, msg.thermal.cpu3) / 10.0
max_comp_temp = max(max_cpu_temp, msg.thermal.mem / 10., msg.thermal.gpu / 10.)
bat_temp = msg.thermal.bat/1000.
fan_speed = handle_fan(max_cpu_temp, bat_temp, fan_speed)
msg.thermal.fanSpeed = fan_speed
# thermal logic with hysterisis
if max_cpu_temp > 107. or bat_temp >= 63.:
# onroad not allowed
thermal_status = ThermalStatus.danger
elif max_comp_temp > 92.5 or bat_temp > 60.: # CPU throttling starts around ~90C
# hysteresis between onroad not allowed and engage not allowed
thermal_status = clip(thermal_status, ThermalStatus.red, ThermalStatus.danger)
elif max_cpu_temp > 87.5:
# hysteresis between engage not allowed and uploader not allowed
thermal_status = clip(thermal_status, ThermalStatus.yellow, ThermalStatus.red)
elif max_cpu_temp > 80.0:
# uploader not allowed
thermal_status = ThermalStatus.yellow
elif max_cpu_temp > 75.0:
# hysteresis between uploader not allowed and all good
thermal_status = clip(thermal_status, ThermalStatus.green, ThermalStatus.yellow)
else:
# all good
thermal_status = ThermalStatus.green
# **** starting logic ****
# Check for last update time and display alerts if needed
now = datetime.datetime.now()
try:
last_update = datetime.datetime.fromisoformat(params.get("LastUpdateTime", encoding='utf8'))
except (TypeError, ValueError):
last_update = now
dt = now - last_update
if dt.days > DAYS_NO_CONNECTIVITY_MAX:
if current_connectivity_alert != "expired":
current_connectivity_alert = "expired"
params.delete("Offroad_ConnectivityNeededPrompt")
params.put("Offroad_ConnectivityNeeded", json.dumps(OFFROAD_ALERTS["Offroad_ConnectivityNeeded"]))
elif dt.days > DAYS_NO_CONNECTIVITY_PROMPT:
remaining_time = str(DAYS_NO_CONNECTIVITY_MAX - dt.days)
if current_connectivity_alert != "prompt" + remaining_time:
current_connectivity_alert = "prompt" + remaining_time
alert_connectivity_prompt = copy.copy(OFFROAD_ALERTS["Offroad_ConnectivityNeededPrompt"])
alert_connectivity_prompt["text"] += remaining_time + " days."
params.delete("Offroad_ConnectivityNeeded")
params.put("Offroad_ConnectivityNeededPrompt", json.dumps(alert_connectivity_prompt))
elif current_connectivity_alert is not None:
current_connectivity_alert = None
params.delete("Offroad_ConnectivityNeeded") | ignition = health is not None and health.health.started
do_uninstall = params.get("DoUninstall") == b"1"
accepted_terms = params.get("HasAcceptedTerms") == terms_version
completed_training = params.get("CompletedTrainingVersion") == training_version
should_start = ignition
# have we seen a panda?
passive = (params.get("Passive") == "1")
# with 2% left, we killall, otherwise the phone will take a long time to boot
should_start = should_start and msg.thermal.freeSpace > 0.02
# confirm we have completed training and aren't uninstalling
should_start = should_start and accepted_terms and (passive or completed_training) and (not do_uninstall)
# if any CPU gets above 107 or the battery gets above 63, kill all processes
# controls will warn with CPU above 95 or battery above 60
if thermal_status >= ThermalStatus.danger:
should_start = False
if thermal_status_prev < ThermalStatus.danger:
params.put("Offroad_TemperatureTooHigh", json.dumps(OFFROAD_ALERTS["Offroad_TemperatureTooHigh"]))
else:
if thermal_status_prev >= ThermalStatus.danger:
params.delete("Offroad_TemperatureTooHigh")
if should_start:
off_ts = None
if started_ts is None:
started_ts = sec_since_boot()
started_seen = True
os.system('echo performance > /sys/class/devfreq/soc:qcom,cpubw/governor')
else:
started_ts = None
if off_ts is None:
off_ts = sec_since_boot()
os.system('echo powersave > /sys/class/devfreq/soc:qcom,cpubw/governor')
# shutdown if the battery gets lower than 3%, it's discharging, we aren't running for
# more than a minute but we were running
if msg.thermal.batteryPercent < BATT_PERC_OFF and msg.thermal.batteryStatus == "Discharging" and \
started_seen and (sec_since_boot() - off_ts) > 60:
os.system('LD_LIBRARY_PATH="" svc power shutdown')
msg.thermal.chargingError = current_filter.x > 0. and msg.thermal.batteryPercent < 90 # if current is positive, then battery is being discharged
msg.thermal.started = started_ts is not None
msg.thermal.startedTs = int(1e9*(started_ts or 0))
msg.thermal.thermalStatus = thermal_status
thermal_sock.send(msg.to_bytes())
if usb_power_prev and not usb_power:
params.put("Offroad_ChargeDisabled", json.dumps(OFFROAD_ALERTS["Offroad_ChargeDisabled"]))
elif usb_power and not usb_power_prev:
params.delete("Offroad_ChargeDisabled")
thermal_status_prev = thermal_status
usb_power_prev = usb_power
print(msg)
# report to server once per minute
if (count % int(60. / DT_TRML)) == 0:
cloudlog.event("STATUS_PACKET",
count=count,
health=(health.to_dict() if health else None),
location=(location.to_dict() if location else None),
thermal=msg.to_dict())
count += 1
def main(gctx=None):
thermald_thread()
if __name__ == "__main__":
main() | params.delete("Offroad_ConnectivityNeededPrompt")
# start constellation of processes when the car starts | random_line_split |
thermald.py | #!/usr/bin/env python3.7
import os
import json
import copy
import datetime
from smbus2 import SMBus
from cereal import log
from common.basedir import BASEDIR
from common.params import Params
from common.realtime import sec_since_boot, DT_TRML
from common.numpy_fast import clip
from common.filter_simple import FirstOrderFilter
from selfdrive.version import terms_version, training_version
from selfdrive.swaglog import cloudlog
import selfdrive.messaging as messaging
from selfdrive.services import service_list
from selfdrive.loggerd.config import get_available_percent
ThermalStatus = log.ThermalData.ThermalStatus
CURRENT_TAU = 15. # 15s time constant
DAYS_NO_CONNECTIVITY_MAX = 7 # do not allow to engage after a week without internet
DAYS_NO_CONNECTIVITY_PROMPT = 4 # send an offroad prompt after 4 days with no internet
with open(BASEDIR + "/selfdrive/controls/lib/alerts_offroad.json") as json_file:
OFFROAD_ALERTS = json.load(json_file)
def read_tz(x):
with open("/sys/devices/virtual/thermal/thermal_zone%d/temp" % x) as f:
ret = max(0, int(f.read()))
return ret
def read_thermal():
dat = messaging.new_message()
dat.init('thermal')
dat.thermal.cpu0 = read_tz(5)
dat.thermal.cpu1 = read_tz(7)
dat.thermal.cpu2 = read_tz(10)
dat.thermal.cpu3 = read_tz(12)
dat.thermal.mem = read_tz(2)
dat.thermal.gpu = read_tz(16)
dat.thermal.bat = read_tz(29)
return dat
LEON = False
def setup_eon_fan():
global LEON
os.system("echo 2 > /sys/module/dwc3_msm/parameters/otg_switch")
bus = SMBus(7, force=True)
try:
bus.write_byte_data(0x21, 0x10, 0xf) # mask all interrupts
bus.write_byte_data(0x21, 0x03, 0x1) # set drive current and global interrupt disable
bus.write_byte_data(0x21, 0x02, 0x2) # needed?
bus.write_byte_data(0x21, 0x04, 0x4) # manual override source
except IOError:
print("LEON detected")
#os.system("echo 1 > /sys/devices/soc/6a00000.ssusb/power_supply/usb/usb_otg")
LEON = True
bus.close()
last_eon_fan_val = None
def | (val):
global LEON, last_eon_fan_val
if last_eon_fan_val is None or last_eon_fan_val != val:
bus = SMBus(7, force=True)
if LEON:
try:
i = [0x1, 0x3 | 0, 0x3 | 0x08, 0x3 | 0x10][val]
bus.write_i2c_block_data(0x3d, 0, [i])
except IOError:
# tusb320
if val == 0:
bus.write_i2c_block_data(0x67, 0xa, [0])
else:
bus.write_i2c_block_data(0x67, 0xa, [0x20])
bus.write_i2c_block_data(0x67, 0x8, [(val-1)<<6])
else:
bus.write_byte_data(0x21, 0x04, 0x2)
bus.write_byte_data(0x21, 0x03, (val*2)+1)
bus.write_byte_data(0x21, 0x04, 0x4)
bus.close()
last_eon_fan_val = val
# temp thresholds to control fan speed - high hysteresis
_TEMP_THRS_H = [50., 65., 80., 10000]
# temp thresholds to control fan speed - low hysteresis
_TEMP_THRS_L = [42.5, 57.5, 72.5, 10000]
# fan speed options
_FAN_SPEEDS = [0, 16384, 32768, 65535]
# max fan speed only allowed if battery is hot
_BAT_TEMP_THERSHOLD = 45.
def handle_fan(max_cpu_temp, bat_temp, fan_speed):
new_speed_h = next(speed for speed, temp_h in zip(_FAN_SPEEDS, _TEMP_THRS_H) if temp_h > max_cpu_temp)
new_speed_l = next(speed for speed, temp_l in zip(_FAN_SPEEDS, _TEMP_THRS_L) if temp_l > max_cpu_temp)
if new_speed_h > fan_speed:
# update speed if using the high thresholds results in fan speed increment
fan_speed = new_speed_h
elif new_speed_l < fan_speed:
# update speed if using the low thresholds results in fan speed decrement
fan_speed = new_speed_l
if bat_temp < _BAT_TEMP_THERSHOLD:
# no max fan speed unless battery is hot
fan_speed = min(fan_speed, _FAN_SPEEDS[-2])
set_eon_fan(fan_speed//16384)
return fan_speed
def thermald_thread():
setup_eon_fan()
# prevent LEECO from undervoltage
BATT_PERC_OFF = 10 if LEON else 3
# now loop
thermal_sock = messaging.pub_sock(service_list['thermal'].port)
health_sock = messaging.sub_sock(service_list['health'].port)
location_sock = messaging.sub_sock(service_list['gpsLocation'].port)
fan_speed = 0
count = 0
off_ts = None
started_ts = None
started_seen = False
thermal_status = ThermalStatus.green
thermal_status_prev = ThermalStatus.green
usb_power = True
usb_power_prev = True
health_sock.RCVTIMEO = int(1000 * 2 * DT_TRML) # 2x the expected health frequency
current_filter = FirstOrderFilter(0., CURRENT_TAU, DT_TRML)
health_prev = None
current_connectivity_alert = None
params = Params()
while 1:
health = messaging.recv_sock(health_sock, wait=True)
location = messaging.recv_sock(location_sock)
location = location.gpsLocation if location else None
msg = read_thermal()
# clear car params when panda gets disconnected
if health is None and health_prev is not None:
params.panda_disconnect()
health_prev = health
if health is not None:
usb_power = health.health.usbPowerMode != log.HealthData.UsbPowerMode.client
# loggerd is gated based on free space
avail = get_available_percent() / 100.0
# thermal message now also includes free space
msg.thermal.freeSpace = avail
with open("/sys/class/power_supply/battery/capacity") as f:
msg.thermal.batteryPercent = int(f.read())
with open("/sys/class/power_supply/battery/status") as f:
msg.thermal.batteryStatus = f.read().strip()
with open("/sys/class/power_supply/battery/current_now") as f:
msg.thermal.batteryCurrent = int(f.read())
with open("/sys/class/power_supply/battery/voltage_now") as f:
msg.thermal.batteryVoltage = int(f.read())
with open("/sys/class/power_supply/usb/present") as f:
msg.thermal.usbOnline = bool(int(f.read()))
current_filter.update(msg.thermal.batteryCurrent / 1e6)
# TODO: add car battery voltage check
max_cpu_temp = max(msg.thermal.cpu0, msg.thermal.cpu1,
msg.thermal.cpu2, msg.thermal.cpu3) / 10.0
max_comp_temp = max(max_cpu_temp, msg.thermal.mem / 10., msg.thermal.gpu / 10.)
bat_temp = msg.thermal.bat/1000.
fan_speed = handle_fan(max_cpu_temp, bat_temp, fan_speed)
msg.thermal.fanSpeed = fan_speed
# thermal logic with hysterisis
if max_cpu_temp > 107. or bat_temp >= 63.:
# onroad not allowed
thermal_status = ThermalStatus.danger
elif max_comp_temp > 92.5 or bat_temp > 60.: # CPU throttling starts around ~90C
# hysteresis between onroad not allowed and engage not allowed
thermal_status = clip(thermal_status, ThermalStatus.red, ThermalStatus.danger)
elif max_cpu_temp > 87.5:
# hysteresis between engage not allowed and uploader not allowed
thermal_status = clip(thermal_status, ThermalStatus.yellow, ThermalStatus.red)
elif max_cpu_temp > 80.0:
# uploader not allowed
thermal_status = ThermalStatus.yellow
elif max_cpu_temp > 75.0:
# hysteresis between uploader not allowed and all good
thermal_status = clip(thermal_status, ThermalStatus.green, ThermalStatus.yellow)
else:
# all good
thermal_status = ThermalStatus.green
# **** starting logic ****
# Check for last update time and display alerts if needed
now = datetime.datetime.now()
try:
last_update = datetime.datetime.fromisoformat(params.get("LastUpdateTime", encoding='utf8'))
except (TypeError, ValueError):
last_update = now
dt = now - last_update
if dt.days > DAYS_NO_CONNECTIVITY_MAX:
if current_connectivity_alert != "expired":
current_connectivity_alert = "expired"
params.delete("Offroad_ConnectivityNeededPrompt")
params.put("Offroad_ConnectivityNeeded", json.dumps(OFFROAD_ALERTS["Offroad_ConnectivityNeeded"]))
elif dt.days > DAYS_NO_CONNECTIVITY_PROMPT:
remaining_time = str(DAYS_NO_CONNECTIVITY_MAX - dt.days)
if current_connectivity_alert != "prompt" + remaining_time:
current_connectivity_alert = "prompt" + remaining_time
alert_connectivity_prompt = copy.copy(OFFROAD_ALERTS["Offroad_ConnectivityNeededPrompt"])
alert_connectivity_prompt["text"] += remaining_time + " days."
params.delete("Offroad_ConnectivityNeeded")
params.put("Offroad_ConnectivityNeededPrompt", json.dumps(alert_connectivity_prompt))
elif current_connectivity_alert is not None:
current_connectivity_alert = None
params.delete("Offroad_ConnectivityNeeded")
params.delete("Offroad_ConnectivityNeededPrompt")
# start constellation of processes when the car starts
ignition = health is not None and health.health.started
do_uninstall = params.get("DoUninstall") == b"1"
accepted_terms = params.get("HasAcceptedTerms") == terms_version
completed_training = params.get("CompletedTrainingVersion") == training_version
should_start = ignition
# have we seen a panda?
passive = (params.get("Passive") == "1")
# with 2% left, we killall, otherwise the phone will take a long time to boot
should_start = should_start and msg.thermal.freeSpace > 0.02
# confirm we have completed training and aren't uninstalling
should_start = should_start and accepted_terms and (passive or completed_training) and (not do_uninstall)
# if any CPU gets above 107 or the battery gets above 63, kill all processes
# controls will warn with CPU above 95 or battery above 60
if thermal_status >= ThermalStatus.danger:
should_start = False
if thermal_status_prev < ThermalStatus.danger:
params.put("Offroad_TemperatureTooHigh", json.dumps(OFFROAD_ALERTS["Offroad_TemperatureTooHigh"]))
else:
if thermal_status_prev >= ThermalStatus.danger:
params.delete("Offroad_TemperatureTooHigh")
if should_start:
off_ts = None
if started_ts is None:
started_ts = sec_since_boot()
started_seen = True
os.system('echo performance > /sys/class/devfreq/soc:qcom,cpubw/governor')
else:
started_ts = None
if off_ts is None:
off_ts = sec_since_boot()
os.system('echo powersave > /sys/class/devfreq/soc:qcom,cpubw/governor')
# shutdown if the battery gets lower than 3%, it's discharging, we aren't running for
# more than a minute but we were running
if msg.thermal.batteryPercent < BATT_PERC_OFF and msg.thermal.batteryStatus == "Discharging" and \
started_seen and (sec_since_boot() - off_ts) > 60:
os.system('LD_LIBRARY_PATH="" svc power shutdown')
msg.thermal.chargingError = current_filter.x > 0. and msg.thermal.batteryPercent < 90 # if current is positive, then battery is being discharged
msg.thermal.started = started_ts is not None
msg.thermal.startedTs = int(1e9*(started_ts or 0))
msg.thermal.thermalStatus = thermal_status
thermal_sock.send(msg.to_bytes())
if usb_power_prev and not usb_power:
params.put("Offroad_ChargeDisabled", json.dumps(OFFROAD_ALERTS["Offroad_ChargeDisabled"]))
elif usb_power and not usb_power_prev:
params.delete("Offroad_ChargeDisabled")
thermal_status_prev = thermal_status
usb_power_prev = usb_power
print(msg)
# report to server once per minute
if (count % int(60. / DT_TRML)) == 0:
cloudlog.event("STATUS_PACKET",
count=count,
health=(health.to_dict() if health else None),
location=(location.to_dict() if location else None),
thermal=msg.to_dict())
count += 1
def main(gctx=None):
thermald_thread()
if __name__ == "__main__":
main()
| set_eon_fan | identifier_name |
thermald.py | #!/usr/bin/env python3.7
import os
import json
import copy
import datetime
from smbus2 import SMBus
from cereal import log
from common.basedir import BASEDIR
from common.params import Params
from common.realtime import sec_since_boot, DT_TRML
from common.numpy_fast import clip
from common.filter_simple import FirstOrderFilter
from selfdrive.version import terms_version, training_version
from selfdrive.swaglog import cloudlog
import selfdrive.messaging as messaging
from selfdrive.services import service_list
from selfdrive.loggerd.config import get_available_percent
ThermalStatus = log.ThermalData.ThermalStatus
CURRENT_TAU = 15. # 15s time constant
DAYS_NO_CONNECTIVITY_MAX = 7 # do not allow to engage after a week without internet
DAYS_NO_CONNECTIVITY_PROMPT = 4 # send an offroad prompt after 4 days with no internet
with open(BASEDIR + "/selfdrive/controls/lib/alerts_offroad.json") as json_file:
OFFROAD_ALERTS = json.load(json_file)
def read_tz(x):
with open("/sys/devices/virtual/thermal/thermal_zone%d/temp" % x) as f:
ret = max(0, int(f.read()))
return ret
def read_thermal():
dat = messaging.new_message()
dat.init('thermal')
dat.thermal.cpu0 = read_tz(5)
dat.thermal.cpu1 = read_tz(7)
dat.thermal.cpu2 = read_tz(10)
dat.thermal.cpu3 = read_tz(12)
dat.thermal.mem = read_tz(2)
dat.thermal.gpu = read_tz(16)
dat.thermal.bat = read_tz(29)
return dat
LEON = False
def setup_eon_fan():
global LEON
os.system("echo 2 > /sys/module/dwc3_msm/parameters/otg_switch")
bus = SMBus(7, force=True)
try:
bus.write_byte_data(0x21, 0x10, 0xf) # mask all interrupts
bus.write_byte_data(0x21, 0x03, 0x1) # set drive current and global interrupt disable
bus.write_byte_data(0x21, 0x02, 0x2) # needed?
bus.write_byte_data(0x21, 0x04, 0x4) # manual override source
except IOError:
print("LEON detected")
#os.system("echo 1 > /sys/devices/soc/6a00000.ssusb/power_supply/usb/usb_otg")
LEON = True
bus.close()
last_eon_fan_val = None
def set_eon_fan(val):
global LEON, last_eon_fan_val
if last_eon_fan_val is None or last_eon_fan_val != val:
bus = SMBus(7, force=True)
if LEON:
try:
i = [0x1, 0x3 | 0, 0x3 | 0x08, 0x3 | 0x10][val]
bus.write_i2c_block_data(0x3d, 0, [i])
except IOError:
# tusb320
if val == 0:
bus.write_i2c_block_data(0x67, 0xa, [0])
else:
bus.write_i2c_block_data(0x67, 0xa, [0x20])
bus.write_i2c_block_data(0x67, 0x8, [(val-1)<<6])
else:
bus.write_byte_data(0x21, 0x04, 0x2)
bus.write_byte_data(0x21, 0x03, (val*2)+1)
bus.write_byte_data(0x21, 0x04, 0x4)
bus.close()
last_eon_fan_val = val
# temp thresholds to control fan speed - high hysteresis
_TEMP_THRS_H = [50., 65., 80., 10000]
# temp thresholds to control fan speed - low hysteresis
_TEMP_THRS_L = [42.5, 57.5, 72.5, 10000]
# fan speed options
_FAN_SPEEDS = [0, 16384, 32768, 65535]
# max fan speed only allowed if battery is hot
_BAT_TEMP_THERSHOLD = 45.
def handle_fan(max_cpu_temp, bat_temp, fan_speed):
new_speed_h = next(speed for speed, temp_h in zip(_FAN_SPEEDS, _TEMP_THRS_H) if temp_h > max_cpu_temp)
new_speed_l = next(speed for speed, temp_l in zip(_FAN_SPEEDS, _TEMP_THRS_L) if temp_l > max_cpu_temp)
if new_speed_h > fan_speed:
# update speed if using the high thresholds results in fan speed increment
fan_speed = new_speed_h
elif new_speed_l < fan_speed:
# update speed if using the low thresholds results in fan speed decrement
fan_speed = new_speed_l
if bat_temp < _BAT_TEMP_THERSHOLD:
# no max fan speed unless battery is hot
fan_speed = min(fan_speed, _FAN_SPEEDS[-2])
set_eon_fan(fan_speed//16384)
return fan_speed
def thermald_thread():
setup_eon_fan()
# prevent LEECO from undervoltage
BATT_PERC_OFF = 10 if LEON else 3
# now loop
thermal_sock = messaging.pub_sock(service_list['thermal'].port)
health_sock = messaging.sub_sock(service_list['health'].port)
location_sock = messaging.sub_sock(service_list['gpsLocation'].port)
fan_speed = 0
count = 0
off_ts = None
started_ts = None
started_seen = False
thermal_status = ThermalStatus.green
thermal_status_prev = ThermalStatus.green
usb_power = True
usb_power_prev = True
health_sock.RCVTIMEO = int(1000 * 2 * DT_TRML) # 2x the expected health frequency
current_filter = FirstOrderFilter(0., CURRENT_TAU, DT_TRML)
health_prev = None
current_connectivity_alert = None
params = Params()
while 1:
|
def main(gctx=None):
thermald_thread()
if __name__ == "__main__":
main()
| health = messaging.recv_sock(health_sock, wait=True)
location = messaging.recv_sock(location_sock)
location = location.gpsLocation if location else None
msg = read_thermal()
# clear car params when panda gets disconnected
if health is None and health_prev is not None:
params.panda_disconnect()
health_prev = health
if health is not None:
usb_power = health.health.usbPowerMode != log.HealthData.UsbPowerMode.client
# loggerd is gated based on free space
avail = get_available_percent() / 100.0
# thermal message now also includes free space
msg.thermal.freeSpace = avail
with open("/sys/class/power_supply/battery/capacity") as f:
msg.thermal.batteryPercent = int(f.read())
with open("/sys/class/power_supply/battery/status") as f:
msg.thermal.batteryStatus = f.read().strip()
with open("/sys/class/power_supply/battery/current_now") as f:
msg.thermal.batteryCurrent = int(f.read())
with open("/sys/class/power_supply/battery/voltage_now") as f:
msg.thermal.batteryVoltage = int(f.read())
with open("/sys/class/power_supply/usb/present") as f:
msg.thermal.usbOnline = bool(int(f.read()))
current_filter.update(msg.thermal.batteryCurrent / 1e6)
# TODO: add car battery voltage check
max_cpu_temp = max(msg.thermal.cpu0, msg.thermal.cpu1,
msg.thermal.cpu2, msg.thermal.cpu3) / 10.0
max_comp_temp = max(max_cpu_temp, msg.thermal.mem / 10., msg.thermal.gpu / 10.)
bat_temp = msg.thermal.bat/1000.
fan_speed = handle_fan(max_cpu_temp, bat_temp, fan_speed)
msg.thermal.fanSpeed = fan_speed
# thermal logic with hysterisis
if max_cpu_temp > 107. or bat_temp >= 63.:
# onroad not allowed
thermal_status = ThermalStatus.danger
elif max_comp_temp > 92.5 or bat_temp > 60.: # CPU throttling starts around ~90C
# hysteresis between onroad not allowed and engage not allowed
thermal_status = clip(thermal_status, ThermalStatus.red, ThermalStatus.danger)
elif max_cpu_temp > 87.5:
# hysteresis between engage not allowed and uploader not allowed
thermal_status = clip(thermal_status, ThermalStatus.yellow, ThermalStatus.red)
elif max_cpu_temp > 80.0:
# uploader not allowed
thermal_status = ThermalStatus.yellow
elif max_cpu_temp > 75.0:
# hysteresis between uploader not allowed and all good
thermal_status = clip(thermal_status, ThermalStatus.green, ThermalStatus.yellow)
else:
# all good
thermal_status = ThermalStatus.green
# **** starting logic ****
# Check for last update time and display alerts if needed
now = datetime.datetime.now()
try:
last_update = datetime.datetime.fromisoformat(params.get("LastUpdateTime", encoding='utf8'))
except (TypeError, ValueError):
last_update = now
dt = now - last_update
if dt.days > DAYS_NO_CONNECTIVITY_MAX:
if current_connectivity_alert != "expired":
current_connectivity_alert = "expired"
params.delete("Offroad_ConnectivityNeededPrompt")
params.put("Offroad_ConnectivityNeeded", json.dumps(OFFROAD_ALERTS["Offroad_ConnectivityNeeded"]))
elif dt.days > DAYS_NO_CONNECTIVITY_PROMPT:
remaining_time = str(DAYS_NO_CONNECTIVITY_MAX - dt.days)
if current_connectivity_alert != "prompt" + remaining_time:
current_connectivity_alert = "prompt" + remaining_time
alert_connectivity_prompt = copy.copy(OFFROAD_ALERTS["Offroad_ConnectivityNeededPrompt"])
alert_connectivity_prompt["text"] += remaining_time + " days."
params.delete("Offroad_ConnectivityNeeded")
params.put("Offroad_ConnectivityNeededPrompt", json.dumps(alert_connectivity_prompt))
elif current_connectivity_alert is not None:
current_connectivity_alert = None
params.delete("Offroad_ConnectivityNeeded")
params.delete("Offroad_ConnectivityNeededPrompt")
# start constellation of processes when the car starts
ignition = health is not None and health.health.started
do_uninstall = params.get("DoUninstall") == b"1"
accepted_terms = params.get("HasAcceptedTerms") == terms_version
completed_training = params.get("CompletedTrainingVersion") == training_version
should_start = ignition
# have we seen a panda?
passive = (params.get("Passive") == "1")
# with 2% left, we killall, otherwise the phone will take a long time to boot
should_start = should_start and msg.thermal.freeSpace > 0.02
# confirm we have completed training and aren't uninstalling
should_start = should_start and accepted_terms and (passive or completed_training) and (not do_uninstall)
# if any CPU gets above 107 or the battery gets above 63, kill all processes
# controls will warn with CPU above 95 or battery above 60
if thermal_status >= ThermalStatus.danger:
should_start = False
if thermal_status_prev < ThermalStatus.danger:
params.put("Offroad_TemperatureTooHigh", json.dumps(OFFROAD_ALERTS["Offroad_TemperatureTooHigh"]))
else:
if thermal_status_prev >= ThermalStatus.danger:
params.delete("Offroad_TemperatureTooHigh")
if should_start:
off_ts = None
if started_ts is None:
started_ts = sec_since_boot()
started_seen = True
os.system('echo performance > /sys/class/devfreq/soc:qcom,cpubw/governor')
else:
started_ts = None
if off_ts is None:
off_ts = sec_since_boot()
os.system('echo powersave > /sys/class/devfreq/soc:qcom,cpubw/governor')
# shutdown if the battery gets lower than 3%, it's discharging, we aren't running for
# more than a minute but we were running
if msg.thermal.batteryPercent < BATT_PERC_OFF and msg.thermal.batteryStatus == "Discharging" and \
started_seen and (sec_since_boot() - off_ts) > 60:
os.system('LD_LIBRARY_PATH="" svc power shutdown')
msg.thermal.chargingError = current_filter.x > 0. and msg.thermal.batteryPercent < 90 # if current is positive, then battery is being discharged
msg.thermal.started = started_ts is not None
msg.thermal.startedTs = int(1e9*(started_ts or 0))
msg.thermal.thermalStatus = thermal_status
thermal_sock.send(msg.to_bytes())
if usb_power_prev and not usb_power:
params.put("Offroad_ChargeDisabled", json.dumps(OFFROAD_ALERTS["Offroad_ChargeDisabled"]))
elif usb_power and not usb_power_prev:
params.delete("Offroad_ChargeDisabled")
thermal_status_prev = thermal_status
usb_power_prev = usb_power
print(msg)
# report to server once per minute
if (count % int(60. / DT_TRML)) == 0:
cloudlog.event("STATUS_PACKET",
count=count,
health=(health.to_dict() if health else None),
location=(location.to_dict() if location else None),
thermal=msg.to_dict())
count += 1 | conditional_block |
falcon.py | """
Python implementation of Falcon:
https://falcon-sign.info/.
"""
from .common import q
from numpy import set_printoptions
from math import sqrt
from .fft import fft, ifft, sub, neg, add_fft, mul_fft
from .ntt import sub_zq, mul_zq, div_zq
from .ffsampling import gram, ffldl_fft, ffsampling_fft
from .ntrugen import ntru_gen
from .encoding import compress, decompress
# https://pycryptodome.readthedocs.io/en/latest/src/hash/shake256.html
from Crypto.Hash import SHAKE256
# Randomness
from os import urandom
from .rng import ChaCha20
# For debugging purposes
import sys
if sys.version_info >= (3, 4):
from importlib import reload # Python 3.4+ only.
set_printoptions(linewidth=200, precision=5, suppress=True)
logn = {
2: 1,
4: 2,
8: 3,
16: 4,
32: 5,
64: 6,
128: 7,
256: 8,
512: 9,
1024: 10
}
# Bytelength of the signing salt and header
HEAD_LEN = 1
SALT_LEN = 40
SEED_LEN = 56
# Parameter sets for Falcon:
# - n is the dimension/degree of the cyclotomic ring
# - sigma is the std. dev. of signatures (Gaussians over a lattice)
# - sigmin is a lower bounds on the std. dev. of each Gaussian over Z
# - sigbound is the upper bound on ||s0||^2 + ||s1||^2
# - sig_bytelen is the bytelength of signatures
Params = {
# FalconParam(2, 2)
2: {
"n": 2,
"sigma": 144.81253976308423,
"sigmin": 1.1165085072329104,
"sig_bound": 101498,
"sig_bytelen": 44,
},
# FalconParam(4, 2)
4: {
"n": 4,
"sigma": 146.83798833523608,
"sigmin": 1.1321247692325274,
"sig_bound": 208714,
"sig_bytelen": 47,
},
# FalconParam(8, 2)
8: {
"n": 8,
"sigma": 148.83587593064718,
"sigmin": 1.147528535373367,
"sig_bound": 428865,
"sig_bytelen": 52,
},
# FalconParam(16, 4)
16: {
"n": 16,
"sigma": 151.78340713845503,
"sigmin": 1.170254078853483,
"sig_bound": 892039,
"sig_bytelen": 63,
},
# FalconParam(32, 8)
32: {
"n": 32,
"sigma": 154.6747794602761,
"sigmin": 1.1925466358390344,
"sig_bound": 1852696,
"sig_bytelen": 82,
},
# FalconParam(64, 16)
64: {
"n": 64,
"sigma": 157.51308555044122,
"sigmin": 1.2144300507766141,
"sig_bound": 3842630,
"sig_bytelen": 122,
},
# FalconParam(128, 32)
128: {
"n": 128,
"sigma": 160.30114421975344,
"sigmin": 1.235926056771981,
"sig_bound": 7959734,
"sig_bytelen": 200,
},
# FalconParam(256, 64)
256: {
"n": 256,
"sigma": 163.04153322607107,
"sigmin": 1.2570545284063217,
"sig_bound": 16468416,
"sig_bytelen": 356,
},
# FalconParam(512, 128)
512: {
"n": 512,
"sigma": 165.7366171829776,
"sigmin": 1.2778336969128337,
"sig_bound": 34034726,
"sig_bytelen": 666,
},
# FalconParam(1024, 256)
1024: {
"n": 1024,
"sigma": 168.38857144654395,
"sigmin": 1.298280334344292,
"sig_bound": 70265242,
"sig_bytelen": 1280,
},
}
def print_tree(tree, pref=""):
"""
Display a LDL tree in a readable form.
Args:
T: a LDL tree
Format: coefficient or fft
"""
leaf = "|_____> "
top = "|_______"
son1 = "| "
son2 = " "
width = len(top)
a = ""
if len(tree) == 3:
if (pref == ""):
a += pref + str(tree[0]) + "\n"
else:
a += pref[:-width] + top + str(tree[0]) + "\n"
a += print_tree(tree[1], pref + son1)
a += print_tree(tree[2], pref + son2)
return a
else:
return (pref[:-width] + leaf + str(tree) + "\n")
def normalize_tree(tree, sigma):
"""
Normalize leaves of a LDL tree (from values ||b_i||**2 to sigma/||b_i||).
Args:
T: a LDL tree
sigma: a standard deviation
Format: coefficient or fft
"""
if len(tree) == 3:
normalize_tree(tree[1], sigma)
normalize_tree(tree[2], sigma)
else:
tree[0] = sigma / sqrt(tree[0].real)
tree[1] = 0
class PublicKey:
"""
This class contains methods for performing public key operations in Falcon.
"""
def __init__(self, sk=None, n=None, h=None):
"""Initialize a public key."""
if sk:
self.n = sk.n
self.h = sk.h
elif n and h:
self.n = n
self.h = h
else:
raise Exception("Public Key construction failed: insufficient/wrong arguments")
self.signature_bound = Params[self.n]["sig_bound"]
self.sig_bytelen = Params[self.n]["sig_bytelen"]
def __repr__(self):
"""Print the object in readable form."""
rep = "Public for n = {n}:\n\n".format(n=self.n)
rep += "h = {h}\n".format(h=self.h)
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def verify(self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True
class SecretKey:
"""
This class contains methods for performing
secret key operations (and also public key operations) in Falcon.
One can:
- initialize a secret key for:
- n = 128, 256, 512, 1024,
- phi = x ** n + 1,
- q = 12 * 1024 + 1
- find a preimage t of a point c (both in ( Z[x] mod (Phi,q) )**2 ) such that t*B0 = c
- hash a message to a point of Z[x] mod (Phi,q)
- sign a message
- verify the signature of a message
"""
def __init__(self, n, polys=None):
"""Initialize a secret key."""
# Public parameters
self.n = n
self.sigma = Params[n]["sigma"]
self.sigmin = Params[n]["sigmin"]
self.signature_bound = Params[n]["sig_bound"]
self.sig_bytelen = Params[n]["sig_bytelen"]
# Compute NTRU polynomials f, g, F, G verifying fG - gF = q mod Phi
if polys is None:
self.f, self.g, self.F, self.G = ntru_gen(n)
else:
[f, g, F, G] = polys
assert all((len(poly) == n) for poly in [f, g, F, G])
self.f = f[:]
self.g = g[:]
self.F = F[:]
self.G = G[:]
# From f, g, F, G, compute the basis B0 of a NTRU lattice
# as well as its Gram matrix and their fft's.
B0 = [[self.g, neg(self.f)], [self.G, neg(self.F)]]
G0 = gram(B0)
self.B0_fft = [[fft(elt) for elt in row] for row in B0]
G0_fft = [[fft(elt) for elt in row] for row in G0]
self.T_fft = ffldl_fft(G0_fft)
# Normalize Falcon tree
normalize_tree(self.T_fft, self.sigma)
# The public key is a polynomial such that h*f = g mod (Phi,q)
self.h = div_zq(self.g, self.f)
def __repr__(self, verbose=False):
"""Print the object in readable form."""
rep = "Private key for n = {n}:\n\n".format(n=self.n)
rep += "f = {f}\n\n".format(f=self.f)
rep += "g = {g}\n\n".format(g=self.g)
rep += "F = {F}\n\n".format(F=self.F)
rep += "G = {G}\n\n".format(G=self.G)
if verbose:
rep += "\nFFT tree\n"
rep += print_tree(self.T_fft, pref="")
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def sample_preimage(self, point, seed=None):
"""
Sample a short vector s such that s[0] + s[1] * h = point.
"""
[[a, b], [c, d]] = self.B0_fft
# We compute a vector t_fft such that:
# (fft(point), fft(0)) * B0_fft = t_fft
# Because fft(0) = 0 and the inverse of B has a very specific form,
# we can do several optimizations.
'''
print("---------Inside sample_preimage----------")
print("point: ", point)
'''
point_fft = fft(point)
t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]
t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]
t_fft = [t0_fft, t1_fft]
# We now compute v such that:
# v = z * B0 for an integral vector z
# v is close to (point, 0)
if seed is None:
# If no seed is defined, use urandom as the pseudo-random source.
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)
else:
# If a seed is defined, initialize a ChaCha20 PRG
# that is used to generate pseudo-randomness.
chacha_prng = ChaCha20(seed)
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,
chacha_prng.randombytes)
v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))
v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))
v0 = [int(round(elt)) for elt in ifft(v0_fft)]
v1 = [int(round(elt)) for elt in ifft(v1_fft)]
# The difference s = (point, 0) - v is such that:
# s is short
# s[0] + s[1] * h = point
s = [sub(point, v0), neg(v1)]
return s
def sign(self, message, randombytes=urandom):
"""
Sign a message. The message MUST be a byte string or byte array.
Optionally, one can select the source of (pseudo-)randomness used
(default: urandom).
"""
int_header = 0x30 + logn[self.n]
header = int_header.to_bytes(1, "little")
salt = randombytes(SALT_LEN)
hashed = self.hash_to_point(message, salt)
# We repeat the signing procedure until we find a signature that is
# short enough (both the Euclidean norm and the bytelength)
'''
print("---------Inside sign----------")
'''
while(1):
if (randombytes == urandom):
s = self.sample_preimage(hashed)
'''
print("s: ", s)
'''
else:
seed = randombytes(SEED_LEN)
s = self.sample_preimage(hashed, seed=seed)
norm_sign = sum(coef ** 2 for coef in s[0])
norm_sign += sum(coef ** 2 for coef in s[1])
# Check the Euclidean norm
if norm_sign <= self.signature_bound:
enc_s = compress(s[1], self.sig_bytelen - HEAD_LEN - SALT_LEN)
# Check that the encoding is valid (sometimes it fails)
if (enc_s is not False):
return header + salt + enc_s
'''
else:
print("-------------INVALID encoding---------------")
else:
print("-------------NOT within signature bound---------------")
'''
def verify(self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
| s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True | random_line_split | |
falcon.py | """
Python implementation of Falcon:
https://falcon-sign.info/.
"""
from .common import q
from numpy import set_printoptions
from math import sqrt
from .fft import fft, ifft, sub, neg, add_fft, mul_fft
from .ntt import sub_zq, mul_zq, div_zq
from .ffsampling import gram, ffldl_fft, ffsampling_fft
from .ntrugen import ntru_gen
from .encoding import compress, decompress
# https://pycryptodome.readthedocs.io/en/latest/src/hash/shake256.html
from Crypto.Hash import SHAKE256
# Randomness
from os import urandom
from .rng import ChaCha20
# For debugging purposes
import sys
if sys.version_info >= (3, 4):
from importlib import reload # Python 3.4+ only.
set_printoptions(linewidth=200, precision=5, suppress=True)
logn = {
2: 1,
4: 2,
8: 3,
16: 4,
32: 5,
64: 6,
128: 7,
256: 8,
512: 9,
1024: 10
}
# Bytelength of the signing salt and header
HEAD_LEN = 1
SALT_LEN = 40
SEED_LEN = 56
# Parameter sets for Falcon:
# - n is the dimension/degree of the cyclotomic ring
# - sigma is the std. dev. of signatures (Gaussians over a lattice)
# - sigmin is a lower bounds on the std. dev. of each Gaussian over Z
# - sigbound is the upper bound on ||s0||^2 + ||s1||^2
# - sig_bytelen is the bytelength of signatures
Params = {
# FalconParam(2, 2)
2: {
"n": 2,
"sigma": 144.81253976308423,
"sigmin": 1.1165085072329104,
"sig_bound": 101498,
"sig_bytelen": 44,
},
# FalconParam(4, 2)
4: {
"n": 4,
"sigma": 146.83798833523608,
"sigmin": 1.1321247692325274,
"sig_bound": 208714,
"sig_bytelen": 47,
},
# FalconParam(8, 2)
8: {
"n": 8,
"sigma": 148.83587593064718,
"sigmin": 1.147528535373367,
"sig_bound": 428865,
"sig_bytelen": 52,
},
# FalconParam(16, 4)
16: {
"n": 16,
"sigma": 151.78340713845503,
"sigmin": 1.170254078853483,
"sig_bound": 892039,
"sig_bytelen": 63,
},
# FalconParam(32, 8)
32: {
"n": 32,
"sigma": 154.6747794602761,
"sigmin": 1.1925466358390344,
"sig_bound": 1852696,
"sig_bytelen": 82,
},
# FalconParam(64, 16)
64: {
"n": 64,
"sigma": 157.51308555044122,
"sigmin": 1.2144300507766141,
"sig_bound": 3842630,
"sig_bytelen": 122,
},
# FalconParam(128, 32)
128: {
"n": 128,
"sigma": 160.30114421975344,
"sigmin": 1.235926056771981,
"sig_bound": 7959734,
"sig_bytelen": 200,
},
# FalconParam(256, 64)
256: {
"n": 256,
"sigma": 163.04153322607107,
"sigmin": 1.2570545284063217,
"sig_bound": 16468416,
"sig_bytelen": 356,
},
# FalconParam(512, 128)
512: {
"n": 512,
"sigma": 165.7366171829776,
"sigmin": 1.2778336969128337,
"sig_bound": 34034726,
"sig_bytelen": 666,
},
# FalconParam(1024, 256)
1024: {
"n": 1024,
"sigma": 168.38857144654395,
"sigmin": 1.298280334344292,
"sig_bound": 70265242,
"sig_bytelen": 1280,
},
}
def print_tree(tree, pref=""):
"""
Display a LDL tree in a readable form.
Args:
T: a LDL tree
Format: coefficient or fft
"""
leaf = "|_____> "
top = "|_______"
son1 = "| "
son2 = " "
width = len(top)
a = ""
if len(tree) == 3:
if (pref == ""):
a += pref + str(tree[0]) + "\n"
else:
a += pref[:-width] + top + str(tree[0]) + "\n"
a += print_tree(tree[1], pref + son1)
a += print_tree(tree[2], pref + son2)
return a
else:
return (pref[:-width] + leaf + str(tree) + "\n")
def normalize_tree(tree, sigma):
"""
Normalize leaves of a LDL tree (from values ||b_i||**2 to sigma/||b_i||).
Args:
T: a LDL tree
sigma: a standard deviation
Format: coefficient or fft
"""
if len(tree) == 3:
normalize_tree(tree[1], sigma)
normalize_tree(tree[2], sigma)
else:
tree[0] = sigma / sqrt(tree[0].real)
tree[1] = 0
class PublicKey:
"""
This class contains methods for performing public key operations in Falcon.
"""
def __init__(self, sk=None, n=None, h=None):
"""Initialize a public key."""
if sk:
self.n = sk.n
self.h = sk.h
elif n and h:
self.n = n
self.h = h
else:
raise Exception("Public Key construction failed: insufficient/wrong arguments")
self.signature_bound = Params[self.n]["sig_bound"]
self.sig_bytelen = Params[self.n]["sig_bytelen"]
def __repr__(self):
"""Print the object in readable form."""
rep = "Public for n = {n}:\n\n".format(n=self.n)
rep += "h = {h}\n".format(h=self.h)
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def verify(self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True
class SecretKey:
"""
This class contains methods for performing
secret key operations (and also public key operations) in Falcon.
One can:
- initialize a secret key for:
- n = 128, 256, 512, 1024,
- phi = x ** n + 1,
- q = 12 * 1024 + 1
- find a preimage t of a point c (both in ( Z[x] mod (Phi,q) )**2 ) such that t*B0 = c
- hash a message to a point of Z[x] mod (Phi,q)
- sign a message
- verify the signature of a message
"""
def __init__(self, n, polys=None):
"""Initialize a secret key."""
# Public parameters
self.n = n
self.sigma = Params[n]["sigma"]
self.sigmin = Params[n]["sigmin"]
self.signature_bound = Params[n]["sig_bound"]
self.sig_bytelen = Params[n]["sig_bytelen"]
# Compute NTRU polynomials f, g, F, G verifying fG - gF = q mod Phi
if polys is None:
self.f, self.g, self.F, self.G = ntru_gen(n)
else:
[f, g, F, G] = polys
assert all((len(poly) == n) for poly in [f, g, F, G])
self.f = f[:]
self.g = g[:]
self.F = F[:]
self.G = G[:]
# From f, g, F, G, compute the basis B0 of a NTRU lattice
# as well as its Gram matrix and their fft's.
B0 = [[self.g, neg(self.f)], [self.G, neg(self.F)]]
G0 = gram(B0)
self.B0_fft = [[fft(elt) for elt in row] for row in B0]
G0_fft = [[fft(elt) for elt in row] for row in G0]
self.T_fft = ffldl_fft(G0_fft)
# Normalize Falcon tree
normalize_tree(self.T_fft, self.sigma)
# The public key is a polynomial such that h*f = g mod (Phi,q)
self.h = div_zq(self.g, self.f)
def __repr__(self, verbose=False):
"""Print the object in readable form."""
rep = "Private key for n = {n}:\n\n".format(n=self.n)
rep += "f = {f}\n\n".format(f=self.f)
rep += "g = {g}\n\n".format(g=self.g)
rep += "F = {F}\n\n".format(F=self.F)
rep += "G = {G}\n\n".format(G=self.G)
if verbose:
rep += "\nFFT tree\n"
rep += print_tree(self.T_fft, pref="")
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def sample_preimage(self, point, seed=None):
"""
Sample a short vector s such that s[0] + s[1] * h = point.
"""
[[a, b], [c, d]] = self.B0_fft
# We compute a vector t_fft such that:
# (fft(point), fft(0)) * B0_fft = t_fft
# Because fft(0) = 0 and the inverse of B has a very specific form,
# we can do several optimizations.
'''
print("---------Inside sample_preimage----------")
print("point: ", point)
'''
point_fft = fft(point)
t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]
t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]
t_fft = [t0_fft, t1_fft]
# We now compute v such that:
# v = z * B0 for an integral vector z
# v is close to (point, 0)
if seed is None:
# If no seed is defined, use urandom as the pseudo-random source.
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)
else:
# If a seed is defined, initialize a ChaCha20 PRG
# that is used to generate pseudo-randomness.
chacha_prng = ChaCha20(seed)
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,
chacha_prng.randombytes)
v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))
v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))
v0 = [int(round(elt)) for elt in ifft(v0_fft)]
v1 = [int(round(elt)) for elt in ifft(v1_fft)]
# The difference s = (point, 0) - v is such that:
# s is short
# s[0] + s[1] * h = point
s = [sub(point, v0), neg(v1)]
return s
def sign(self, message, randombytes=urandom):
"""
Sign a message. The message MUST be a byte string or byte array.
Optionally, one can select the source of (pseudo-)randomness used
(default: urandom).
"""
int_header = 0x30 + logn[self.n]
header = int_header.to_bytes(1, "little")
salt = randombytes(SALT_LEN)
hashed = self.hash_to_point(message, salt)
# We repeat the signing procedure until we find a signature that is
# short enough (both the Euclidean norm and the bytelength)
'''
print("---------Inside sign----------")
'''
while(1):
if (randombytes == urandom):
s = self.sample_preimage(hashed)
'''
print("s: ", s)
'''
else:
seed = randombytes(SEED_LEN)
s = self.sample_preimage(hashed, seed=seed)
norm_sign = sum(coef ** 2 for coef in s[0])
norm_sign += sum(coef ** 2 for coef in s[1])
# Check the Euclidean norm
if norm_sign <= self.signature_bound:
enc_s = compress(s[1], self.sig_bytelen - HEAD_LEN - SALT_LEN)
# Check that the encoding is valid (sometimes it fails)
if (enc_s is not False):
|
'''
else:
print("-------------INVALID encoding---------------")
else:
print("-------------NOT within signature bound---------------")
'''
def verify(self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True
| return header + salt + enc_s | conditional_block |
falcon.py | """
Python implementation of Falcon:
https://falcon-sign.info/.
"""
from .common import q
from numpy import set_printoptions
from math import sqrt
from .fft import fft, ifft, sub, neg, add_fft, mul_fft
from .ntt import sub_zq, mul_zq, div_zq
from .ffsampling import gram, ffldl_fft, ffsampling_fft
from .ntrugen import ntru_gen
from .encoding import compress, decompress
# https://pycryptodome.readthedocs.io/en/latest/src/hash/shake256.html
from Crypto.Hash import SHAKE256
# Randomness
from os import urandom
from .rng import ChaCha20
# For debugging purposes
import sys
if sys.version_info >= (3, 4):
from importlib import reload # Python 3.4+ only.
set_printoptions(linewidth=200, precision=5, suppress=True)
logn = {
2: 1,
4: 2,
8: 3,
16: 4,
32: 5,
64: 6,
128: 7,
256: 8,
512: 9,
1024: 10
}
# Bytelength of the signing salt and header
HEAD_LEN = 1
SALT_LEN = 40
SEED_LEN = 56
# Parameter sets for Falcon:
# - n is the dimension/degree of the cyclotomic ring
# - sigma is the std. dev. of signatures (Gaussians over a lattice)
# - sigmin is a lower bounds on the std. dev. of each Gaussian over Z
# - sigbound is the upper bound on ||s0||^2 + ||s1||^2
# - sig_bytelen is the bytelength of signatures
Params = {
# FalconParam(2, 2)
2: {
"n": 2,
"sigma": 144.81253976308423,
"sigmin": 1.1165085072329104,
"sig_bound": 101498,
"sig_bytelen": 44,
},
# FalconParam(4, 2)
4: {
"n": 4,
"sigma": 146.83798833523608,
"sigmin": 1.1321247692325274,
"sig_bound": 208714,
"sig_bytelen": 47,
},
# FalconParam(8, 2)
8: {
"n": 8,
"sigma": 148.83587593064718,
"sigmin": 1.147528535373367,
"sig_bound": 428865,
"sig_bytelen": 52,
},
# FalconParam(16, 4)
16: {
"n": 16,
"sigma": 151.78340713845503,
"sigmin": 1.170254078853483,
"sig_bound": 892039,
"sig_bytelen": 63,
},
# FalconParam(32, 8)
32: {
"n": 32,
"sigma": 154.6747794602761,
"sigmin": 1.1925466358390344,
"sig_bound": 1852696,
"sig_bytelen": 82,
},
# FalconParam(64, 16)
64: {
"n": 64,
"sigma": 157.51308555044122,
"sigmin": 1.2144300507766141,
"sig_bound": 3842630,
"sig_bytelen": 122,
},
# FalconParam(128, 32)
128: {
"n": 128,
"sigma": 160.30114421975344,
"sigmin": 1.235926056771981,
"sig_bound": 7959734,
"sig_bytelen": 200,
},
# FalconParam(256, 64)
256: {
"n": 256,
"sigma": 163.04153322607107,
"sigmin": 1.2570545284063217,
"sig_bound": 16468416,
"sig_bytelen": 356,
},
# FalconParam(512, 128)
512: {
"n": 512,
"sigma": 165.7366171829776,
"sigmin": 1.2778336969128337,
"sig_bound": 34034726,
"sig_bytelen": 666,
},
# FalconParam(1024, 256)
1024: {
"n": 1024,
"sigma": 168.38857144654395,
"sigmin": 1.298280334344292,
"sig_bound": 70265242,
"sig_bytelen": 1280,
},
}
def print_tree(tree, pref=""):
"""
Display a LDL tree in a readable form.
Args:
T: a LDL tree
Format: coefficient or fft
"""
leaf = "|_____> "
top = "|_______"
son1 = "| "
son2 = " "
width = len(top)
a = ""
if len(tree) == 3:
if (pref == ""):
a += pref + str(tree[0]) + "\n"
else:
a += pref[:-width] + top + str(tree[0]) + "\n"
a += print_tree(tree[1], pref + son1)
a += print_tree(tree[2], pref + son2)
return a
else:
return (pref[:-width] + leaf + str(tree) + "\n")
def normalize_tree(tree, sigma):
"""
Normalize leaves of a LDL tree (from values ||b_i||**2 to sigma/||b_i||).
Args:
T: a LDL tree
sigma: a standard deviation
Format: coefficient or fft
"""
if len(tree) == 3:
normalize_tree(tree[1], sigma)
normalize_tree(tree[2], sigma)
else:
tree[0] = sigma / sqrt(tree[0].real)
tree[1] = 0
class PublicKey:
"""
This class contains methods for performing public key operations in Falcon.
"""
def __init__(self, sk=None, n=None, h=None):
"""Initialize a public key."""
if sk:
self.n = sk.n
self.h = sk.h
elif n and h:
self.n = n
self.h = h
else:
raise Exception("Public Key construction failed: insufficient/wrong arguments")
self.signature_bound = Params[self.n]["sig_bound"]
self.sig_bytelen = Params[self.n]["sig_bytelen"]
def __repr__(self):
"""Print the object in readable form."""
rep = "Public for n = {n}:\n\n".format(n=self.n)
rep += "h = {h}\n".format(h=self.h)
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def | (self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True
class SecretKey:
"""
This class contains methods for performing
secret key operations (and also public key operations) in Falcon.
One can:
- initialize a secret key for:
- n = 128, 256, 512, 1024,
- phi = x ** n + 1,
- q = 12 * 1024 + 1
- find a preimage t of a point c (both in ( Z[x] mod (Phi,q) )**2 ) such that t*B0 = c
- hash a message to a point of Z[x] mod (Phi,q)
- sign a message
- verify the signature of a message
"""
def __init__(self, n, polys=None):
"""Initialize a secret key."""
# Public parameters
self.n = n
self.sigma = Params[n]["sigma"]
self.sigmin = Params[n]["sigmin"]
self.signature_bound = Params[n]["sig_bound"]
self.sig_bytelen = Params[n]["sig_bytelen"]
# Compute NTRU polynomials f, g, F, G verifying fG - gF = q mod Phi
if polys is None:
self.f, self.g, self.F, self.G = ntru_gen(n)
else:
[f, g, F, G] = polys
assert all((len(poly) == n) for poly in [f, g, F, G])
self.f = f[:]
self.g = g[:]
self.F = F[:]
self.G = G[:]
# From f, g, F, G, compute the basis B0 of a NTRU lattice
# as well as its Gram matrix and their fft's.
B0 = [[self.g, neg(self.f)], [self.G, neg(self.F)]]
G0 = gram(B0)
self.B0_fft = [[fft(elt) for elt in row] for row in B0]
G0_fft = [[fft(elt) for elt in row] for row in G0]
self.T_fft = ffldl_fft(G0_fft)
# Normalize Falcon tree
normalize_tree(self.T_fft, self.sigma)
# The public key is a polynomial such that h*f = g mod (Phi,q)
self.h = div_zq(self.g, self.f)
def __repr__(self, verbose=False):
"""Print the object in readable form."""
rep = "Private key for n = {n}:\n\n".format(n=self.n)
rep += "f = {f}\n\n".format(f=self.f)
rep += "g = {g}\n\n".format(g=self.g)
rep += "F = {F}\n\n".format(F=self.F)
rep += "G = {G}\n\n".format(G=self.G)
if verbose:
rep += "\nFFT tree\n"
rep += print_tree(self.T_fft, pref="")
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def sample_preimage(self, point, seed=None):
"""
Sample a short vector s such that s[0] + s[1] * h = point.
"""
[[a, b], [c, d]] = self.B0_fft
# We compute a vector t_fft such that:
# (fft(point), fft(0)) * B0_fft = t_fft
# Because fft(0) = 0 and the inverse of B has a very specific form,
# we can do several optimizations.
'''
print("---------Inside sample_preimage----------")
print("point: ", point)
'''
point_fft = fft(point)
t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]
t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]
t_fft = [t0_fft, t1_fft]
# We now compute v such that:
# v = z * B0 for an integral vector z
# v is close to (point, 0)
if seed is None:
# If no seed is defined, use urandom as the pseudo-random source.
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)
else:
# If a seed is defined, initialize a ChaCha20 PRG
# that is used to generate pseudo-randomness.
chacha_prng = ChaCha20(seed)
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,
chacha_prng.randombytes)
v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))
v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))
v0 = [int(round(elt)) for elt in ifft(v0_fft)]
v1 = [int(round(elt)) for elt in ifft(v1_fft)]
# The difference s = (point, 0) - v is such that:
# s is short
# s[0] + s[1] * h = point
s = [sub(point, v0), neg(v1)]
return s
def sign(self, message, randombytes=urandom):
"""
Sign a message. The message MUST be a byte string or byte array.
Optionally, one can select the source of (pseudo-)randomness used
(default: urandom).
"""
int_header = 0x30 + logn[self.n]
header = int_header.to_bytes(1, "little")
salt = randombytes(SALT_LEN)
hashed = self.hash_to_point(message, salt)
# We repeat the signing procedure until we find a signature that is
# short enough (both the Euclidean norm and the bytelength)
'''
print("---------Inside sign----------")
'''
while(1):
if (randombytes == urandom):
s = self.sample_preimage(hashed)
'''
print("s: ", s)
'''
else:
seed = randombytes(SEED_LEN)
s = self.sample_preimage(hashed, seed=seed)
norm_sign = sum(coef ** 2 for coef in s[0])
norm_sign += sum(coef ** 2 for coef in s[1])
# Check the Euclidean norm
if norm_sign <= self.signature_bound:
enc_s = compress(s[1], self.sig_bytelen - HEAD_LEN - SALT_LEN)
# Check that the encoding is valid (sometimes it fails)
if (enc_s is not False):
return header + salt + enc_s
'''
else:
print("-------------INVALID encoding---------------")
else:
print("-------------NOT within signature bound---------------")
'''
def verify(self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True
| verify | identifier_name |
falcon.py | """
Python implementation of Falcon:
https://falcon-sign.info/.
"""
from .common import q
from numpy import set_printoptions
from math import sqrt
from .fft import fft, ifft, sub, neg, add_fft, mul_fft
from .ntt import sub_zq, mul_zq, div_zq
from .ffsampling import gram, ffldl_fft, ffsampling_fft
from .ntrugen import ntru_gen
from .encoding import compress, decompress
# https://pycryptodome.readthedocs.io/en/latest/src/hash/shake256.html
from Crypto.Hash import SHAKE256
# Randomness
from os import urandom
from .rng import ChaCha20
# For debugging purposes
import sys
if sys.version_info >= (3, 4):
from importlib import reload # Python 3.4+ only.
set_printoptions(linewidth=200, precision=5, suppress=True)
logn = {
2: 1,
4: 2,
8: 3,
16: 4,
32: 5,
64: 6,
128: 7,
256: 8,
512: 9,
1024: 10
}
# Bytelength of the signing salt and header
HEAD_LEN = 1
SALT_LEN = 40
SEED_LEN = 56
# Parameter sets for Falcon:
# - n is the dimension/degree of the cyclotomic ring
# - sigma is the std. dev. of signatures (Gaussians over a lattice)
# - sigmin is a lower bounds on the std. dev. of each Gaussian over Z
# - sigbound is the upper bound on ||s0||^2 + ||s1||^2
# - sig_bytelen is the bytelength of signatures
Params = {
# FalconParam(2, 2)
2: {
"n": 2,
"sigma": 144.81253976308423,
"sigmin": 1.1165085072329104,
"sig_bound": 101498,
"sig_bytelen": 44,
},
# FalconParam(4, 2)
4: {
"n": 4,
"sigma": 146.83798833523608,
"sigmin": 1.1321247692325274,
"sig_bound": 208714,
"sig_bytelen": 47,
},
# FalconParam(8, 2)
8: {
"n": 8,
"sigma": 148.83587593064718,
"sigmin": 1.147528535373367,
"sig_bound": 428865,
"sig_bytelen": 52,
},
# FalconParam(16, 4)
16: {
"n": 16,
"sigma": 151.78340713845503,
"sigmin": 1.170254078853483,
"sig_bound": 892039,
"sig_bytelen": 63,
},
# FalconParam(32, 8)
32: {
"n": 32,
"sigma": 154.6747794602761,
"sigmin": 1.1925466358390344,
"sig_bound": 1852696,
"sig_bytelen": 82,
},
# FalconParam(64, 16)
64: {
"n": 64,
"sigma": 157.51308555044122,
"sigmin": 1.2144300507766141,
"sig_bound": 3842630,
"sig_bytelen": 122,
},
# FalconParam(128, 32)
128: {
"n": 128,
"sigma": 160.30114421975344,
"sigmin": 1.235926056771981,
"sig_bound": 7959734,
"sig_bytelen": 200,
},
# FalconParam(256, 64)
256: {
"n": 256,
"sigma": 163.04153322607107,
"sigmin": 1.2570545284063217,
"sig_bound": 16468416,
"sig_bytelen": 356,
},
# FalconParam(512, 128)
512: {
"n": 512,
"sigma": 165.7366171829776,
"sigmin": 1.2778336969128337,
"sig_bound": 34034726,
"sig_bytelen": 666,
},
# FalconParam(1024, 256)
1024: {
"n": 1024,
"sigma": 168.38857144654395,
"sigmin": 1.298280334344292,
"sig_bound": 70265242,
"sig_bytelen": 1280,
},
}
def print_tree(tree, pref=""):
"""
Display a LDL tree in a readable form.
Args:
T: a LDL tree
Format: coefficient or fft
"""
leaf = "|_____> "
top = "|_______"
son1 = "| "
son2 = " "
width = len(top)
a = ""
if len(tree) == 3:
if (pref == ""):
a += pref + str(tree[0]) + "\n"
else:
a += pref[:-width] + top + str(tree[0]) + "\n"
a += print_tree(tree[1], pref + son1)
a += print_tree(tree[2], pref + son2)
return a
else:
return (pref[:-width] + leaf + str(tree) + "\n")
def normalize_tree(tree, sigma):
"""
Normalize leaves of a LDL tree (from values ||b_i||**2 to sigma/||b_i||).
Args:
T: a LDL tree
sigma: a standard deviation
Format: coefficient or fft
"""
if len(tree) == 3:
normalize_tree(tree[1], sigma)
normalize_tree(tree[2], sigma)
else:
tree[0] = sigma / sqrt(tree[0].real)
tree[1] = 0
class PublicKey:
|
class SecretKey:
"""
This class contains methods for performing
secret key operations (and also public key operations) in Falcon.
One can:
- initialize a secret key for:
- n = 128, 256, 512, 1024,
- phi = x ** n + 1,
- q = 12 * 1024 + 1
- find a preimage t of a point c (both in ( Z[x] mod (Phi,q) )**2 ) such that t*B0 = c
- hash a message to a point of Z[x] mod (Phi,q)
- sign a message
- verify the signature of a message
"""
def __init__(self, n, polys=None):
"""Initialize a secret key."""
# Public parameters
self.n = n
self.sigma = Params[n]["sigma"]
self.sigmin = Params[n]["sigmin"]
self.signature_bound = Params[n]["sig_bound"]
self.sig_bytelen = Params[n]["sig_bytelen"]
# Compute NTRU polynomials f, g, F, G verifying fG - gF = q mod Phi
if polys is None:
self.f, self.g, self.F, self.G = ntru_gen(n)
else:
[f, g, F, G] = polys
assert all((len(poly) == n) for poly in [f, g, F, G])
self.f = f[:]
self.g = g[:]
self.F = F[:]
self.G = G[:]
# From f, g, F, G, compute the basis B0 of a NTRU lattice
# as well as its Gram matrix and their fft's.
B0 = [[self.g, neg(self.f)], [self.G, neg(self.F)]]
G0 = gram(B0)
self.B0_fft = [[fft(elt) for elt in row] for row in B0]
G0_fft = [[fft(elt) for elt in row] for row in G0]
self.T_fft = ffldl_fft(G0_fft)
# Normalize Falcon tree
normalize_tree(self.T_fft, self.sigma)
# The public key is a polynomial such that h*f = g mod (Phi,q)
self.h = div_zq(self.g, self.f)
def __repr__(self, verbose=False):
"""Print the object in readable form."""
rep = "Private key for n = {n}:\n\n".format(n=self.n)
rep += "f = {f}\n\n".format(f=self.f)
rep += "g = {g}\n\n".format(g=self.g)
rep += "F = {F}\n\n".format(F=self.F)
rep += "G = {G}\n\n".format(G=self.G)
if verbose:
rep += "\nFFT tree\n"
rep += print_tree(self.T_fft, pref="")
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def sample_preimage(self, point, seed=None):
"""
Sample a short vector s such that s[0] + s[1] * h = point.
"""
[[a, b], [c, d]] = self.B0_fft
# We compute a vector t_fft such that:
# (fft(point), fft(0)) * B0_fft = t_fft
# Because fft(0) = 0 and the inverse of B has a very specific form,
# we can do several optimizations.
'''
print("---------Inside sample_preimage----------")
print("point: ", point)
'''
point_fft = fft(point)
t0_fft = [(point_fft[i] * d[i]) / q for i in range(self.n)]
t1_fft = [(-point_fft[i] * b[i]) / q for i in range(self.n)]
t_fft = [t0_fft, t1_fft]
# We now compute v such that:
# v = z * B0 for an integral vector z
# v is close to (point, 0)
if seed is None:
# If no seed is defined, use urandom as the pseudo-random source.
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin, urandom)
else:
# If a seed is defined, initialize a ChaCha20 PRG
# that is used to generate pseudo-randomness.
chacha_prng = ChaCha20(seed)
z_fft = ffsampling_fft(t_fft, self.T_fft, self.sigmin,
chacha_prng.randombytes)
v0_fft = add_fft(mul_fft(z_fft[0], a), mul_fft(z_fft[1], c))
v1_fft = add_fft(mul_fft(z_fft[0], b), mul_fft(z_fft[1], d))
v0 = [int(round(elt)) for elt in ifft(v0_fft)]
v1 = [int(round(elt)) for elt in ifft(v1_fft)]
# The difference s = (point, 0) - v is such that:
# s is short
# s[0] + s[1] * h = point
s = [sub(point, v0), neg(v1)]
return s
def sign(self, message, randombytes=urandom):
"""
Sign a message. The message MUST be a byte string or byte array.
Optionally, one can select the source of (pseudo-)randomness used
(default: urandom).
"""
int_header = 0x30 + logn[self.n]
header = int_header.to_bytes(1, "little")
salt = randombytes(SALT_LEN)
hashed = self.hash_to_point(message, salt)
# We repeat the signing procedure until we find a signature that is
# short enough (both the Euclidean norm and the bytelength)
'''
print("---------Inside sign----------")
'''
while(1):
if (randombytes == urandom):
s = self.sample_preimage(hashed)
'''
print("s: ", s)
'''
else:
seed = randombytes(SEED_LEN)
s = self.sample_preimage(hashed, seed=seed)
norm_sign = sum(coef ** 2 for coef in s[0])
norm_sign += sum(coef ** 2 for coef in s[1])
# Check the Euclidean norm
if norm_sign <= self.signature_bound:
enc_s = compress(s[1], self.sig_bytelen - HEAD_LEN - SALT_LEN)
# Check that the encoding is valid (sometimes it fails)
if (enc_s is not False):
return header + salt + enc_s
'''
else:
print("-------------INVALID encoding---------------")
else:
print("-------------NOT within signature bound---------------")
'''
def verify(self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True
| """
This class contains methods for performing public key operations in Falcon.
"""
def __init__(self, sk=None, n=None, h=None):
"""Initialize a public key."""
if sk:
self.n = sk.n
self.h = sk.h
elif n and h:
self.n = n
self.h = h
else:
raise Exception("Public Key construction failed: insufficient/wrong arguments")
self.signature_bound = Params[self.n]["sig_bound"]
self.sig_bytelen = Params[self.n]["sig_bytelen"]
def __repr__(self):
"""Print the object in readable form."""
rep = "Public for n = {n}:\n\n".format(n=self.n)
rep += "h = {h}\n".format(h=self.h)
return rep
def hash_to_point(self, message, salt):
"""
Hash a message to a point in Z[x] mod(Phi, q).
Inspired by the Parse function from NewHope.
"""
n = self.n
if q > (1 << 16):
raise ValueError("The modulus is too large")
k = (1 << 16) // q
# Create a SHAKE object and hash the salt and message.
shake = SHAKE256.new()
shake.update(salt)
shake.update(message)
# Output pseudorandom bytes and map them to coefficients.
hashed = [0 for i in range(n)]
i = 0
j = 0
while i < n:
# Takes 2 bytes, transform them in a 16 bits integer
twobytes = shake.read(2)
elt = (twobytes[0] << 8) + twobytes[1] # This breaks in Python 2.x
# Implicit rejection sampling
if elt < k * q:
hashed[i] = elt % q
i += 1
j += 1
return hashed
def verify(self, message, signature):
"""
Verify a signature.
"""
# Unpack the salt and the short polynomial s1
salt = signature[HEAD_LEN:HEAD_LEN + SALT_LEN]
enc_s = signature[HEAD_LEN + SALT_LEN:]
s1 = decompress(enc_s, self.sig_bytelen - HEAD_LEN - SALT_LEN, self.n)
# Check that the encoding is valid
if (s1 is False):
print("Invalid encoding")
return False
# Compute s0 and normalize its coefficients in (-q/2, q/2]
hashed = self.hash_to_point(message, salt)
s0 = sub_zq(hashed, mul_zq(s1, self.h))
s0 = [(coef + (q >> 1)) % q - (q >> 1) for coef in s0]
# Check that the (s0, s1) is short
norm_sign = sum(coef ** 2 for coef in s0)
norm_sign += sum(coef ** 2 for coef in s1)
if norm_sign > self.signature_bound:
print("Squared norm of signature is too large:", norm_sign)
return False
# If all checks are passed, accept
return True | identifier_body |
cluster_feeder.go | /*
Copyright 2018 The Kubernetes Authors.
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.
*/
package input
import (
"context"
"fmt"
"time"
apiv1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/fields"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/wait"
"k8s.io/apimachinery/pkg/watch"
kube_client "k8s.io/client-go/kubernetes"
corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
v1lister "k8s.io/client-go/listers/core/v1"
"k8s.io/client-go/tools/cache"
"k8s.io/klog/v2"
vpa_types "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/apis/autoscaling.k8s.io/v1"
vpa_api "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/client/clientset/versioned/typed/autoscaling.k8s.io/v1"
vpa_lister "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/client/listers/autoscaling.k8s.io/v1"
controllerfetcher "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/input/controller_fetcher"
"k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/input/history"
"k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/input/metrics"
"k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/input/oom"
"k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/input/spec"
"k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/model"
"k8s.io/autoscaler/vertical-pod-autoscaler/pkg/target"
metrics_recommender "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/metrics/recommender"
)
const (
evictionWatchRetryWait = 10 * time.Second
evictionWatchJitterFactor = 0.5
// DefaultRecommenderName recommender name explicitly (and so implicitly specify that the default recommender should handle them)
DefaultRecommenderName = "default"
)
// ClusterStateFeeder can update state of ClusterState object.
type ClusterStateFeeder interface {
// InitFromHistoryProvider loads historical pod spec into clusterState.
InitFromHistoryProvider(historyProvider history.HistoryProvider)
// InitFromCheckpoints loads historical checkpoints into clusterState.
InitFromCheckpoints()
// LoadVPAs updates clusterState with current state of VPAs.
LoadVPAs()
// LoadPods updates clusterState with current specification of Pods and their Containers.
LoadPods()
// LoadRealTimeMetrics updates clusterState with current usage metrics of containers.
LoadRealTimeMetrics()
// GarbageCollectCheckpoints removes historical checkpoints that don't have a matching VPA.
GarbageCollectCheckpoints()
}
// ClusterStateFeederFactory makes instances of ClusterStateFeeder.
type ClusterStateFeederFactory struct {
ClusterState *model.ClusterState
KubeClient kube_client.Interface
MetricsClient metrics.MetricsClient
VpaCheckpointClient vpa_api.VerticalPodAutoscalerCheckpointsGetter
VpaLister vpa_lister.VerticalPodAutoscalerLister
PodLister v1lister.PodLister
OOMObserver oom.Observer
SelectorFetcher target.VpaTargetSelectorFetcher
MemorySaveMode bool
ControllerFetcher controllerfetcher.ControllerFetcher
RecommenderName string
}
// Make creates new ClusterStateFeeder with internal data providers, based on kube client.
func (m ClusterStateFeederFactory) Make() *clusterStateFeeder {
return &clusterStateFeeder{
coreClient: m.KubeClient.CoreV1(),
metricsClient: m.MetricsClient,
oomChan: m.OOMObserver.GetObservedOomsChannel(),
vpaCheckpointClient: m.VpaCheckpointClient,
vpaLister: m.VpaLister,
clusterState: m.ClusterState,
specClient: spec.NewSpecClient(m.PodLister),
selectorFetcher: m.SelectorFetcher,
memorySaveMode: m.MemorySaveMode,
controllerFetcher: m.ControllerFetcher,
recommenderName: m.RecommenderName,
}
}
// WatchEvictionEventsWithRetries watches new Events with reason=Evicted and passes them to the observer.
func WatchEvictionEventsWithRetries(kubeClient kube_client.Interface, observer oom.Observer, namespace string) {
go func() {
options := metav1.ListOptions{
FieldSelector: "reason=Evicted",
}
watchEvictionEventsOnce := func() {
watchInterface, err := kubeClient.CoreV1().Events(namespace).Watch(context.TODO(), options)
if err != nil {
klog.Errorf("Cannot initialize watching events. Reason %v", err)
return
}
watchEvictionEvents(watchInterface.ResultChan(), observer)
}
for {
watchEvictionEventsOnce()
// Wait between attempts, retrying too often breaks API server.
waitTime := wait.Jitter(evictionWatchRetryWait, evictionWatchJitterFactor)
klog.V(1).Infof("An attempt to watch eviction events finished. Waiting %v before the next one.", waitTime)
time.Sleep(waitTime)
}
}()
}
func watchEvictionEvents(evictedEventChan <-chan watch.Event, observer oom.Observer) {
for {
evictedEvent, ok := <-evictedEventChan
if !ok {
klog.V(3).Infof("Eviction event chan closed")
return
}
if evictedEvent.Type == watch.Added {
evictedEvent, ok := evictedEvent.Object.(*apiv1.Event)
if !ok {
continue
}
observer.OnEvent(evictedEvent)
}
}
}
// Creates clients watching pods: PodLister (listing only not terminated pods).
func newPodClients(kubeClient kube_client.Interface, resourceEventHandler cache.ResourceEventHandler, namespace string) v1lister.PodLister {
// We are interested in pods which are Running or Unknown (in case the pod is
// running but there are some transient errors we don't want to delete it from
// our model).
// We don't want to watch Pending pods because they didn't generate any usage
// yet.
// Succeeded and Failed failed pods don't generate any usage anymore but we
// don't necessarily want to immediately delete them.
selector := fields.ParseSelectorOrDie("status.phase!=" + string(apiv1.PodPending))
podListWatch := cache.NewListWatchFromClient(kubeClient.CoreV1().RESTClient(), "pods", namespace, selector)
indexer, controller := cache.NewIndexerInformer(
podListWatch,
&apiv1.Pod{},
time.Hour,
resourceEventHandler,
cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
)
podLister := v1lister.NewPodLister(indexer)
stopCh := make(chan struct{})
go controller.Run(stopCh)
return podLister
}
// NewPodListerAndOOMObserver creates pair of pod lister and OOM observer.
func NewPodListerAndOOMObserver(kubeClient kube_client.Interface, namespace string) (v1lister.PodLister, oom.Observer) {
oomObserver := oom.NewObserver()
podLister := newPodClients(kubeClient, oomObserver, namespace)
WatchEvictionEventsWithRetries(kubeClient, oomObserver, namespace)
return podLister, oomObserver
}
type clusterStateFeeder struct {
coreClient corev1.CoreV1Interface
specClient spec.SpecClient
metricsClient metrics.MetricsClient
oomChan <-chan oom.OomInfo
vpaCheckpointClient vpa_api.VerticalPodAutoscalerCheckpointsGetter
vpaLister vpa_lister.VerticalPodAutoscalerLister
clusterState *model.ClusterState
selectorFetcher target.VpaTargetSelectorFetcher
memorySaveMode bool
controllerFetcher controllerfetcher.ControllerFetcher
recommenderName string
}
func (feeder *clusterStateFeeder) InitFromHistoryProvider(historyProvider history.HistoryProvider) {
klog.V(3).Info("Initializing VPA from history provider")
clusterHistory, err := historyProvider.GetClusterHistory()
if err != nil {
klog.Errorf("Cannot get cluster history: %v", err)
}
for podID, podHistory := range clusterHistory {
klog.V(4).Infof("Adding pod %v with labels %v", podID, podHistory.LastLabels)
feeder.clusterState.AddOrUpdatePod(podID, podHistory.LastLabels, apiv1.PodUnknown)
for containerName, sampleList := range podHistory.Samples {
containerID := model.ContainerID{
PodID: podID,
ContainerName: containerName,
}
if err = feeder.clusterState.AddOrUpdateContainer(containerID, nil); err != nil {
klog.Warningf("Failed to add container %+v. Reason: %+v", containerID, err)
}
klog.V(4).Infof("Adding %d samples for container %v", len(sampleList), containerID)
for _, sample := range sampleList {
if err := feeder.clusterState.AddSample(
&model.ContainerUsageSampleWithKey{
ContainerUsageSample: sample,
Container: containerID,
}); err != nil {
klog.Warningf("Error adding metric sample for container %v: %v", containerID, err)
}
}
}
}
}
func (feeder *clusterStateFeeder) setVpaCheckpoint(checkpoint *vpa_types.VerticalPodAutoscalerCheckpoint) error {
vpaID := model.VpaID{Namespace: checkpoint.Namespace, VpaName: checkpoint.Spec.VPAObjectName}
vpa, exists := feeder.clusterState.Vpas[vpaID]
if !exists {
return fmt.Errorf("cannot load checkpoint to missing VPA object %+v", vpaID)
}
cs := model.NewAggregateContainerState()
err := cs.LoadFromCheckpoint(&checkpoint.Status)
if err != nil {
return fmt.Errorf("cannot load checkpoint for VPA %+v. Reason: %v", vpa.ID, err)
}
vpa.ContainersInitialAggregateState[checkpoint.Spec.ContainerName] = cs
return nil
}
func (feeder *clusterStateFeeder) InitFromCheckpoints() {
klog.V(3).Info("Initializing VPA from checkpoints")
feeder.LoadVPAs()
namespaces := make(map[string]bool)
for _, v := range feeder.clusterState.Vpas {
namespaces[v.ID.Namespace] = true
}
for namespace := range namespaces {
klog.V(3).Infof("Fetching checkpoints from namespace %s", namespace)
checkpointList, err := feeder.vpaCheckpointClient.VerticalPodAutoscalerCheckpoints(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil |
for _, checkpoint := range checkpointList.Items {
klog.V(3).Infof("Loading VPA %s/%s checkpoint for %s", checkpoint.ObjectMeta.Namespace, checkpoint.Spec.VPAObjectName, checkpoint.Spec.ContainerName)
err = feeder.setVpaCheckpoint(&checkpoint)
if err != nil {
klog.Errorf("Error while loading checkpoint. Reason: %+v", err)
}
}
}
}
func (feeder *clusterStateFeeder) GarbageCollectCheckpoints() {
klog.V(3).Info("Starting garbage collection of checkpoints")
feeder.LoadVPAs()
namespaceList, err := feeder.coreClient.Namespaces().List(context.TODO(), metav1.ListOptions{})
if err != nil {
klog.Errorf("Cannot list namespaces. Reason: %+v", err)
return
}
for _, namespaceItem := range namespaceList.Items {
namespace := namespaceItem.Name
checkpointList, err := feeder.vpaCheckpointClient.VerticalPodAutoscalerCheckpoints(namespace).List(context.TODO(), metav1.ListOptions{})
if err != nil {
klog.Errorf("Cannot list VPA checkpoints from namespace %v. Reason: %+v", namespace, err)
}
for _, checkpoint := range checkpointList.Items {
vpaID := model.VpaID{Namespace: checkpoint.Namespace, VpaName: checkpoint.Spec.VPAObjectName}
_, exists := feeder.clusterState.Vpas[vpaID]
if !exists {
err = feeder.vpaCheckpointClient.VerticalPodAutoscalerCheckpoints(namespace).Delete(context.TODO(), checkpoint.Name, metav1.DeleteOptions{})
if err == nil {
klog.V(3).Infof("Orphaned VPA checkpoint cleanup - deleting %v/%v.", namespace, checkpoint.Name)
} else {
klog.Errorf("Cannot delete VPA checkpoint %v/%v. Reason: %+v", namespace, checkpoint.Name, err)
}
}
}
}
}
func implicitDefaultRecommender(selectors []*vpa_types.VerticalPodAutoscalerRecommenderSelector) bool {
return len(selectors) == 0
}
func selectsRecommender(selectors []*vpa_types.VerticalPodAutoscalerRecommenderSelector, name *string) bool {
for _, s := range selectors {
if s.Name == *name {
return true
}
}
return false
}
// Filter VPA objects whose specified recommender names are not default
func filterVPAs(feeder *clusterStateFeeder, allVpaCRDs []*vpa_types.VerticalPodAutoscaler) []*vpa_types.VerticalPodAutoscaler {
klog.V(3).Infof("Start selecting the vpaCRDs.")
var vpaCRDs []*vpa_types.VerticalPodAutoscaler
for _, vpaCRD := range allVpaCRDs {
if feeder.recommenderName == DefaultRecommenderName {
if !implicitDefaultRecommender(vpaCRD.Spec.Recommenders) && !selectsRecommender(vpaCRD.Spec.Recommenders, &feeder.recommenderName) {
klog.V(6).Infof("Ignoring vpaCRD %s in namespace %s as current recommender's name %v doesn't appear among its recommenders", vpaCRD.Name, vpaCRD.Namespace, feeder.recommenderName)
continue
}
} else {
if implicitDefaultRecommender(vpaCRD.Spec.Recommenders) {
klog.V(6).Infof("Ignoring vpaCRD %s in namespace %s as %v recommender doesn't process CRDs implicitly destined to %v recommender", vpaCRD.Name, vpaCRD.Namespace, feeder.recommenderName, DefaultRecommenderName)
continue
}
if !selectsRecommender(vpaCRD.Spec.Recommenders, &feeder.recommenderName) {
klog.V(6).Infof("Ignoring vpaCRD %s in namespace %s as current recommender's name %v doesn't appear among its recommenders", vpaCRD.Name, vpaCRD.Namespace, feeder.recommenderName)
continue
}
}
vpaCRDs = append(vpaCRDs, vpaCRD)
}
return vpaCRDs
}
// LoadVPAs fetches VPA objects and loads them into the cluster state.
func (feeder *clusterStateFeeder) LoadVPAs() {
// List VPA API objects.
allVpaCRDs, err := feeder.vpaLister.List(labels.Everything())
if err != nil {
klog.Errorf("Cannot list VPAs. Reason: %+v", err)
return
}
// Filter out VPAs that specified recommenders with names not equal to "default"
vpaCRDs := filterVPAs(feeder, allVpaCRDs)
klog.V(3).Infof("Fetched %d VPAs.", len(vpaCRDs))
// Add or update existing VPAs in the model.
vpaKeys := make(map[model.VpaID]bool)
for _, vpaCRD := range vpaCRDs {
vpaID := model.VpaID{
Namespace: vpaCRD.Namespace,
VpaName: vpaCRD.Name,
}
selector, conditions := feeder.getSelector(vpaCRD)
klog.V(4).Infof("Using selector %s for VPA %s/%s", selector.String(), vpaCRD.Namespace, vpaCRD.Name)
if feeder.clusterState.AddOrUpdateVpa(vpaCRD, selector) == nil {
// Successfully added VPA to the model.
vpaKeys[vpaID] = true
for _, condition := range conditions {
if condition.delete {
delete(feeder.clusterState.Vpas[vpaID].Conditions, condition.conditionType)
} else {
feeder.clusterState.Vpas[vpaID].Conditions.Set(condition.conditionType, true, "", condition.message)
}
}
}
}
// Delete non-existent VPAs from the model.
for vpaID := range feeder.clusterState.Vpas {
if _, exists := vpaKeys[vpaID]; !exists {
klog.V(3).Infof("Deleting VPA %v", vpaID)
if err := feeder.clusterState.DeleteVpa(vpaID); err != nil {
klog.Errorf("Deleting VPA %v failed: %v", vpaID, err)
}
}
}
feeder.clusterState.ObservedVpas = vpaCRDs
}
// LoadPods loads pod into the cluster state.
func (feeder *clusterStateFeeder) LoadPods() {
podSpecs, err := feeder.specClient.GetPodSpecs()
if err != nil {
klog.Errorf("Cannot get SimplePodSpecs. Reason: %+v", err)
}
pods := make(map[model.PodID]*spec.BasicPodSpec)
for _, spec := range podSpecs {
pods[spec.ID] = spec
}
for key := range feeder.clusterState.Pods {
if _, exists := pods[key]; !exists {
klog.V(3).Infof("Deleting Pod %v", key)
feeder.clusterState.DeletePod(key)
}
}
for _, pod := range pods {
if feeder.memorySaveMode && !feeder.matchesVPA(pod) {
continue
}
feeder.clusterState.AddOrUpdatePod(pod.ID, pod.PodLabels, pod.Phase)
for _, container := range pod.Containers {
if err = feeder.clusterState.AddOrUpdateContainer(container.ID, container.Request); err != nil {
klog.Warningf("Failed to add container %+v. Reason: %+v", container.ID, err)
}
}
}
}
func (feeder *clusterStateFeeder) LoadRealTimeMetrics() {
containersMetrics, err := feeder.metricsClient.GetContainersMetrics()
if err != nil {
klog.Errorf("Cannot get ContainerMetricsSnapshot from MetricsClient. Reason: %+v", err)
}
sampleCount := 0
droppedSampleCount := 0
for _, containerMetrics := range containersMetrics {
for _, sample := range newContainerUsageSamplesWithKey(containerMetrics) {
if err := feeder.clusterState.AddSample(sample); err != nil {
// Not all pod states are tracked in memory saver mode
if _, isKeyError := err.(model.KeyError); isKeyError && feeder.memorySaveMode {
continue
}
klog.Warningf("Error adding metric sample for container %v: %v", sample.Container, err)
droppedSampleCount++
} else {
sampleCount++
}
}
}
klog.V(3).Infof("ClusterSpec fed with #%v ContainerUsageSamples for #%v containers. Dropped #%v samples.", sampleCount, len(containersMetrics), droppedSampleCount)
Loop:
for {
select {
case oomInfo := <-feeder.oomChan:
klog.V(3).Infof("OOM detected %+v", oomInfo)
if err = feeder.clusterState.RecordOOM(oomInfo.ContainerID, oomInfo.Timestamp, oomInfo.Memory); err != nil {
klog.Warningf("Failed to record OOM %+v. Reason: %+v", oomInfo, err)
}
default:
break Loop
}
}
metrics_recommender.RecordAggregateContainerStatesCount(feeder.clusterState.StateMapSize())
}
func (feeder *clusterStateFeeder) matchesVPA(pod *spec.BasicPodSpec) bool {
for vpaKey, vpa := range feeder.clusterState.Vpas {
podLabels := labels.Set(pod.PodLabels)
if vpaKey.Namespace == pod.ID.Namespace && vpa.PodSelector.Matches(podLabels) {
return true
}
}
return false
}
func newContainerUsageSamplesWithKey(metrics *metrics.ContainerMetricsSnapshot) []*model.ContainerUsageSampleWithKey {
var samples []*model.ContainerUsageSampleWithKey
for metricName, resourceAmount := range metrics.Usage {
sample := &model.ContainerUsageSampleWithKey{
Container: metrics.ID,
ContainerUsageSample: model.ContainerUsageSample{
MeasureStart: metrics.SnapshotTime,
Resource: metricName,
Usage: resourceAmount,
},
}
samples = append(samples, sample)
}
return samples
}
type condition struct {
conditionType vpa_types.VerticalPodAutoscalerConditionType
delete bool
message string
}
func (feeder *clusterStateFeeder) validateTargetRef(vpa *vpa_types.VerticalPodAutoscaler) (bool, condition) {
//
if vpa.Spec.TargetRef == nil {
return false, condition{}
}
k := controllerfetcher.ControllerKeyWithAPIVersion{
ControllerKey: controllerfetcher.ControllerKey{
Namespace: vpa.Namespace,
Kind: vpa.Spec.TargetRef.Kind,
Name: vpa.Spec.TargetRef.Name,
},
ApiVersion: vpa.Spec.TargetRef.APIVersion,
}
top, err := feeder.controllerFetcher.FindTopMostWellKnownOrScalable(&k)
if err != nil {
return false, condition{conditionType: vpa_types.ConfigUnsupported, delete: false, message: fmt.Sprintf("Error checking if target is a topmost well-known or scalable controller: %s", err)}
}
if top == nil {
return false, condition{conditionType: vpa_types.ConfigUnsupported, delete: false, message: fmt.Sprintf("Unknown error during checking if target is a topmost well-known or scalable controller: %s", err)}
}
if *top != k {
return false, condition{conditionType: vpa_types.ConfigUnsupported, delete: false, message: "The targetRef controller has a parent but it should point to a topmost well-known or scalable controller"}
}
return true, condition{}
}
func (feeder *clusterStateFeeder) getSelector(vpa *vpa_types.VerticalPodAutoscaler) (labels.Selector, []condition) {
selector, fetchErr := feeder.selectorFetcher.Fetch(vpa)
if selector != nil {
validTargetRef, unsupportedCondition := feeder.validateTargetRef(vpa)
if !validTargetRef {
return labels.Nothing(), []condition{
unsupportedCondition,
{conditionType: vpa_types.ConfigDeprecated, delete: true},
}
}
return selector, []condition{
{conditionType: vpa_types.ConfigUnsupported, delete: true},
{conditionType: vpa_types.ConfigDeprecated, delete: true},
}
}
msg := "Cannot read targetRef"
if fetchErr != nil {
klog.Errorf("Cannot get target selector from VPA's targetRef. Reason: %+v", fetchErr)
msg = fmt.Sprintf("Cannot read targetRef. Reason: %s", fetchErr.Error())
}
return labels.Nothing(), []condition{
{conditionType: vpa_types.ConfigUnsupported, delete: false, message: msg},
{conditionType: vpa_types.ConfigDeprecated, delete: true},
}
}
| {
klog.Errorf("Cannot list VPA checkpoints from namespace %v. Reason: %+v", namespace, err)
} | conditional_block |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.