file_name
stringlengths 3
137
| prefix
stringlengths 0
918k
| suffix
stringlengths 0
962k
| middle
stringlengths 0
812k
|
|---|---|---|---|
hooks.test.tsx | import React from 'react';
import {mountWithApp, mount} from 'test-utilities';
import {
IndexRowContext,
IndexSelectionChangeContext,
IndexContextType,
IndexContext,
} from '../context';
import {
BulkSelectionDataOptions,
HandleBulkSelectionOptions,
SelectionType,
} from '../types';
import {
useIndexRow,
useIndexSelectionChange,
useIndexValue,
useBulkSelectionData,
useHandleBulkSelection,
} from '../hooks';
interface IndexSelectionChangeTypedChildProps {
onSelectionChange: ReturnType<typeof useIndexSelectionChange>;
}
interface IndexValueTypedChildProps extends IndexContextType {}
interface BulkSelectionDataTypedChildProps
extends ReturnType<typeof useBulkSelectionData> {}
interface HandleBulkSelectionTypedChildProps {
onSelectionChange: ReturnType<typeof useHandleBulkSelection>;
}
describe('useIndexRow', () => {
it('returns selectMode & condensed', () => {
const spy = jest.fn();
function MockComponent() {
const value = useIndexRow();
spy(value);
return null;
}
mountWithApp(
<IndexRowContext.Provider value={{selectMode: true, condensed: true}}>
<MockComponent />
</IndexRowContext.Provider>,
);
expect(spy).toHaveBeenCalledWith({selectMode: true, condensed: true});
});
it('throws when IndexProvider is not being used', () => {
const consoleErrorSpy = jest.spyOn(console, 'error');
consoleErrorSpy.mockImplementation(() => {});
function callback() {
function MockComponent() { | return null;
}
mount(<MockComponent />);
}
expect(callback).toThrow(`Missing IndexProvider context`);
consoleErrorSpy.mockRestore();
});
});
describe('useIndexSelectionChange', () => {
function TypedChild(_: IndexSelectionChangeTypedChildProps) {
return null;
}
function MockComponent() {
const onSelectionChange = useIndexSelectionChange();
return <TypedChild onSelectionChange={onSelectionChange} />;
}
let consoleErrorSpy: jest.SpyInstance;
beforeEach(() => {
consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
});
afterEach(() => {
consoleErrorSpy.mockRestore();
});
it('throws when IndexSelectionChangeContext is missing', () => {
function throwMissingContext() {
mount(<MockComponent />);
}
expect(throwMissingContext).toThrow('Missing IndexProvider context');
});
it('returns onSelectionChange', () => {
const contextSpy = jest.fn();
const mockComponent = mount(
<IndexSelectionChangeContext.Provider value={contextSpy}>
<MockComponent />
</IndexSelectionChangeContext.Provider>,
);
expect(mockComponent).toContainReactComponent(TypedChild, {
onSelectionChange: contextSpy,
});
});
});
describe('useIndexValue', () => {
function TypedChild(_: IndexValueTypedChildProps) {
return null;
}
function MockComponent() {
const contextValues = useIndexValue();
return <TypedChild {...contextValues} />;
}
let consoleErrorSpy: jest.SpyInstance;
beforeEach(() => {
consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
});
afterEach(() => {
consoleErrorSpy.mockRestore();
});
it('throws when IndexContext is missing', () => {
function throwMissingContext() {
mount(<MockComponent />);
}
expect(throwMissingContext).toThrow('Missing IndexProvider context');
});
it('returns index context values', () => {
const contextValues = {
resourceName: {singular: 'singular', plural: 'plural'},
selectedItemsCount: 0,
selectMode: false,
itemCount: 3,
};
const mockComponent = mount(
<IndexContext.Provider value={contextValues}>
<MockComponent />
</IndexContext.Provider>,
);
expect(mockComponent).toContainReactComponent(TypedChild, contextValues);
});
});
describe('useBulkSelectionData', () => {
function TypedChild(_: BulkSelectionDataTypedChildProps) {
return null;
}
function MockComponent(options: Partial<BulkSelectionDataOptions>) {
const contextValues = useBulkSelectionData({
selectedItemsCount: 0,
itemCount: 4,
hasMoreItems: true,
resourceName: {
singular: 'test',
plural: 'tests',
},
...options,
});
return <TypedChild {...contextValues} />;
}
it('returns paginated select all text when all resources are selected', () => {
const itemCount = 4;
const resourceName = {
singular: 'order',
plural: 'orders',
};
const paginatedSelectAllText = `All ${itemCount}+ ${resourceName.plural} in your store are selected.`;
const mockComponent = mountWithApp(
<MockComponent
selectedItemsCount="All"
hasMoreItems
itemCount={itemCount}
resourceName={resourceName}
/>,
);
expect(mockComponent).toContainReactComponent(TypedChild, {
paginatedSelectAllText,
});
});
});
describe('useHandleBulkSelection', () => {
function TypedChild(_: HandleBulkSelectionTypedChildProps) {
return null;
}
function MockComponent(options: HandleBulkSelectionOptions) {
const contextValue = useHandleBulkSelection(options);
return <TypedChild onSelectionChange={contextValue} />;
}
it('selects ranges', () => {
const onSelectionChangeSpy = jest.fn();
const mockComponent = mount(
<MockComponent onSelectionChange={onSelectionChangeSpy} />,
);
const typedChild = mockComponent.find(TypedChild)!;
// First selection cannot be multi
typedChild.trigger(
'onSelectionChange',
SelectionType.Multi,
true,
undefined,
3,
);
typedChild.trigger(
'onSelectionChange',
SelectionType.Multi,
true,
undefined,
4,
);
expect(onSelectionChangeSpy).toHaveBeenLastCalledWith(
SelectionType.Multi,
true,
[3, 4],
);
});
}); | useIndexRow(); |
maketiles_old.py | import skimage.io
import numpy as np
import pandas as pd
import sys
from pathlib import Path
import pickle
import argparse
import cv2
parser = argparse.ArgumentParser()
parser.add_argument("--base_dir", default='G:/Datasets/panda', required=False)
parser.add_argument("--out_dir", default='D:/Datasets/panda', required=False)
args = parser.parse_args()
BASE_PATH = Path(args.base_dir)
OUTPUT_BASE = Path(args.out_dir)
SIZE = 128
NUM = 16
LEVEL = 1
STRIDE = False
TRAIN_PATH = BASE_PATH/'train_images/'
MASKS_TRAIN_PATH = BASE_PATH/'train_label_masks/'
OUTPUT_IMG_PATH = OUTPUT_BASE/f'train_tiles_{SIZE}_{LEVEL}/imgs/'
OUTPUT_MASK_PATH = OUTPUT_BASE/f'train_tiles_{SIZE}_{LEVEL}/masks/'
PICKLE_NAME = OUTPUT_BASE/f'stats_{SIZE}_{LEVEL}.pkl'
CSV_PATH = BASE_PATH/'train.csv'
pen_marked_images = [
'fd6fe1a3985b17d067f2cb4d5bc1e6e1',
'ebb6a080d72e09f6481721ef9f88c472',
'ebb6d5ca45942536f78beb451ee43cc4',
'ea9d52d65500acc9b9d89eb6b82cdcdf',
'e726a8eac36c3d91c3c4f9edba8ba713',
'e90abe191f61b6fed6d6781c8305fe4b',
'fd0bb45eba479a7f7d953f41d574bf9f',
'ff10f937c3d52eff6ad4dd733f2bc3ac',
'feee2e895355a921f2b75b54debad328',
'feac91652a1c5accff08217d19116f1c',
'fb01a0a69517bb47d7f4699b6217f69d',
'f00ec753b5618cfb30519db0947fe724',
'e9a4f528b33479412ee019e155e1a197',
'f062f6c1128e0e9d51a76747d9018849',
'f39bf22d9a2f313425ee201932bac91a',
]
def remove_pen_marks(img):
# Define elliptic kernel
kernel5x5 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
# use cv2.inRange to mask pen marks (hardcoded for now)
lower = np.array([0, 0, 0])
upper = np.array([200, 255, 255])
img_mask1 = cv2.inRange(img, lower, upper)
# Use erosion and findContours to remove masked tissue (side effect of above)
img_mask1 = cv2.erode(img_mask1, kernel5x5, iterations=4)
img_mask2 = np.zeros(img_mask1.shape, dtype=np.uint8)
contours, _ = cv2.findContours(img_mask1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
x, y = contour[:, 0, 0], contour[:, 0, 1]
w, h = x.max() - x.min(), y.max() - y.min()
if w > 100 and h > 100:
cv2.drawContours(img_mask2, [contour], 0, 1, -1)
# expand the area of the pen marks
img_mask2 = cv2.dilate(img_mask2, kernel5x5, iterations=3)
img_mask2 = (1 - img_mask2)
# Mask out pen marks from original image
img = cv2.bitwise_and(img, img, mask=img_mask2)
img[img == 0] = 255
return img, img_mask1, img_mask2
class TileMaker:
|
if __name__ == "__main__":
OUTPUT_IMG_PATH.mkdir(exist_ok=True, parents=True)
OUTPUT_MASK_PATH.mkdir(exist_ok=True, parents=True)
tile_maker = TileMaker(SIZE, NUM)
img_list = list(TRAIN_PATH.glob('**/*.tiff'))
# img_list.pop(5765)
bad_images = []
bad_masks = []
image_stats = []
files = []
for i, img_fn in enumerate(img_list):
img_id = img_fn.stem
mask_fn = MASKS_TRAIN_PATH / (img_id + '_mask.tiff')
try:
col = skimage.io.MultiImage(str(img_fn))
image = col[-LEVEL]
except:
bad_images.append(img_id)
continue
if img_id in pen_marked_images:
image, _, _ = remove_pen_marks(image)
if mask_fn.exists():
try:
mask = skimage.io.MultiImage(str(mask_fn))[-LEVEL]
except:
bad_masks.append(img_id)
mask = np.zeros_like(image)
else:
mask = np.zeros_like(image)
if STRIDE:
image, mask = tile_maker.make_multistride(image, mask)
else:
image, mask = tile_maker.make(image, mask)
sys.stdout.write(f'\r{i + 1}/{len(img_list)}')
image_stats.append({'image_id': img_id, 'mean': image.mean(axis=(0, 1, 2)) / 255,
'mean_square': ((image / 255) ** 2).mean(axis=(0, 1, 2)),
'img_mean': (255 - image).mean()})
for i, (tile_image, tile_mask) in enumerate(zip(image, mask)):
a = (img_id + '_' + str(i) + '.png')
b = (img_id + '_' + str(i) + '.png')
files.append({'image_id': img_id, 'num': i, 'filename': a, 'maskname': b,
'value': (255-tile_image[:, :, 0]).mean()})
skimage.io.imsave(OUTPUT_IMG_PATH / a, tile_image, check_contrast=False)
skimage.io.imsave(OUTPUT_MASK_PATH / b, tile_mask, check_contrast=False)
image_stats = pd.DataFrame(image_stats)
df = pd.read_csv(CSV_PATH)
df = pd.merge(df, image_stats, on='image_id', how='left')
df[['image_id', 'img_mean']].to_csv(OUTPUT_BASE/f'img_mean_{SIZE}_{LEVEL}.csv', index=False)
provider_stats = {}
for provider in df['data_provider'].unique():
mean = (df[df['data_provider'] == provider]['mean']).mean(0)
std = np.sqrt((df[df['data_provider'] == provider]['mean_square']).mean(0) - mean ** 2)
provider_stats[provider] = (mean, std)
mean = (df['mean']).mean()
std = np.sqrt((df['mean_square']).mean() - mean ** 2)
provider_stats['all'] = (mean, std)
with open(PICKLE_NAME, 'wb') as file:
pickle.dump(provider_stats, file)
pd.DataFrame(files).to_csv(OUTPUT_BASE/f'files_{SIZE}_{LEVEL}.csv', index=False)
print(bad_images)
print(bad_masks)
print(provider_stats)
| def __init__(self, size, number):
self.size = size
self.number = number
def make_multistride(self, image, mask):
# Pad only once
image, mask = self.__pad(image, mask)
s0, _ = self.__get_tiles(image, mask)
# For strided grids, need to also remove on the right/bottom
s1, _ = self.__get_tiles(image[self.size // 2:-self.size // 2, :],
mask[self.size // 2:-self.size // 2, :])
s2, _ = self.__get_tiles(image[:, self.size // 2:-self.size // 2],
image[:, self.size // 2:-self.size // 2])
s3, _ = self.__get_tiles(image[self.size // 2:-self.size // 2, self.size // 2:-self.size // 2],
image[self.size // 2:-self.size // 2, self.size // 2:-self.size // 2])
all_tiles = np.concatenate([s0, s1, s2, s3], axis=0)
# Find the images with the most stuff (the most red):
red_channel = all_tiles[:, :, :, 0]
tissue = np.where((red_channel < 230) & (red_channel > 200), red_channel, 0)
sorted_tiles = np.argsort(np.sum(tissue, axis=(1, 2)))[::-1]
sorted_tiles = sorted_tiles[:self.number * 4]
return all_tiles[sorted_tiles], _
def __pad(self, image, mask):
h, w, c = image.shape
horizontal_pad = 0 if (w % self.size) == 0 else self.size - (w % self.size)
vertical_pad = 0 if (h % self.size) == 0 else self.size - (h % self.size)
image = np.pad(image, pad_width=((vertical_pad // 2, vertical_pad - vertical_pad // 2),
(horizontal_pad // 2, horizontal_pad - horizontal_pad // 2),
(0, 0)),
mode='constant', constant_values=255) # Empty is white in this data
mask = np.pad(mask, pad_width=((vertical_pad // 2, vertical_pad - vertical_pad // 2),
(horizontal_pad // 2, horizontal_pad - horizontal_pad // 2),
(0, 0)),
mode='constant', constant_values=0) # Empty is black in this data
return image, mask
def __get_tiles(self, image, mask):
h, w, c = image.shape
image = image.reshape(h // self.size, self.size, w // self.size, self.size, c)
image = image.swapaxes(1, 2).reshape(-1, self.size, self.size, c)
mask = mask.reshape(h // self.size, self.size, w // self.size, self.size, c)
mask = mask.swapaxes(1, 2).reshape(-1, self.size, self.size, c)
if image.shape[0] < self.number:
image = np.pad(image, pad_width=((0, self.number - image.shape[0]), (0, 0), (0, 0), (0, 0)),
mode='constant', constant_values=255)
mask = np.pad(mask, pad_width=((0, self.number - mask.shape[0]), (0, 0), (0, 0), (0, 0)),
mode='constant', constant_values=0)
return image, mask
def make(self, image, mask):
image, mask = self.__pad(image, mask)
image, mask = self.__get_tiles(image, mask)
# Find the images with the most dark (epithelium) stuff
red_channel = image[:, :, :, 0]
tissue = np.where((red_channel < 230) & (red_channel > 200), red_channel, 0)
sorted_tiles = np.argsort(np.sum(tissue, axis=(1, 2)))[::-1]
sorted_tiles = sorted_tiles[:self.number]
return image[sorted_tiles], mask[sorted_tiles] |
ip.rs | // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use vec::MutableCloneableVector;
use to_str::ToStr;
use from_str::FromStr;
use option::{Option, None, Some};
pub type Port = u16;
#[deriving(Eq, TotalEq, Clone)]
pub enum IpAddr {
Ipv4Addr(u8, u8, u8, u8),
Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16)
}
impl ToStr for IpAddr {
fn to_str(&self) -> ~str {
match *self {
Ipv4Addr(a, b, c, d) =>
format!("{}.{}.{}.{}", a, b, c, d),
// Ipv4 Compatible address
Ipv6Addr(0, 0, 0, 0, 0, 0, g, h) => {
format!("::{}.{}.{}.{}", (g >> 8) as u8, g as u8,
(h >> 8) as u8, h as u8)
}
// Ipv4-Mapped address
Ipv6Addr(0, 0, 0, 0, 0, 0xFFFF, g, h) => {
format!("::FFFF:{}.{}.{}.{}", (g >> 8) as u8, g as u8,
(h >> 8) as u8, h as u8)
}
Ipv6Addr(a, b, c, d, e, f, g, h) =>
format!("{}:{}:{}:{}:{}:{}:{}:{}", a, b, c, d, e, f, g, h)
}
}
}
#[deriving(Eq, TotalEq, Clone)]
pub struct SocketAddr {
ip: IpAddr,
port: Port,
}
impl ToStr for SocketAddr {
fn to_str(&self) -> ~str {
match self.ip {
Ipv4Addr(*) => format!("{}:{}", self.ip.to_str(), self.port),
Ipv6Addr(*) => format!("[{}]:{}", self.ip.to_str(), self.port),
}
}
}
struct Parser<'self> {
// parsing as ASCII, so can use byte array
s: &'self [u8],
pos: uint,
}
impl<'self> Parser<'self> {
fn | (s: &'self str) -> Parser<'self> {
Parser {
s: s.as_bytes(),
pos: 0,
}
}
fn is_eof(&self) -> bool {
self.pos == self.s.len()
}
// Commit only if parser returns Some
fn read_atomically<T>(&mut self, cb: &fn(&mut Parser) -> Option<T>) -> Option<T> {
let pos = self.pos;
let r = cb(self);
if r.is_none() {
self.pos = pos;
}
r
}
// Commit only if parser read till EOF
fn read_till_eof<T>(&mut self, cb: &fn(&mut Parser) -> Option<T>) -> Option<T> {
do self.read_atomically |p| {
cb(p).filtered(|_| p.is_eof())
}
}
// Return result of first successful parser
fn read_or<T>(&mut self, parsers: &[&fn(&mut Parser) -> Option<T>]) -> Option<T> {
for pf in parsers.iter() {
match self.read_atomically(|p: &mut Parser| (*pf)(p)) {
Some(r) => return Some(r),
None => {}
}
}
None
}
// Apply 3 parsers sequentially
fn read_seq_3<A, B, C>(&mut self,
pa: &fn(&mut Parser) -> Option<A>,
pb: &fn(&mut Parser) -> Option<B>,
pc: &fn(&mut Parser) -> Option<C>
) -> Option<(A, B, C)>
{
do self.read_atomically |p| {
let a = pa(p);
let b = if a.is_some() { pb(p) } else { None };
let c = if b.is_some() { pc(p) } else { None };
match (a, b, c) {
(Some(a), Some(b), Some(c)) => Some((a, b, c)),
_ => None
}
}
}
// Read next char
fn read_char(&mut self) -> Option<char> {
if self.is_eof() {
None
} else {
let r = self.s[self.pos] as char;
self.pos += 1;
Some(r)
}
}
// Return char and advance iff next char is equal to requested
fn read_given_char(&mut self, c: char) -> Option<char> {
do self.read_atomically |p| {
p.read_char().filtered(|&next| next == c)
}
}
// Read digit
fn read_digit(&mut self, radix: u8) -> Option<u8> {
fn parse_digit(c: char, radix: u8) -> Option<u8> {
let c = c as u8;
// assuming radix is either 10 or 16
if c >= '0' as u8 && c <= '9' as u8 {
Some((c - '0' as u8) as u8)
} else if radix > 10 && c >= 'a' as u8 && c < 'a' as u8 + (radix - 10) {
Some((c - 'a' as u8 + 10) as u8)
} else if radix > 10 && c >= 'A' as u8 && c < 'A' as u8 + (radix - 10) {
Some((c - 'A' as u8 + 10) as u8)
} else {
None
}
}
do self.read_atomically |p| {
p.read_char().and_then(|c| parse_digit(c, radix))
}
}
fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
let mut r = 0u32;
let mut digit_count = 0;
loop {
match self.read_digit(radix) {
Some(d) => {
r = r * (radix as u32) + (d as u32);
digit_count += 1;
if digit_count > max_digits || r >= upto {
return None
}
}
None => {
if digit_count == 0 {
return None
} else {
return Some(r)
}
}
};
}
}
// Read number, failing if max_digits of number value exceeded
fn read_number(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
do self.read_atomically |p| {
p.read_number_impl(radix, max_digits, upto)
}
}
fn read_ipv4_addr_impl(&mut self) -> Option<IpAddr> {
let mut bs = [0u8, ..4];
let mut i = 0;
while i < 4 {
if i != 0 && self.read_given_char('.').is_none() {
return None;
}
let octet = self.read_number(10, 3, 0x100).map(|n| n as u8);
match octet {
Some(d) => bs[i] = d,
None => return None,
};
i += 1;
}
Some(Ipv4Addr(bs[0], bs[1], bs[2], bs[3]))
}
// Read IPv4 address
fn read_ipv4_addr(&mut self) -> Option<IpAddr> {
do self.read_atomically |p| {
p.read_ipv4_addr_impl()
}
}
fn read_ipv6_addr_impl(&mut self) -> Option<IpAddr> {
fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> IpAddr {
assert!(head.len() + tail.len() <= 8);
let mut gs = [0u16, ..8];
gs.copy_from(head);
gs.mut_slice(8 - tail.len(), 8).copy_from(tail);
Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
}
fn read_groups(p: &mut Parser, groups: &mut [u16, ..8], limit: uint) -> (uint, bool) {
let mut i = 0;
while i < limit {
if i < limit - 1 {
let ipv4 = do p.read_atomically |p| {
if i == 0 || p.read_given_char(':').is_some() {
p.read_ipv4_addr()
} else {
None
}
};
match ipv4 {
Some(Ipv4Addr(a, b, c, d)) => {
groups[i + 0] = (a as u16 << 8) | (b as u16);
groups[i + 1] = (c as u16 << 8) | (d as u16);
return (i + 2, true);
}
_ => {}
}
}
let group = do p.read_atomically |p| {
if i == 0 || p.read_given_char(':').is_some() {
p.read_number(16, 4, 0x10000).map(|n| n as u16)
} else {
None
}
};
match group {
Some(g) => groups[i] = g,
None => return (i, false)
}
i += 1;
}
(i, false)
}
let mut head = [0u16, ..8];
let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
if head_size == 8 {
return Some(Ipv6Addr(
head[0], head[1], head[2], head[3],
head[4], head[5], head[6], head[7]))
}
// IPv4 part is not allowed before `::`
if head_ipv4 {
return None
}
// read `::` if previous code parsed less than 8 groups
if !self.read_given_char(':').is_some() || !self.read_given_char(':').is_some() {
return None;
}
let mut tail = [0u16, ..8];
let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
Some(ipv6_addr_from_head_tail(head.slice(0, head_size), tail.slice(0, tail_size)))
}
fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
do self.read_atomically |p| {
p.read_ipv6_addr_impl()
}
}
fn read_ip_addr(&mut self) -> Option<IpAddr> {
let ipv4_addr = |p: &mut Parser| p.read_ipv4_addr();
let ipv6_addr = |p: &mut Parser| p.read_ipv6_addr();
self.read_or([ipv4_addr, ipv6_addr])
}
fn read_socket_addr(&mut self) -> Option<SocketAddr> {
let ip_addr = |p: &mut Parser| {
let ipv4_p = |p: &mut Parser| p.read_ip_addr();
let ipv6_p = |p: &mut Parser| {
let open_br = |p: &mut Parser| p.read_given_char('[');
let ip_addr = |p: &mut Parser| p.read_ipv6_addr();
let clos_br = |p: &mut Parser| p.read_given_char(']');
p.read_seq_3::<char, IpAddr, char>(open_br, ip_addr, clos_br)
.map(|t| match t { (_, ip, _) => ip })
};
p.read_or([ipv4_p, ipv6_p])
};
let colon = |p: &mut Parser| p.read_given_char(':');
let port = |p: &mut Parser| p.read_number(10, 5, 0x10000).map(|n| n as u16);
// host, colon, port
self.read_seq_3::<IpAddr, char, u16>(ip_addr, colon, port)
.map(|t| match t { (ip, _, port) => SocketAddr { ip: ip, port: port } })
}
}
impl FromStr for IpAddr {
fn from_str(s: &str) -> Option<IpAddr> {
do Parser::new(s).read_till_eof |p| {
p.read_ip_addr()
}
}
}
impl FromStr for SocketAddr {
fn from_str(s: &str) -> Option<SocketAddr> {
do Parser::new(s).read_till_eof |p| {
p.read_socket_addr()
}
}
}
#[cfg(test)]
mod test {
use super::*;
use from_str::FromStr;
use option::{Option, Some, None};
#[test]
fn test_from_str_ipv4() {
assert_eq!(Some(Ipv4Addr(127, 0, 0, 1)), FromStr::from_str("127.0.0.1"));
assert_eq!(Some(Ipv4Addr(255, 255, 255, 255)), FromStr::from_str("255.255.255.255"));
assert_eq!(Some(Ipv4Addr(0, 0, 0, 0)), FromStr::from_str("0.0.0.0"));
// out of range
let none: Option<IpAddr> = FromStr::from_str("256.0.0.1");
assert_eq!(None, none);
// too short
let none: Option<IpAddr> = FromStr::from_str("255.0.0");
assert_eq!(None, none);
// too long
let none: Option<IpAddr> = FromStr::from_str("255.0.0.1.2");
assert_eq!(None, none);
// no number between dots
let none: Option<IpAddr> = FromStr::from_str("255.0..1");
assert_eq!(None, none);
}
#[test]
fn test_from_str_ipv6() {
assert_eq!(Some(Ipv6Addr(0, 0, 0, 0, 0, 0, 0, 0)), FromStr::from_str("0:0:0:0:0:0:0:0"));
assert_eq!(Some(Ipv6Addr(0, 0, 0, 0, 0, 0, 0, 1)), FromStr::from_str("0:0:0:0:0:0:0:1"));
assert_eq!(Some(Ipv6Addr(0, 0, 0, 0, 0, 0, 0, 1)), FromStr::from_str("::1"));
assert_eq!(Some(Ipv6Addr(0, 0, 0, 0, 0, 0, 0, 0)), FromStr::from_str("::"));
assert_eq!(Some(Ipv6Addr(0x2a02, 0x6b8, 0, 0, 0, 0, 0x11, 0x11)),
FromStr::from_str("2a02:6b8::11:11"));
// too long group
let none: Option<IpAddr> = FromStr::from_str("::00000");
assert_eq!(None, none);
// too short
let none: Option<IpAddr> = FromStr::from_str("1:2:3:4:5:6:7");
assert_eq!(None, none);
// too long
let none: Option<IpAddr> = FromStr::from_str("1:2:3:4:5:6:7:8:9");
assert_eq!(None, none);
// triple colon
let none: Option<IpAddr> = FromStr::from_str("1:2:::6:7:8");
assert_eq!(None, none);
// two double colons
let none: Option<IpAddr> = FromStr::from_str("1:2::6::8");
assert_eq!(None, none);
}
#[test]
fn test_from_str_ipv4_in_ipv6() {
assert_eq!(Some(Ipv6Addr(0, 0, 0, 0, 0, 0, 49152, 545)),
FromStr::from_str("::192.0.2.33"));
assert_eq!(Some(Ipv6Addr(0, 0, 0, 0, 0, 0xFFFF, 49152, 545)),
FromStr::from_str("::FFFF:192.0.2.33"));
assert_eq!(Some(Ipv6Addr(0x64, 0xff9b, 0, 0, 0, 0, 49152, 545)),
FromStr::from_str("64:ff9b::192.0.2.33"));
assert_eq!(Some(Ipv6Addr(0x2001, 0xdb8, 0x122, 0xc000, 0x2, 0x2100, 49152, 545)),
FromStr::from_str("2001:db8:122:c000:2:2100:192.0.2.33"));
// colon after v4
let none: Option<IpAddr> = FromStr::from_str("::127.0.0.1:");
assert_eq!(None, none);
// not enought groups
let none: Option<IpAddr> = FromStr::from_str("1.2.3.4.5:127.0.0.1");
assert_eq!(None, none);
// too many groups
let none: Option<IpAddr> =
FromStr::from_str("1.2.3.4.5:6:7:127.0.0.1");
assert_eq!(None, none);
}
#[test]
fn test_from_str_socket_addr() {
assert_eq!(Some(SocketAddr { ip: Ipv4Addr(77, 88, 21, 11), port: 80 }),
FromStr::from_str("77.88.21.11:80"));
assert_eq!(Some(SocketAddr { ip: Ipv6Addr(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), port: 53 }),
FromStr::from_str("[2a02:6b8:0:1::1]:53"));
assert_eq!(Some(SocketAddr { ip: Ipv6Addr(0, 0, 0, 0, 0, 0, 0x7F00, 1), port: 22 }),
FromStr::from_str("[::127.0.0.1]:22"));
// without port
let none: Option<SocketAddr> = FromStr::from_str("127.0.0.1");
assert_eq!(None, none);
// without port
let none: Option<SocketAddr> = FromStr::from_str("127.0.0.1:");
assert_eq!(None, none);
// wrong brackets around v4
let none: Option<SocketAddr> = FromStr::from_str("[127.0.0.1]:22");
assert_eq!(None, none);
// port out of range
let none: Option<SocketAddr> = FromStr::from_str("127.0.0.1:123456");
assert_eq!(None, none);
}
#[test]
fn ipv6_addr_to_str() {
let a1 = Ipv6Addr(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x280);
assert!(a1.to_str() == ~"::ffff:192.0.2.128" || a1.to_str() == ~"::FFFF:192.0.2.128");
}
}
| new |
test_sensor.py | """Tests for greeneye_monitor sensors."""
from unittest.mock import AsyncMock
from homeassistant.components.greeneye_monitor.sensor import (
DATA_PULSES,
DATA_WATT_SECONDS,
)
from homeassistant.const import STATE_UNKNOWN
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_registry import (
RegistryEntryDisabler,
async_get as get_entity_registry,
)
from .common import (
MULTI_MONITOR_CONFIG,
SINGLE_MONITOR_CONFIG_POWER_SENSORS,
SINGLE_MONITOR_CONFIG_PULSE_COUNTERS,
SINGLE_MONITOR_CONFIG_TEMPERATURE_SENSORS,
SINGLE_MONITOR_CONFIG_VOLTAGE_SENSORS,
SINGLE_MONITOR_SERIAL_NUMBER,
connect_monitor,
setup_greeneye_monitor_component_with_config,
)
from .conftest import assert_sensor_state
async def test_sensor_does_not_exist_before_monitor_connected(
hass: HomeAssistant, monitors: AsyncMock
) -> None:
"""Test that a sensor does not exist before its monitor is connected."""
# The sensor base class handles connecting the monitor, so we test this with a single voltage sensor for ease
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_VOLTAGE_SENSORS
)
entity_registry = get_entity_registry(hass)
assert entity_registry.async_get("sensor.voltage_1") is None
async def test_sensors_created_when_monitor_connected(
hass: HomeAssistant, monitors: AsyncMock
) -> None:
"""Test that sensors get created when the monitor first connects."""
# The sensor base class handles updating the state on connection, so we test this with a single voltage sensor for ease
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_VOLTAGE_SENSORS
)
assert len(monitors.listeners) == 1
await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
assert len(monitors.listeners) == 0 # Make sure we cleaned up the listener
assert_sensor_state(hass, "sensor.voltage_1", "120.0")
async def test_sensors_created_during_setup_if_monitor_already_connected(
hass: HomeAssistant, monitors: AsyncMock
) -> None:
"""Test that sensors get created during setup if the monitor happens to connect really quickly."""
# The sensor base class handles updating the state on connection, so we test this with a single voltage sensor for ease
await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_VOLTAGE_SENSORS
)
assert len(monitors.listeners) == 0 # Make sure we cleaned up the listener
assert_sensor_state(hass, "sensor.voltage_1", "120.0")
async def test_disable_sensor_after_monitor_connected(
hass: HomeAssistant, monitors: AsyncMock
) -> None:
"""Test that a sensor disabled after its monitor connected stops listening for sensor changes."""
# The sensor base class handles connecting the monitor, so we test this with a single voltage sensor for ease
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_VOLTAGE_SENSORS
)
monitor = await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
assert len(monitor.voltage_sensor.listeners) == 1
await disable_entity(hass, "sensor.voltage_1")
assert len(monitor.voltage_sensor.listeners) == 0
async def test_updates_state_when_sensor_pushes(
hass: HomeAssistant, monitors: AsyncMock
) -> None:
"""Test that a sensor entity updates its state when the underlying sensor pushes an update."""
# The sensor base class handles triggering state updates, so we test this with a single voltage sensor for ease
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_VOLTAGE_SENSORS
)
monitor = await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
assert_sensor_state(hass, "sensor.voltage_1", "120.0")
monitor.voltage_sensor.voltage = 119.8
monitor.voltage_sensor.notify_all_listeners()
assert_sensor_state(hass, "sensor.voltage_1", "119.8")
async def test_power_sensor_initially_unknown(
hass: HomeAssistant, monitors: AsyncMock
) -> None:
"""Test that the power sensor can handle its initial state being unknown (since the GEM API needs at least two packets to arrive before it can compute watts)."""
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_POWER_SENSORS
)
await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
assert_sensor_state(
hass, "sensor.channel_1", STATE_UNKNOWN, {DATA_WATT_SECONDS: 1000}
)
# This sensor was configured with net metering on, so we should be taking the
# polarized value
assert_sensor_state(
hass, "sensor.channel_two", STATE_UNKNOWN, {DATA_WATT_SECONDS: -400}
)
async def test_power_sensor(hass: HomeAssistant, monitors: AsyncMock) -> None:
"""Test that a power sensor reports its values correctly, including handling net metering."""
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_POWER_SENSORS
) | monitor = await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
monitor.channels[0].watts = 120.0
monitor.channels[1].watts = 120.0
monitor.channels[0].notify_all_listeners()
monitor.channels[1].notify_all_listeners()
assert_sensor_state(hass, "sensor.channel_1", "120.0", {DATA_WATT_SECONDS: 1000})
# This sensor was configured with net metering on, so we should be taking the
# polarized value
assert_sensor_state(hass, "sensor.channel_two", "120.0", {DATA_WATT_SECONDS: -400})
async def test_pulse_counter_initially_unknown(
hass: HomeAssistant, monitors: AsyncMock
) -> None:
"""Test that the pulse counter sensor can handle its initial state being unknown (since the GEM API needs at least two packets to arrive before it can compute pulses per time)."""
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_PULSE_COUNTERS
)
monitor = await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
monitor.pulse_counters[0].pulses_per_second = None
monitor.pulse_counters[1].pulses_per_second = None
monitor.pulse_counters[2].pulses_per_second = None
monitor.pulse_counters[0].notify_all_listeners()
monitor.pulse_counters[1].notify_all_listeners()
monitor.pulse_counters[2].notify_all_listeners()
assert_sensor_state(hass, "sensor.pulse_a", STATE_UNKNOWN, {DATA_PULSES: 1000})
# This counter was configured with each pulse meaning 0.5 gallons and
# wanting to show gallons per minute, so 10 pulses per second -> 300 gal/min
assert_sensor_state(hass, "sensor.pulse_2", STATE_UNKNOWN, {DATA_PULSES: 1000})
# This counter was configured with each pulse meaning 0.5 gallons and
# wanting to show gallons per hour, so 10 pulses per second -> 18000 gal/hr
assert_sensor_state(hass, "sensor.pulse_3", STATE_UNKNOWN, {DATA_PULSES: 1000})
async def test_pulse_counter(hass: HomeAssistant, monitors: AsyncMock) -> None:
"""Test that a pulse counter sensor reports its values properly, including calculating different units."""
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_PULSE_COUNTERS
)
await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
assert_sensor_state(hass, "sensor.pulse_a", "10.0", {DATA_PULSES: 1000})
# This counter was configured with each pulse meaning 0.5 gallons and
# wanting to show gallons per minute, so 10 pulses per second -> 300 gal/min
assert_sensor_state(hass, "sensor.pulse_2", "300.0", {DATA_PULSES: 1000})
# This counter was configured with each pulse meaning 0.5 gallons and
# wanting to show gallons per hour, so 10 pulses per second -> 18000 gal/hr
assert_sensor_state(hass, "sensor.pulse_3", "18000.0", {DATA_PULSES: 1000})
async def test_temperature_sensor(hass: HomeAssistant, monitors: AsyncMock) -> None:
"""Test that a temperature sensor reports its values properly, including proper handling of when its native unit is different from that configured in hass."""
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_TEMPERATURE_SENSORS
)
await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
# The config says that the sensor is reporting in Fahrenheit; if we set that up
# properly, HA will have converted that to Celsius by default.
assert_sensor_state(hass, "sensor.temp_a", "0.0")
async def test_voltage_sensor(hass: HomeAssistant, monitors: AsyncMock) -> None:
"""Test that a voltage sensor reports its values properly."""
await setup_greeneye_monitor_component_with_config(
hass, SINGLE_MONITOR_CONFIG_VOLTAGE_SENSORS
)
await connect_monitor(hass, monitors, SINGLE_MONITOR_SERIAL_NUMBER)
assert_sensor_state(hass, "sensor.voltage_1", "120.0")
async def test_multi_monitor_sensors(hass: HomeAssistant, monitors: AsyncMock) -> None:
"""Test that sensors still work when multiple monitors are registered."""
await setup_greeneye_monitor_component_with_config(hass, MULTI_MONITOR_CONFIG)
await connect_monitor(hass, monitors, 1)
await connect_monitor(hass, monitors, 2)
await connect_monitor(hass, monitors, 3)
assert_sensor_state(hass, "sensor.unit_1_temp_1", "32.0")
assert_sensor_state(hass, "sensor.unit_2_temp_1", "0.0")
assert_sensor_state(hass, "sensor.unit_3_temp_1", "32.0")
async def disable_entity(hass: HomeAssistant, entity_id: str) -> None:
"""Disable the given entity."""
entity_registry = get_entity_registry(hass)
entity_registry.async_update_entity(
entity_id, disabled_by=RegistryEntryDisabler.USER
)
await hass.async_block_till_done() | |
basic.rs | use anyhow::Context as _;
use anyhow::Result;
use async_trait::async_trait;
use asynchronous_codec::Bytes;
use futures::SinkExt;
use futures::StreamExt;
use libp2p_core::multiaddr::Protocol;
use libp2p_core::Multiaddr;
use std::collections::HashSet;
use std::time::Duration;
use tokio_tasks::Tasks;
use xtra::message_channel::StrongMessageChannel;
use xtra::spawn::TokioGlobalSpawnExt;
use xtra::Actor;
use xtra::Address;
use xtra_libp2p::libp2p::identity::Keypair;
use xtra_libp2p::libp2p::transport::MemoryTransport;
use xtra_libp2p::libp2p::PeerId;
use xtra_libp2p::Connect;
use xtra_libp2p::Disconnect;
use xtra_libp2p::Endpoint;
use xtra_libp2p::GetConnectionStats;
use xtra_libp2p::ListenOn;
use xtra_libp2p::NewInboundSubstream;
use xtra_libp2p::OpenSubstream;
use xtra_productivity::xtra_productivity;
#[tokio::test]
async fn hello_world() {
let alice_hello_world_handler = HelloWorld::default().create(None).spawn_global();
let (alice_peer_id, _, _alice, bob, _) = alice_and_bob(
[(
"/hello-world/1.0.0",
alice_hello_world_handler.clone_channel(),
)],
[],
)
.await;
let bob_to_alice = bob
.send(OpenSubstream::single_protocol(
alice_peer_id,
"/hello-world/1.0.0",
))
.await
.unwrap()
.unwrap();
let string = hello_world_dialer(bob_to_alice, "Bob").await.unwrap();
assert_eq!(string, "Hello Bob!");
}
#[tokio::test]
async fn after_connect_see_each_other_as_connected() {
let (alice_peer_id, bob_peer_id, alice, bob, _) = alice_and_bob([], []).await;
let alice_stats = alice.send(GetConnectionStats).await.unwrap();
let bob_stats = bob.send(GetConnectionStats).await.unwrap();
assert_eq!(alice_stats.connected_peers, HashSet::from([bob_peer_id]));
assert_eq!(bob_stats.connected_peers, HashSet::from([alice_peer_id]));
}
#[tokio::test]
async fn disconnect_is_reflected_in_stats() {
let (_, bob_peer_id, alice, bob, _) = alice_and_bob([], []).await;
alice.send(Disconnect(bob_peer_id)).await.unwrap();
let alice_stats = alice.send(GetConnectionStats).await.unwrap();
let bob_stats = bob.send(GetConnectionStats).await.unwrap();
assert_eq!(alice_stats.connected_peers, HashSet::from([]));
assert_eq!(bob_stats.connected_peers, HashSet::from([]));
}
#[tokio::test]
async fn listen_address_is_reflected_in_stats() {
let (_, _, alice, _, listen_address) = alice_and_bob([], []).await;
let alice_stats = alice.send(GetConnectionStats).await.unwrap();
assert_eq!(
alice_stats.listen_addresses,
HashSet::from([listen_address])
);
}
#[tokio::test]
async fn cannot_open_substream_for_unhandled_protocol() {
let (_, bob_peer_id, alice, _bob, _) = alice_and_bob([], []).await;
let error = alice
.send(OpenSubstream::single_protocol(
bob_peer_id,
"/foo/bar/1.0.0",
))
.await
.unwrap()
.unwrap_err();
assert!(matches!(
error,
xtra_libp2p::Error::NegotiationFailed(xtra_libp2p::NegotiationError::Failed)
))
}
#[tokio::test]
async fn cannot_connect_twice() {
let (alice_peer_id, _bob_peer_id, _alice, bob, alice_listen) = alice_and_bob([], []).await;
let error = bob
.send(Connect(
alice_listen.with(Protocol::P2p(alice_peer_id.into())),
))
.await
.unwrap()
.unwrap_err();
assert!(matches!(
error,
xtra_libp2p::Error::AlreadyConnected(twin) if twin == alice_peer_id
))
}
#[tokio::test]
async fn chooses_first_protocol_in_list_of_multiple() {
let alice_hello_world_handler = HelloWorld::default().create(None).spawn_global();
let (alice_peer_id, _, _alice, bob, _) = alice_and_bob(
[(
"/hello-world/1.0.0",
alice_hello_world_handler.clone_channel(),
)],
[],
)
.await;
let (actual_protocol, _) = bob
.send(OpenSubstream::multiple_protocols(
alice_peer_id,
vec![
"/hello-world/1.0.0",
"/foo-bar/1.0.0", // This is unsupported by Alice. | .await
.unwrap()
.unwrap();
assert_eq!(actual_protocol, "/hello-world/1.0.0");
}
#[cfg_attr(debug_assertions, tokio::test)] // The assertion for duplicate handlers only runs in debug mode.
#[should_panic(expected = "Duplicate handler declared for protocol /hello-world/1.0.0")]
async fn disallow_duplicate_handlers() {
let hello_world_handler = HelloWorld::default().create(None).spawn_global();
make_endpoint([
("/hello-world/1.0.0", hello_world_handler.clone_channel()),
("/hello-world/1.0.0", hello_world_handler.clone_channel()),
]);
}
#[tokio::test]
async fn falls_back_to_next_protocol_if_unsupported() {
let alice_hello_world_handler = HelloWorld::default().create(None).spawn_global();
let (alice_peer_id, _, _alice, bob, _) = alice_and_bob(
[(
"/hello-world/1.0.0",
alice_hello_world_handler.clone_channel(),
)],
[],
)
.await;
let (actual_protocol, _) = bob
.send(OpenSubstream::multiple_protocols(
alice_peer_id,
vec![
"/foo-bar/1.0.0", // This is unsupported by Alice.
"/hello-world/1.0.0",
],
))
.await
.unwrap()
.unwrap();
assert_eq!(actual_protocol, "/hello-world/1.0.0");
}
async fn alice_and_bob<const AN: usize, const BN: usize>(
alice_inbound_substream_handlers: [(
&'static str,
Box<dyn StrongMessageChannel<NewInboundSubstream>>,
); AN],
bob_inbound_substream_handlers: [(
&'static str,
Box<dyn StrongMessageChannel<NewInboundSubstream>>,
); BN],
) -> (
PeerId,
PeerId,
Address<Endpoint>,
Address<Endpoint>,
Multiaddr,
) {
let port = rand::random::<u16>();
let (alice_peer_id, alice) = make_endpoint(alice_inbound_substream_handlers);
let (bob_peer_id, bob) = make_endpoint(bob_inbound_substream_handlers);
let alice_listen = format!("/memory/{port}").parse::<Multiaddr>().unwrap();
alice.send(ListenOn(alice_listen.clone())).await.unwrap();
bob.send(Connect(
format!("/memory/{port}/p2p/{alice_peer_id}")
.parse()
.unwrap(),
))
.await
.unwrap()
.unwrap();
(alice_peer_id, bob_peer_id, alice, bob, alice_listen)
}
fn make_endpoint<const N: usize>(
substream_handlers: [(
&'static str,
Box<dyn StrongMessageChannel<NewInboundSubstream>>,
); N],
) -> (PeerId, Address<Endpoint>) {
let id = Keypair::generate_ed25519();
let peer_id = id.public().to_peer_id();
let endpoint = Endpoint::new(
MemoryTransport::default(),
id,
Duration::from_secs(20),
substream_handlers,
)
.create(None)
.spawn_global();
(peer_id, endpoint)
}
#[derive(Default)]
struct HelloWorld {
tasks: Tasks,
}
#[xtra_productivity(message_impl = false)]
impl HelloWorld {
async fn handle(&mut self, msg: NewInboundSubstream) {
tracing::info!("New hello world stream from {}", msg.peer);
self.tasks
.add_fallible(hello_world_listener(msg.stream), move |e| async move {
tracing::warn!("Hello world protocol with peer {} failed: {}", msg.peer, e);
});
}
}
#[async_trait]
impl Actor for HelloWorld {
type Stop = ();
async fn stopped(self) -> Self::Stop {}
}
async fn hello_world_dialer(stream: xtra_libp2p::Substream, name: &'static str) -> Result<String> {
let mut stream = asynchronous_codec::Framed::new(stream, asynchronous_codec::LengthCodec);
stream.send(Bytes::from(name)).await?;
let bytes = stream.next().await.context("Expected message")??;
let message = String::from_utf8(bytes.to_vec())?;
Ok(message)
}
async fn hello_world_listener(stream: xtra_libp2p::Substream) -> Result<()> {
let mut stream =
asynchronous_codec::Framed::new(stream, asynchronous_codec::LengthCodec).fuse();
let bytes = stream.select_next_some().await?;
let name = String::from_utf8(bytes.to_vec())?;
stream.send(Bytes::from(format!("Hello {name}!"))).await?;
Ok(())
} | ],
)) |
kendo.culture.tn.min.js | /**
* Kendo UI v2016.3.1118 (http://www.telerik.com/kendo-ui)
* Copyright 2016 Telerik AD. All rights reserved.
*
* Kendo UI commercial licenses may be obtained at
* http://www.telerik.com/purchase/license-agreement/kendo-ui-complete
* If you do not own a commercial license, this file shall be governed by the trial license terms.
|
*/
!function(e){"function"==typeof define&&define.amd?define(["kendo.core.min"],e):e()}(function(){!function(e,M){kendo.cultures.tn={name:"tn",numberFormat:{pattern:["-n"],decimals:2,",":",",".":".",groupSize:[3],percent:{pattern:["-%n","%n"],decimals:2,",":",",".":".",groupSize:[3],symbol:"%"},currency:{name:"",abbr:"",pattern:["$-n","$ n"],decimals:2,",":",",".":".",groupSize:[3],symbol:"R"}},calendars:{standard:{days:{names:["Sontaga","Mosupologo","Labobedi","Laboraro","Labone","Labotlhano","Matlhatso"],namesAbbr:["Sont.","Mos.","Lab.","Labr.","Labn.","Labt.","Matlh."],namesShort:["So","Ms","Lb","Lr","Ln","Lt","Ma"]},months:{names:["Ferikgong","Tlhakole","Mopitlwe","Moranang","Motsheganong","Seetebosigo","Phukwi","Phatwe","Lwetse","Diphalane","Ngwanatsele","Sedimothole"],namesAbbr:["Fer.","Tlh.","Mop.","Mor.","Motsh.","Seet.","Phk.","Pht.","Lwetse.","Diph.","Ngwn.","Sed."]},AM:["Mo Mosong","mo mosong","MO MOSONG"],PM:["Mo Maitseboeng","mo maitseboeng","MO MAITSEBOENG"],patterns:{d:"dd/MM/yy",D:"dd MMMM yyyy",F:"dd MMMM yyyy hh:mm:ss tt",g:"dd/MM/yy hh:mm tt",G:"dd/MM/yy hh:mm:ss tt",m:"d MMMM",M:"d MMMM",s:"yyyy'-'MM'-'dd'T'HH':'mm':'ss",t:"hh:mm tt",T:"hh:mm:ss tt",u:"yyyy'-'MM'-'dd HH':'mm':'ss'Z'",y:"MMMM yyyy",Y:"MMMM yyyy"},"/":"/",":":":",firstDay:1}}}}(this)});
//# sourceMappingURL=kendo.culture.tn.min.js.map | |
sb.starboardAlreadyStarred.ts | import * as DJS from "discord.js";
import Bot from "structures/Bot";
import Event from "structures/Event";
export default class | extends Event {
constructor(bot: Bot) {
super(bot, "starboardAlreadyStarred");
}
async execute(bot: Bot, _: string, message: DJS.Message, user: DJS.User) {
if (!message.guild?.available) return;
if (
!(message.channel as DJS.TextChannel)
.permissionsFor(message.guild.me!)
?.has(DJS.Permissions.FLAGS.SEND_MESSAGES)
) {
return;
}
const lang = await bot.utils.getGuildLang(message.guild?.id);
return message.channel.send({
content: lang.EVENTS.STARBOARD_MESSAGE.replace("{userTag}", user.tag),
});
}
}
| StarboardAlreadyStarredEvent |
mod.rs | // Copyright (c) The Libra Core Contributors
// SPDX-License-Identifier: Apache-2.0
#[cfg(test)]
mod consensusdb_test;
mod schema;
use crate::consensusdb::schema::{
block::{BlockSchema, SchemaBlock},
quorum_certificate::QCSchema,
single_entry::{SingleEntryKey, SingleEntrySchema},
};
use anyhow::{ensure, Result};
use consensus_types::{block::Block, common::Payload, quorum_cert::QuorumCert};
use libra_crypto::HashValue;
use libra_logger::prelude::*;
use schema::{BLOCK_CF_NAME, QC_CF_NAME, SINGLE_ENTRY_CF_NAME};
use schemadb::{ReadOptions, SchemaBatch, DB, DEFAULT_CF_NAME};
use std::{collections::HashMap, iter::Iterator, path::Path, time::Instant};
type HighestTimeoutCertificate = Vec<u8>;
type VoteMsgData = Vec<u8>;
pub struct ConsensusDB {
db: DB,
}
impl ConsensusDB {
pub fn new<P: AsRef<Path> + Clone>(db_root_path: P) -> Self |
pub fn get_data<T: Payload>(
&self,
) -> Result<(
Option<VoteMsgData>,
Option<HighestTimeoutCertificate>,
Vec<Block<T>>,
Vec<QuorumCert>,
)> {
let last_vote_msg_data = self.get_last_vote_msg_data()?;
let highest_timeout_certificate = self.get_highest_timeout_certificate()?;
let consensus_blocks = self
.get_blocks()?
.into_iter()
.map(|(_block_hash, block_content)| block_content)
.collect::<Vec<_>>();
let consensus_qcs = self
.get_quorum_certificates()?
.into_iter()
.map(|(_block_hash, qc)| qc)
.collect::<Vec<_>>();
Ok((
last_vote_msg_data,
highest_timeout_certificate,
consensus_blocks,
consensus_qcs,
))
}
pub fn save_highest_timeout_certificate(
&self,
highest_timeout_certificate: HighestTimeoutCertificate,
) -> Result<()> {
let mut batch = SchemaBatch::new();
batch.put::<SingleEntrySchema>(
&SingleEntryKey::HighestTimeoutCertificate,
&highest_timeout_certificate,
)?;
self.commit(batch)
}
pub fn save_state(&self, last_vote: VoteMsgData) -> Result<()> {
let mut batch = SchemaBatch::new();
batch.put::<SingleEntrySchema>(&SingleEntryKey::LastVoteMsg, &last_vote)?;
self.commit(batch)
}
pub fn save_blocks_and_quorum_certificates<T: Payload>(
&self,
block_data: Vec<Block<T>>,
qc_data: Vec<QuorumCert>,
) -> Result<()> {
ensure!(
!block_data.is_empty() || !qc_data.is_empty(),
"Consensus block and qc data is empty!"
);
let mut batch = SchemaBatch::new();
block_data
.iter()
.map(|block| {
batch.put::<BlockSchema<T>>(
&block.id(),
&SchemaBlock::<T>::from_block(block.clone()),
)
})
.collect::<Result<()>>()?;
qc_data
.iter()
.map(|qc| batch.put::<QCSchema>(&qc.certified_block().id(), qc))
.collect::<Result<()>>()?;
self.commit(batch)
}
pub fn delete_blocks_and_quorum_certificates<T: Payload>(
&self,
block_ids: Vec<HashValue>,
) -> Result<()> {
ensure!(!block_ids.is_empty(), "Consensus block ids is empty!");
let mut batch = SchemaBatch::new();
block_ids
.iter()
.map(|hash| {
batch.delete::<BlockSchema<T>>(hash)?;
batch.delete::<QCSchema>(hash)
})
.collect::<Result<_>>()?;
self.commit(batch)
}
/// Write the whole schema batch including all data necessary to mutate the ledger
/// state of some transaction by leveraging rocksdb atomicity support.
fn commit(&self, batch: SchemaBatch) -> Result<()> {
self.db.write_schemas(batch)
}
/// Get latest timeout certificates (we only store the latest highest timeout certificates).
fn get_highest_timeout_certificate(&self) -> Result<Option<Vec<u8>>> {
self.db
.get::<SingleEntrySchema>(&SingleEntryKey::HighestTimeoutCertificate)
}
/// Delete the timeout certificates
pub fn delete_highest_timeout_certificate(&self) -> Result<()> {
let mut batch = SchemaBatch::new();
batch.delete::<SingleEntrySchema>(&SingleEntryKey::HighestTimeoutCertificate)?;
self.commit(batch)
}
/// Get latest vote message data (if available)
fn get_last_vote_msg_data(&self) -> Result<Option<Vec<u8>>> {
self.db
.get::<SingleEntrySchema>(&SingleEntryKey::LastVoteMsg)
}
pub fn delete_last_vote_msg(&self) -> Result<()> {
let mut batch = SchemaBatch::new();
batch.delete::<SingleEntrySchema>(&SingleEntryKey::LastVoteMsg)?;
self.commit(batch)
}
/// Get all consensus blocks.
fn get_blocks<T: Payload>(&self) -> Result<HashMap<HashValue, Block<T>>> {
let mut iter = self.db.iter::<BlockSchema<T>>(ReadOptions::default())?;
iter.seek_to_first();
iter.map(|value| value.and_then(|(k, v)| Ok((k, v.borrow_into_block().clone()))))
.collect::<Result<HashMap<HashValue, Block<T>>>>()
}
/// Get all consensus QCs.
fn get_quorum_certificates(&self) -> Result<HashMap<HashValue, QuorumCert>> {
let mut iter = self.db.iter::<QCSchema>(ReadOptions::default())?;
iter.seek_to_first();
iter.collect::<Result<HashMap<HashValue, QuorumCert>>>()
}
}
| {
let column_families = vec![
/* UNUSED CF = */ DEFAULT_CF_NAME,
BLOCK_CF_NAME,
QC_CF_NAME,
SINGLE_ENTRY_CF_NAME,
];
let path = db_root_path.as_ref().join("consensusdb");
let instant = Instant::now();
let db = DB::open(path.clone(), column_families)
.expect("ConsensusDB open failed; unable to continue");
info!(
"Opened ConsensusDB at {:?} in {} ms",
path,
instant.elapsed().as_millis()
);
Self { db }
} |
favs_v1.py | import json, base64, requests
from jinja2 import Environment, FileSystemLoader
from pathlib import Path
import webbrowser
import tweepy
import sys
class Twitter:
def __init__(self, auth, Bearer_Token=None):
self.auth = auth
self.Bearer_Token = Bearer_Token
if self.auth is None:
raise ValueError("API Authorisation keys needed.")
if (self.auth.get("API_key", None) == None) or (self.auth.get("API_secret_key", None) == None):
raise ValueError("'API_key' and 'API_scret_key' not specified")
Path().absolute().joinpath("data").mkdir(parents=True, exist_ok=True)
def GET_BearerToken(self):
credentials = self.auth["API_key"] + ":" + self.auth["API_secret_key"]
b64_creds = base64.b64encode(credentials.encode()).decode()
headers = {
"Authorization" : "Basic " + b64_creds,
"Content-Type" : "application/x-www-form-urlencoded",
"charset" : "UTF-8"
}
payload = {
"grant_type" : "client_credentials"
}
r = requests.post(
"https://api.twitter.com/oauth2/token",
headers=headers,
data=payload
)
self.Bearer_Token = r.json()
later_use = input("Save Bearer Token for later use? [y/n] : ")
if (later_use.lower() == "y"):
with open("Bearer_Token.json", "w", encoding="UTF-8") as bt_file:
json.dump(self.Bearer_Token, bt_file)
print("Saved to Bearer_Token.json")
return self.Bearer_Token
def GET_Favourites(self, screen_name, count, Bearer_Token=None):
if Bearer_Token == None:
print("Bearer Token not specified.\n Using from Class Instance.")
Bearer_Token = self.Bearer_Token
if Bearer_Token == None:
raise ValueError("Class instance not initialized Bearer_Token")
headers = {
"Authorization" : Bearer_Token["token_type"] +
" " +
Bearer_Token["access_token"]
}
payload = {
"screen_name" : screen_name,
"count" : count,
"tweet_mode" : "extended"
}
r = requests.get(
"https://api.twitter.com/1.1/favorites/list.json",
headers=headers,
params=payload
)
favs = r.json()
with open("data/favs.json", "w", encoding='UTF-8') as favs_file:
json.dump(favs, favs_file, indent=4, ensure_ascii=False)
print("{} Favourite Tweets Captured".format(len(favs)))
return favs
def GET_MediaTweets(self, favs=None):
if favs == None :
with open("data/favs.json", "r", encoding="UTF-8") as fav_file:
favs = json.load(fav_file)
media_tweets = []
for tweet in favs:
extended_entity = tweet.get("extended_entities", None)
if extended_entity != None:
media_tweet = {}
media_tweet["created_at"] = tweet["created_at"]
media_tweet["media"] = tweet["extended_entities"]["media"]
media_tweets.append(media_tweet)
with open("data/media_tweets.json", "w", encoding="UTF-8") as media_tweets_file:
json.dump(media_tweets, media_tweets_file, indent=4, ensure_ascii=False)
print("{} Tweets with Media".format(len(media_tweets)))
return media_tweets
def GET_Media(self, media_tweets=None):
if media_tweets == None:
with open("data/media_tweets.json", "r", encoding="UTF-8") as media_tweets_file:
media_tweets = json.load(media_tweets_file)
custom_media_list = []
for tweet in media_tweets:
media_ele_list = tweet["media"]
for media_ele in media_ele_list:
custom_media_ele = {}
custom_media_ele["created_at"] = tweet["created_at"]
custom_media_ele["type"] = media_ele["type"]
custom_media_ele["id"] = media_ele["id_str"]
if custom_media_ele["type"] == "video" or custom_media_ele["type"] == "animated_gif":
variants = {}
for video_variants in media_ele["video_info"]["variants"]:
if video_variants["content_type"] == "video/mp4":
variants[video_variants["bitrate"]] = video_variants["url"]
max_bitrate = max(variants.keys())
custom_media_ele["url"] = variants[max_bitrate]
else:
custom_media_ele["url"] = media_ele["media_url"]
custom_media_list.append(custom_media_ele)
with open("data/media.json", "w", encoding="UTF-8") as media_file:
json.dump(custom_media_list, media_file, indent=4, ensure_ascii=False)
print("{} Media".format(len(custom_media_list)))
return custom_media_list
def visualize(self, media=None):
if media == None:
with open("data/media.json", "r", encoding="UTF-8") as media_file:
media_list = json.load(media_file)
else:
media_list = media
file_loader = FileSystemLoader('Templates')
env = Environment(loader=file_loader) | output = template.render(media_list=media_list)
with open("./data/media.html", "w") as index_file:
index_file.write(output)
webbrowser.open("data\\media.html")
with open("auth.json", "r") as auth_file:
auth = json.load(auth_file)
twpy = Twitter(auth)
twpy.visualize(
twpy.GET_Media(
twpy.GET_MediaTweets(
twpy.GET_Favourites(
"Twitter", 200, twpy.GET_BearerToken()
)
)
)
) |
template = env.get_template('media.html') |
test_cli.py | import re
import subprocess
from subprocess import CalledProcessError
import tempfile
import pytest
import optuna
from optuna.cli import _Studies
from optuna.exceptions import CLIUsageError
from optuna.storages.base import DEFAULT_STUDY_NAME_PREFIX
from optuna.storages import RDBStorage
from optuna.testing.storage import StorageSupplier
from optuna import type_checking
if type_checking.TYPE_CHECKING:
from typing import List # NOQA
from optuna.trial import Trial # NOQA
def test_create_study_command():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
# Create study.
command = ["optuna", "create-study", "--storage", storage_url]
subprocess.check_call(command)
# Command output should be in name string format (no-name + UUID).
study_name = str(subprocess.check_output(command).decode().strip())
name_re = r"^no-name-[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
assert re.match(name_re, study_name) is not None
# study_name should be stored in storage.
study_id = storage.get_study_id_from_name(study_name)
assert study_id == 2
def test_create_study_command_with_study_name():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
study_name = "test_study"
# Create study with name.
command = ["optuna", "create-study", "--storage", storage_url, "--study-name", study_name]
study_name = str(subprocess.check_output(command).decode().strip())
# Check if study_name is stored in the storage.
study_id = storage.get_study_id_from_name(study_name)
assert storage.get_study_name_from_id(study_id) == study_name
def test_create_study_command_without_storage_url():
# type: () -> None
with pytest.raises(subprocess.CalledProcessError) as err:
subprocess.check_output(["optuna", "create-study"])
usage = err.value.output.decode()
assert usage.startswith("usage:")
def test_create_study_command_with_direction():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
command = ["optuna", "create-study", "--storage", storage_url, "--direction", "minimize"]
study_name = str(subprocess.check_output(command).decode().strip())
study_id = storage.get_study_id_from_name(study_name)
assert storage.get_study_direction(study_id) == optuna.structs.StudyDirection.MINIMIZE
command = ["optuna", "create-study", "--storage", storage_url, "--direction", "maximize"]
study_name = str(subprocess.check_output(command).decode().strip())
study_id = storage.get_study_id_from_name(study_name)
assert storage.get_study_direction(study_id) == optuna.structs.StudyDirection.MAXIMIZE
command = ["optuna", "create-study", "--storage", storage_url, "--direction", "test"]
# --direction should be either 'minimize' or 'maximize'.
with pytest.raises(subprocess.CalledProcessError):
subprocess.check_call(command)
def | ():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
study_name = "delete-study-test"
# Create study.
command = ["optuna", "create-study", "--storage", storage_url, "--study-name", study_name]
subprocess.check_call(command)
assert study_name in {s.study_name: s for s in storage.get_all_study_summaries()}
# Delete study.
command = ["optuna", "delete-study", "--storage", storage_url, "--study-name", study_name]
subprocess.check_call(command)
assert study_name not in {s.study_name: s for s in storage.get_all_study_summaries()}
def test_delete_study_command_without_storage_url():
# type: () -> None
with pytest.raises(subprocess.CalledProcessError):
subprocess.check_output(["optuna", "delete-study", "--study-name", "dummy_study"])
def test_study_set_user_attr_command():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
# Create study.
study_name = storage.get_study_name_from_id(storage.create_new_study())
base_command = [
"optuna",
"study",
"set-user-attr",
"--study",
study_name,
"--storage",
storage_url,
]
example_attrs = {"architecture": "ResNet", "baselen_score": "0.002"}
for key, value in example_attrs.items():
subprocess.check_call(base_command + ["--key", key, "--value", value])
# Attrs should be stored in storage.
study_id = storage.get_study_id_from_name(study_name)
study_user_attrs = storage.get_study_user_attrs(study_id)
assert len(study_user_attrs) == 2
assert all([study_user_attrs[k] == v for k, v in example_attrs.items()])
def test_studies_command():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
# First study.
study_1 = optuna.create_study(storage)
# Second study.
study_2 = optuna.create_study(storage, study_name="study_2")
study_2.optimize(objective_func, n_trials=10)
# Run command.
command = ["optuna", "studies", "--storage", storage_url]
output = str(subprocess.check_output(command).decode().strip())
rows = output.split("\n")
def get_row_elements(row_index):
# type: (int) -> List[str]
return [r.strip() for r in rows[row_index].split("|")[1:-1]]
assert len(rows) == 6
assert tuple(get_row_elements(1)) == _Studies._study_list_header
# Check study_name and n_trials for the first study.
elms = get_row_elements(3)
assert elms[0] == study_1.study_name
assert elms[2] == "0"
# Check study_name and n_trials for the second study.
elms = get_row_elements(4)
assert elms[0] == study_2.study_name
assert elms[2] == "10"
def test_create_study_command_with_skip_if_exists():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
study_name = "test_study"
# Create study with name.
command = ["optuna", "create-study", "--storage", storage_url, "--study-name", study_name]
study_name = str(subprocess.check_output(command).decode().strip())
# Check if study_name is stored in the storage.
study_id = storage.get_study_id_from_name(study_name)
assert storage.get_study_name_from_id(study_id) == study_name
# Try to create the same name study without `--skip-if-exists` flag (error).
command = ["optuna", "create-study", "--storage", storage_url, "--study-name", study_name]
with pytest.raises(subprocess.CalledProcessError):
subprocess.check_output(command)
# Try to create the same name study with `--skip-if-exists` flag (OK).
command = [
"optuna",
"create-study",
"--storage",
storage_url,
"--study-name",
study_name,
"--skip-if-exists",
]
study_name = str(subprocess.check_output(command).decode().strip())
new_study_id = storage.get_study_id_from_name(study_name)
assert study_id == new_study_id # The existing study instance is reused.
def test_dashboard_command():
# type: () -> None
with StorageSupplier("new") as storage, tempfile.NamedTemporaryFile("r") as tf_report:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
study_name = storage.get_study_name_from_id(storage.create_new_study())
command = [
"optuna",
"dashboard",
"--study",
study_name,
"--out",
tf_report.name,
"--storage",
storage_url,
]
subprocess.check_call(command)
html = tf_report.read()
assert "<body>" in html
assert "bokeh" in html
@pytest.mark.parametrize(
"origins", [["192.168.111.1:5006"], ["192.168.111.1:5006", "192.168.111.2:5006"]]
)
def test_dashboard_command_with_allow_websocket_origin(origins):
# type: (List[str]) -> None
with StorageSupplier("new") as storage, tempfile.NamedTemporaryFile("r") as tf_report:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
study_name = storage.get_study_name_from_id(storage.create_new_study())
command = [
"optuna",
"dashboard",
"--study",
study_name,
"--out",
tf_report.name,
"--storage",
storage_url,
]
for origin in origins:
command.extend(["--allow-websocket-origin", origin])
subprocess.check_call(command)
html = tf_report.read()
assert "<body>" in html
assert "bokeh" in html
# An example of objective functions for testing study optimize command
def objective_func(trial):
# type: (Trial) -> float
x = trial.suggest_uniform("x", -10, 10)
return (x + 5) ** 2
def test_study_optimize_command():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
study_name = storage.get_study_name_from_id(storage.create_new_study())
command = [
"optuna",
"study",
"optimize",
"--study",
study_name,
"--n-trials",
"10",
__file__,
"objective_func",
"--storage",
storage_url,
]
subprocess.check_call(command)
study = optuna.load_study(storage=storage_url, study_name=study_name)
assert len(study.trials) == 10
assert "x" in study.best_params
# Check if a default value of study_name is stored in the storage.
assert storage.get_study_name_from_id(study._study_id).startswith(
DEFAULT_STUDY_NAME_PREFIX
)
def test_study_optimize_command_inconsistent_args():
# type: () -> None
with tempfile.NamedTemporaryFile() as tf:
db_url = "sqlite:///{}".format(tf.name)
# --study argument is missing.
with pytest.raises(subprocess.CalledProcessError):
subprocess.check_call(
[
"optuna",
"study",
"optimize",
"--storage",
db_url,
"--n-trials",
"10",
__file__,
"objective_func",
]
)
def test_empty_argv():
# type: () -> None
command_empty = ["optuna"]
command_empty_output = str(subprocess.check_output(command_empty))
command_help = ["optuna", "help"]
command_help_output = str(subprocess.check_output(command_help))
assert command_empty_output == command_help_output
def test_check_storage_url():
# type: () -> None
storage_in_args = "sqlite:///args.db"
assert storage_in_args == optuna.cli._check_storage_url(storage_in_args)
with pytest.raises(CLIUsageError):
optuna.cli._check_storage_url(None)
def test_storage_upgrade_command():
# type: () -> None
with StorageSupplier("new") as storage:
assert isinstance(storage, RDBStorage)
storage_url = str(storage.engine.url)
command = ["optuna", "storage", "upgrade"]
with pytest.raises(CalledProcessError):
subprocess.check_call(command)
command.extend(["--storage", storage_url])
subprocess.check_call(command)
| test_delete_study_command |
furnace_test.scene.js | import { quad, block } from './helpers'
const lightMaterial = {
lambertian: {
// albedo: [1, 1, 1],
albedo: [0, 0, 0],
// emittance: [20, 15, 10]
emittance: [10, 10, 10]
}
}
const skyMaterial = {
lambertian: {
// albedo: [0.2, 0.2, 0.2],
albedo: [0, 0, 0],
emittance: [0xdd / 255, 0xee / 255, 1]
// emittance: [0.1, 0.1, 0.1]
}
}
const glassMaterial = {
// transmissive: {
fresnelSpecularTransmissive: {
// albedo: [0.9, 0.9, 0.9],
albedo: [1, 1, 1],
// refractiveIndex: 1.8
refractiveIndex: 1.62
// refractiveIndex: 1.333
}
}
const waterMaterial = {
// transmissive: {
fresnelSpecularTransmissive: {
albedo: [1, 1, 1],
// albedo: [0.7, 0.9, 1],
// albedo: [1, 1, 1],
// refractiveIndex: 1.8
// refractiveIndex: 1.62
refractiveIndex: 1.333
}
}
const mirrorMaterial = {
specular: {
albedo: [0.9, 0.9, 0.9],
emittance: [0, 0, 0]
}
}
const whiteMaterial = {
lambertian: {
albedo: [0.8, 0.8, 0.8]
}
}
const redMaterial = {
lambertian: {
albedo: [0.75, 0.25, 0.25]
}
}
const greenMaterial = {
lambertian: {
albedo: [0.25, 0.75, 0.25]
}
}
const cornellBox = [
// LIGHT
...quad(lightMaterial)(
[0.25, 1.0, 0.25],
[-0.25, 1.0, 0.25],
[-0.25, 1.0, -0.25],
[0.25, 1.0, -0.25]
),
// CEILING
...quad(whiteMaterial)(
[-0.25, 1.0, 0.25],
[-1, 1.0, 1],
[-1, 1.0, -1],
[-0.25, 1.0, -0.25]
),
...quad(whiteMaterial)(
[1, 1.0, 1],
[0.25, 1.0, 0.25],
[0.25, 1.0, -0.25],
[1, 1.0, -1]
),
...quad(whiteMaterial)(
[1, 1.0, 1],
[-1, 1.0, 1],
[-0.25, 1.0, 0.25],
[0.25, 1.0, 0.25]
),
...quad(whiteMaterial)(
[0.25, 1.0, -0.25],
[-0.25, 1.0, -0.25],
[-1, 1.0, -1],
[1, 1.0, -1]
),
// FLOOR
...quad(whiteMaterial)(
[-1.0, -1.0, 1.0],
[1.0, -1.0, 1.0],
[1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0]
),
// // BACK
...quad(whiteMaterial)(
[-1.0, 1.0, 1.0],
[1.0, 1.0, 1.0],
[1.0, -1.0, 1.0],
[-1.0, -1.0, 1.0]
),
// RIGHT
...quad(greenMaterial)(
[1.0, 1.0, 1.0],
[1.0, 1.0, -1.0],
[1.0, -1.0, -1.0],
[1.0, -1.0, 1.0]
),
// LEFT
...quad(redMaterial)(
[-1.0, 1.0, -1.0],
[-1.0, 1.0, 1.0],
[-1.0, -1.0, 1.0],
[-1.0, -1.0, -1.0]
)
]
const cheapCornellBox = [
// // LIGHT
// {
// sphere: {
// center: [0, 1, 0],
// radius: 0.25,
// material: lightMaterial
// }
// },
// {
// implicit: {
// distancefunction: [
// { dfBox: [0.2, 0.02, 0.2] },
// { dfTranslate: [0.05, 1.02, 0.05] }
// ],
// material: lightMaterial
// }
// },
// CEILING
{
plane: {
normal: [0, -1, 0],
d: -1,
// material: whiteMaterial
material: skyMaterial
}
},
// FLOOR
{
plane: {
normal: [0, 1, 0],
d: -1,
material: whiteMaterial
}
},
// // BACK
{
plane: {
normal: [0, 0, -1],
d: -1,
// material: mirrorMaterial
material: whiteMaterial
}
},
// // FRONT (BEHIND CAMERA)
{
plane: {
normal: [0, 0, 1],
d: -1,
material: {
lambertian: {
albedo: [0, 0, 0]
}
}
}
},
// RIGHT
{
plane: {
normal: [-1, 0, 0],
d: -1,
material: greenMaterial
}
},
// LEFT
{
plane: {
normal: [1, 0, 0],
d: -1,
material: redMaterial
}
} | const skyAndGround = [
// SKY
{
sphere: {
center: [0, 1, 0],
radius: 100,
material: skyMaterial
}
}
// {
// plane: {
// normal: [0, 1, 0],
// d: -1,
// material: {
// lambertian: {
// // albedo: [0xff / 255, 0xe7 / 255, 0xd9 / 255]
// // albedo: [0.4, 0.25, 0.25]
// // albedo: [0.5, 0.5, 0.5]
// albedo: [0.5, 0.5, 0.5]
// // emittance: [0.1, 0.1, 0.1]
// }
// }
// }
// }
]
export default {
maxDepth: 20,
camera: {
position: [0, 0, -4],
basis: {
tangent: [1, 0, 0],
bitangent: [0, -1, 0],
normal: [0, 0, 1]
},
aperture: 0,
fieldOfView: 1 / 3,
// fieldOfView: 0.35,
focalLength: 10
// tMin: 0.00001,
// tMax: Infinity
},
geometry: {
group: [
// ...skyAndGround,
...cheapCornellBox,
// TWISTED BOX
{
implicit: {
distancefunction: [
{ dfBox: [0.3, 0.3, 0.3] },
// { dfTwist: Math.PI / 2 }
{ dfRotate: Math.PI / 10 }
// { dfTwist: Math.PI }
// { dfTranslate: [0.35, -0.75, -0.35] }
],
// material: whiteMaterial
material: glassMaterial
// material: redMaterial
}
}
// // TORUS
// {
// implicit: {
// distancefunction: [
// { dfTorus: { major: 0.25, minor: 0.15 } }
// // { dfTwist: Math.PI },
// // { dfTranslate: [0.35, -0.5, -0.35] }
// ],
// // material: whiteMaterial
// // material: glassMaterial
// material: redMaterial
// }
// }
// // SPHERE
// {
// sphere: {
// center: [0, 0, 0],
// // radius: 0,
// radius: 0.4,
// // material: whiteMaterial
// // material: mirrorMaterial
// material: glassMaterial
// }
// }
]
}
} | ]
|
main.go | package main
import (
"context"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/containerd/console"
dockerfile "github.com/docker/dockerfile/builder"
"github.com/moby/buildkit/client"
"github.com/moby/buildkit/util/appcontext"
"github.com/moby/buildkit/util/appdefaults"
"github.com/moby/buildkit/util/progress/progressui"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
"github.com/urfave/cli"
"golang.org/x/sync/errgroup"
)
func main() {
app := cli.NewApp()
app.Name = "build-using-dockerfile"
app.UsageText = `build-using-dockerfile [OPTIONS] PATH | URL | -`
app.Description = `
build using Dockerfile.
This command mimics behavior of "docker build" command so that people can easily get started with BuildKit.
This command is NOT the replacement of "docker build", and should NOT be used for building production images.
By default, the built image is loaded to Docker.
`
dockerIncompatibleFlags := []cli.Flag{
cli.StringFlag{
Name: "buildkit-addr",
Usage: "buildkit daemon address",
EnvVar: "BUILDKIT_HOST",
Value: appdefaults.Address,
},
cli.BoolFlag{
Name: "clientside-frontend",
Usage: "run dockerfile frontend client side, rather than builtin to buildkitd",
EnvVar: "BUILDKIT_CLIENTSIDE_FRONTEND",
},
}
app.Flags = append([]cli.Flag{
cli.StringSliceFlag{
Name: "build-arg",
Usage: "Set build-time variables",
},
cli.StringFlag{
Name: "file, f",
Usage: "Name of the Dockerfile (Default is 'PATH/Dockerfile')",
},
cli.StringFlag{
Name: "tag, t",
Usage: "Name and optionally a tag in the 'name:tag' format",
},
cli.StringFlag{
Name: "target",
Usage: "Set the target build stage to build.",
},
cli.BoolFlag{
Name: "no-cache",
Usage: "Do not use cache when building the image",
},
}, dockerIncompatibleFlags...)
app.Action = action
if err := app.Run(os.Args); err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(1)
}
}
func | (clicontext *cli.Context) error {
ctx := appcontext.Context()
if tag := clicontext.String("tag"); tag == "" {
return errors.New("tag is not specified")
}
c, err := client.New(ctx, clicontext.String("buildkit-addr"), client.WithFailFast())
if err != nil {
return err
}
pipeR, pipeW := io.Pipe()
solveOpt, err := newSolveOpt(clicontext, pipeW)
if err != nil {
return err
}
ch := make(chan *client.SolveStatus)
eg, ctx := errgroup.WithContext(ctx)
eg.Go(func() error {
var err error
if clicontext.Bool("clientside-frontend") {
_, err = c.Build(ctx, *solveOpt, "", dockerfile.Build, ch)
} else {
_, err = c.Solve(ctx, nil, *solveOpt, ch)
}
return err
})
eg.Go(func() error {
var c console.Console
if cn, err := console.ConsoleFromFile(os.Stderr); err == nil {
c = cn
}
// not using shared context to not disrupt display but let is finish reporting errors
_, err = progressui.DisplaySolveStatus(context.TODO(), "", c, os.Stdout, ch)
return err
})
eg.Go(func() error {
if err := loadDockerTar(pipeR); err != nil {
return err
}
return pipeR.Close()
})
if err := eg.Wait(); err != nil {
return err
}
logrus.Infof("Loaded the image %q to Docker.", clicontext.String("tag"))
return nil
}
func newSolveOpt(clicontext *cli.Context, w io.WriteCloser) (*client.SolveOpt, error) {
buildCtx := clicontext.Args().First()
if buildCtx == "" {
return nil, errors.New("please specify build context (e.g. \".\" for the current directory)")
} else if buildCtx == "-" {
return nil, errors.New("stdin not supported yet")
}
file := clicontext.String("file")
if file == "" {
file = filepath.Join(buildCtx, "Dockerfile")
}
localDirs := map[string]string{
"context": buildCtx,
"dockerfile": filepath.Dir(file),
}
frontend := "dockerfile.v0" // TODO: use gateway
if clicontext.Bool("clientside-frontend") {
frontend = ""
}
frontendAttrs := map[string]string{
"filename": filepath.Base(file),
}
if target := clicontext.String("target"); target != "" {
frontendAttrs["target"] = target
}
if clicontext.Bool("no-cache") {
frontendAttrs["no-cache"] = ""
}
for _, buildArg := range clicontext.StringSlice("build-arg") {
kv := strings.SplitN(buildArg, "=", 2)
if len(kv) != 2 {
return nil, errors.Errorf("invalid build-arg value %s", buildArg)
}
frontendAttrs["build-arg:"+kv[0]] = kv[1]
}
return &client.SolveOpt{
Exports: []client.ExportEntry{
{
Type: "docker", // TODO: use containerd image store when it is integrated to Docker
Attrs: map[string]string{
"name": clicontext.String("tag"),
},
Output: func(_ map[string]string) (io.WriteCloser, error) {
return w, nil
},
},
},
LocalDirs: localDirs,
Frontend: frontend,
FrontendAttrs: frontendAttrs,
}, nil
}
func loadDockerTar(r io.Reader) error {
// no need to use moby/moby/client here
cmd := exec.Command("docker", "load")
cmd.Stdin = r
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
| action |
test_stock.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Tests for `mvport` package."""
import unittest
import numpy as np
from mvport.stock import Stock
class TestStock(unittest.TestCase):
"""Tests for `mvport` package."""
def setUp(self):
"""SetUp."""
self.ticker = 'AAPL'
self.returns = [-2, -1, 0, 1, 2]
self.stock = Stock(self.ticker, self.returns)
def test_get_ticker(self):
"""Test get_ticker."""
self.assertEqual(self.stock.get_ticker(), self.ticker)
def | (self):
"""Test set_ticker."""
self.stock.set_ticker('new_ticker')
self.assertEqual(self.stock.get_ticker(), 'new_ticker')
def test_get_returns(self):
"""Test get_returns."""
np.testing.assert_array_equal(self.stock.get_returns(), np.array(self.returns))
def test_set_returns(self):
"""Test set_ticker."""
self.stock.set_returns([-1, 0, 1])
np.testing.assert_array_equal(self.stock.get_returns(), np.array([-1, 0, 1]))
def test_get_mean(self):
"""Test get_mean."""
self.assertEqual(self.stock.get_mean(), 0)
self.stock.set_returns([0, 1, 2])
self.assertEqual(self.stock.get_mean(), 1)
def test_get_variance(self):
"""Test get_variance."""
self.assertEqual(self.stock.get_variance(), 2)
self.stock.set_returns([-3,-1,0,1,3])
self.assertEqual(self.stock.get_variance(), 4)
if __name__ == '__main__':
sys.exit(unittest.main())
| test_set_ticker |
measure.rs | //! Utils functions for measuring the PVN NFs.
use crate::utils::Flow;
use serde_json::{from_reader, Value};
use statrs::statistics::{Max, Mean, Median, Min};
use statrs::statistics::{OrderStatistics, Variance};
use std::collections::HashMap;
use std::fs::File;
use std::time::Instant;
/// Epsilon.
pub const EPSILON: usize = 1000;
/// Number of packets to ignore before starting measurement. Currently deprecated.
pub const NUM_TO_IGNORE: usize = 0;
/// Estimated number of packets for allocating large size array for RDR NF.
pub const RDR_MEASURED_PKT: usize = 100_000_000;
/// Estimated number of packets for allocating large size array.
pub const TOTAL_MEASURED_PKT: usize = 200_000_000;
/// Time for the short experiment with instrumentation.
pub const SHORT_MEASURE_TIME: u64 = 181;
/// Time for the medium experiment with instrumentation.
pub const MEDIUM_MEASURE_TIME: u64 = 301;
/// Time for the long experiment with instrumentation.
pub const LONG_MEASURE_TIME: u64 = 601;
/// Time for the application experiment.
pub const APP_MEASURE_TIME: u64 = 610;
/// Fake flow when retrieving flow failed.
pub fn fake_flow() -> Flow {
Flow {
src_ip: 0_u32,
dst_ip: 0_u32,
src_port: 0_u16,
dst_port: 0_u16,
proto: 0_u8,
}
}
/// experiment parameters.
#[derive(Debug, Clone, Copy)]
pub struct ExprParam {
/// setup (workload level)
pub setup: usize,
/// TLSV setup
pub tlsv_setup: usize,
/// RDR setup
pub rdr_setup: usize,
/// XCDR setup
pub xcdr_setup: usize,
/// P2P setup
pub p2p_setup: usize,
/// iteration of this run
pub iter: usize,
/// whether we have turned on latency instrumentation
pub inst: bool,
/// running experiment time
pub expr_time: u64,
}
/// Read various params from setup.
///
/// Currently returns: *setup* (which setup it is), *iter* (which iteration it
/// is), *inst* (instrumentation for retrieving latencies for every packet),
/// and *expr running time* (how long the NF will run).
///
/// This impl probably can be optimized.
pub fn read_setup_param(file_path: String) -> Option<ExprParam> {
let file = File::open(file_path.clone()).expect("file should open read only");
let read_json = file_path + "should be proper JSON";
let json: Value = from_reader(file).expect(&read_json);
let setup: Option<String> = match serde_json::from_value(json.get("setup").expect("file should have setup").clone())
{
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response for setup: {}", e);
None
}
};
let setup = setup.unwrap().parse::<usize>();
// setup all NF setups
let tlsv_setup: Option<String> =
match serde_json::from_value(json.get("tlsv_setup").expect("file could have tlsv setup").clone()) {
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response for tlsv_setup: {}", e);
None
}
};
let rdr_setup: Option<String> =
match serde_json::from_value(json.get("rdr_setup").expect("file should have rdr_setup").clone()) {
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response for rdr_setup: {}", e);
None
}
};
let xcdr_setup: Option<String> =
match serde_json::from_value(json.get("xcdr_setup").expect("file should have xcdr_setup").clone()) {
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response for xcdr_setup: {}", e);
None
}
};
let p2p_setup: Option<String> =
match serde_json::from_value(json.get("p2p_setup").expect("file should have p2p_setup").clone()) {
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response for p2p_setup: {}", e);
None
}
};
let tlsv_setup = tlsv_setup.unwrap().parse::<usize>();
let rdr_setup = rdr_setup.unwrap().parse::<usize>();
let xcdr_setup = xcdr_setup.unwrap().parse::<usize>();
let p2p_setup = p2p_setup.unwrap().parse::<usize>();
let iter: Option<String> = match serde_json::from_value(json.get("iter").expect("file should have iter").clone()) {
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response: {}", e);
None
}
};
let iter = iter.unwrap().parse::<usize>();
let inst: Option<String> = match serde_json::from_value(json.get("inst").expect("file should have inst").clone()) {
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response: {}", e);
None
}
};
let inst_val = match &*inst.unwrap() {
"on" => Some(true),
"off" => Some(false),
_ => None,
};
let mode: Option<String> = match serde_json::from_value(json.get("mode").expect("file should have mode").clone()) {
Ok(val) => Some(val),
Err(e) => {
println!("Malformed JSON response: {}", e);
None
}
};
let expr_time = match &*mode.unwrap() {
"short" => Some(SHORT_MEASURE_TIME),
"medium" => Some(MEDIUM_MEASURE_TIME),
"long" => Some(LONG_MEASURE_TIME),
_ => None,
};
if let (
Ok(setup),
Ok(tlsv_setup),
Ok(rdr_setup),
Ok(xcdr_setup),
Ok(p2p_setup),
Ok(iter),
Some(inst),
Some(expr_time),
) = (
setup, tlsv_setup, rdr_setup, xcdr_setup, p2p_setup, iter, inst_val, expr_time,
) {
Some(ExprParam {
setup,
tlsv_setup,
rdr_setup,
xcdr_setup,
p2p_setup,
iter,
inst,
expr_time,
})
} else {
None
}
}
/// Merge all the timestamps we have and generate meaningful latencies for each
/// packet.
///
/// The current implementation just works so please don't touch the code unless
/// you have time to verify the correctness.
pub fn merge_ts(
total_measured_pkt: usize,
stop_ts_matched: Vec<Instant>,
stop_ts_not_matched: HashMap<usize, Instant>,
) -> HashMap<usize, Instant> {
let mut actual_ts = HashMap::<usize, Instant>::with_capacity(total_measured_pkt);
let mut not_matched_c = 0;
for pivot in 1..total_measured_pkt + 1 {
if stop_ts_not_matched.contains_key(&pivot) { | not_matched_c += 1;
} else {
// NOTE: we need this early stop because of the drifting behavior in groupby operations
if pivot - not_matched_c - 1 == stop_ts_matched.len() {
println!("merging finished!",);
return actual_ts;
}
actual_ts.insert(pivot - 1, stop_ts_matched[pivot - not_matched_c - 1]);
}
}
println!("This should never be reached!",);
actual_ts
}
/// Compute statistics for the latency results collected.
pub fn compute_stat(mut tmp_results: Vec<u128>) {
tmp_results.sort_unstable();
let mut results: Vec<f64> = tmp_results.into_iter().map(|item| item as f64).collect();
let bar = results.percentile(99);
let (rest, mut main): (_, Vec<_>) = results.into_iter().partition(|x| x >= &bar);
println!("sorting and then type casting done",);
println!("Details of the results in rest",);
let rest_chunk_size = rest.len() / 100 + 1;
//generate 100 groups
for (rest_count, rest_chunk) in rest.chunks(rest_chunk_size).enumerate() {
println!(
"Rest_group {:?}, median: {:02?}, mean: {:02?}, std dev: {:02?}",
rest_count,
rest_chunk.median(),
rest_chunk.mean(),
rest_chunk.std_dev()
);
}
println!("Details of the results in main",);
let main_chunk_size = main.len() / 100 + 1;
//generate 100 groups
for (main_count, main_chunk) in main.chunks(main_chunk_size).enumerate() {
println!(
"Group {:?}, median: {:02?}, mean: {:02?}, std dev: {:02?}",
main_count,
main_chunk.median(),
main_chunk.mean(),
main_chunk.std_dev()
);
}
let min = main.min();
let max = main.max();
println!(
"Stat_extra, mean: {:?}, median: {:?}, std: {:?}, 90%iles: {:?}, 95%iles: {:?}, ",
main.mean(),
main.median(),
main.std_dev(),
main.percentile(90),
main.percentile(95),
);
println!(
"Stat, min: {:?}, 25%iles: {:?}, 50%iles: {:?}, 75%iles: {:?}, max: {:?}",
min,
main.percentile(25),
main.percentile(50),
main.percentile(75),
max,
);
} | // non tcp ts
let item = stop_ts_not_matched.get(&pivot).unwrap();
actual_ts.insert(pivot - 1, *item);
// println!("INSERT: pivot: {:?} is {:?}", pivot - 1, *item); |
map.rs | //! TODO: docs
use std::borrow::Borrow;
use std::fmt;
use std::iter::FromIterator;
use std::mem::ManuallyDrop;
use std::ops::{Bound, RangeBounds};
use std::ptr;
use base::{self, try_pin_loop};
use epoch;
/// A map based on a lock-free skip list.
pub struct SkipMap<K, V> {
inner: base::SkipList<K, V>,
}
impl<K, V> SkipMap<K, V> {
/// Returns a new, empty map.
pub fn new() -> SkipMap<K, V> {
SkipMap {
inner: base::SkipList::new(epoch::default_collector().clone()),
}
}
/// Returns `true` if the map is empty.
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
/// Returns the number of entries in the map.
///
/// If the map is being concurrently modified, consider the returned number just an
/// approximation without any guarantees.
pub fn len(&self) -> usize {
self.inner.len()
}
}
impl<K, V> SkipMap<K, V>
where
K: Ord,
{
/// Returns the entry with the smallest key.
pub fn front(&self) -> Option<Entry<K, V>> {
let guard = &epoch::pin();
try_pin_loop(|| self.inner.front(guard)).map(Entry::new)
}
/// Returns the entry with the largest key.
pub fn back(&self) -> Option<Entry<K, V>> {
let guard = &epoch::pin();
try_pin_loop(|| self.inner.back(guard)).map(Entry::new)
}
/// Returns `true` if the map contains a value for the specified key.
pub fn contains_key<Q>(&self, key: &Q) -> bool
where
K: Borrow<Q>,
Q: Ord + ?Sized,
{
let guard = &epoch::pin();
self.inner.contains_key(key, guard)
}
/// Returns an entry with the specified `key`.
pub fn get<Q>(&self, key: &Q) -> Option<Entry<K, V>>
where
K: Borrow<Q>,
Q: Ord + ?Sized,
{
let guard = &epoch::pin();
try_pin_loop(|| self.inner.get(key, guard)).map(Entry::new)
}
/// Returns an `Entry` pointing to the lowest element whose key is above
/// the given bound. If no such element is found then `None` is
/// returned.
pub fn lower_bound<'a, Q>(&'a self, bound: Bound<&Q>) -> Option<Entry<'a, K, V>>
where
K: Borrow<Q>,
Q: Ord + ?Sized,
{
let guard = &epoch::pin();
try_pin_loop(|| self.inner.lower_bound(bound, guard)).map(Entry::new)
}
/// Returns an `Entry` pointing to the highest element whose key is below
/// the given bound. If no such element is found then `None` is
/// returned.
pub fn upper_bound<'a, Q>(&'a self, bound: Bound<&Q>) -> Option<Entry<'a, K, V>>
where
K: Borrow<Q>,
Q: Ord + ?Sized,
{
let guard = &epoch::pin();
try_pin_loop(|| self.inner.upper_bound(bound, guard)).map(Entry::new)
}
/// Finds an entry with the specified key, or inserts a new `key`-`value` pair if none exist.
pub fn get_or_insert(&self, key: K, value: V) -> Entry<K, V> {
let guard = &epoch::pin();
Entry::new(self.inner.get_or_insert(key, value, guard))
}
/// Returns an iterator over all entries in the map.
pub fn iter(&self) -> Iter<K, V> {
Iter {
inner: self.inner.ref_iter(),
}
}
/// Returns an iterator over a subset of entries in the skip list.
pub fn range<Q, R>(&self, range: R) -> Range<'_, Q, R, K, V>
where
K: Borrow<Q>,
R: RangeBounds<Q>,
Q: Ord + ?Sized,
{
Range {
inner: self.inner.ref_range(range),
}
}
}
impl<K, V> SkipMap<K, V>
where
K: Ord + Send + 'static,
V: Send + 'static,
{
/// Inserts a `key`-`value` pair into the map and returns the new entry.
///
/// If there is an existing entry with this key, it will be removed before inserting the new
/// one.
pub fn insert(&self, key: K, value: V) -> Entry<K, V> {
let guard = &epoch::pin();
Entry::new(self.inner.insert(key, value, guard))
}
/// Removes an entry with the specified `key` from the map and returns it.
pub fn remove<Q>(&self, key: &Q) -> Option<Entry<K, V>>
where
K: Borrow<Q>,
Q: Ord + ?Sized,
{
let guard = &epoch::pin();
self.inner.remove(key, guard).map(Entry::new)
}
/// Removes an entry from the front of the map.
pub fn pop_front(&self) -> Option<Entry<K, V>> {
let guard = &epoch::pin();
self.inner.pop_front(guard).map(Entry::new)
}
/// Removes an entry from the back of the map.
pub fn pop_back(&self) -> Option<Entry<K, V>> {
let guard = &epoch::pin();
self.inner.pop_back(guard).map(Entry::new)
}
/// Iterates over the map and removes every entry.
pub fn clear(&self) {
let guard = &mut epoch::pin();
self.inner.clear(guard);
}
}
impl<K, V> Default for SkipMap<K, V> {
fn default() -> SkipMap<K, V> {
SkipMap::new()
}
}
impl<K, V> fmt::Debug for SkipMap<K, V>
where
K: Ord + fmt::Debug,
V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad("SkipMap { .. }")
}
}
impl<K, V> IntoIterator for SkipMap<K, V> {
type Item = (K, V);
type IntoIter = IntoIter<K, V>;
fn into_iter(self) -> IntoIter<K, V> {
IntoIter {
inner: self.inner.into_iter(),
}
}
}
impl<'a, K, V> IntoIterator for &'a SkipMap<K, V>
where
K: Ord,
{
type Item = Entry<'a, K, V>;
type IntoIter = Iter<'a, K, V>;
fn into_iter(self) -> Iter<'a, K, V> {
self.iter()
}
}
impl<K, V> FromIterator<(K, V)> for SkipMap<K, V>
where
K: Ord,
{
fn from_iter<I>(iter: I) -> SkipMap<K, V>
where
I: IntoIterator<Item = (K, V)>,
{
let s = SkipMap::new();
for (k, v) in iter {
s.get_or_insert(k, v);
}
s
}
}
/// A reference-counted entry in a map.
pub struct Entry<'a, K: 'a, V: 'a> {
inner: ManuallyDrop<base::RefEntry<'a, K, V>>,
}
impl<'a, K, V> Entry<'a, K, V> {
fn new(inner: base::RefEntry<'a, K, V>) -> Entry<'a, K, V> {
Entry {
inner: ManuallyDrop::new(inner),
}
}
/// Returns a reference to the key.
pub fn key(&self) -> &K {
self.inner.key()
}
/// Returns a reference to the value.
pub fn value(&self) -> &V {
self.inner.value()
}
/// Returns `true` if the entry is removed from the map.
pub fn is_removed(&self) -> bool {
self.inner.is_removed()
}
}
impl<'a, K, V> Drop for Entry<'a, K, V> {
fn drop(&mut self) {
unsafe {
ManuallyDrop::into_inner(ptr::read(&mut self.inner)).release_with_pin(epoch::pin);
}
}
}
impl<'a, K, V> Entry<'a, K, V>
where
K: Ord,
{
/// Moves to the next entry in the map.
pub fn move_next(&mut self) -> bool {
let guard = &epoch::pin();
self.inner.move_next(guard)
}
/// Moves to the previous entry in the map.
pub fn move_prev(&mut self) -> bool {
let guard = &epoch::pin();
self.inner.move_prev(guard)
}
/// Returns the next entry in the map.
pub fn next(&self) -> Option<Entry<'a, K, V>> {
let guard = &epoch::pin();
self.inner.next(guard).map(Entry::new)
}
/// Returns the previous entry in the map.
pub fn prev(&self) -> Option<Entry<'a, K, V>> {
let guard = &epoch::pin();
self.inner.prev(guard).map(Entry::new)
}
}
impl<'a, K, V> Entry<'a, K, V> | {
/// Removes the entry from the map.
///
/// Returns `true` if this call removed the entry and `false` if it was already removed.
pub fn remove(&self) -> bool {
let guard = &epoch::pin();
self.inner.remove(guard)
}
}
impl<'a, K, V> Clone for Entry<'a, K, V> {
fn clone(&self) -> Entry<'a, K, V> {
Entry {
inner: self.inner.clone(),
}
}
}
impl<'a, K, V> fmt::Debug for Entry<'a, K, V>
where
K: fmt::Debug,
V: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("Entry")
.field(self.key())
.field(self.value())
.finish()
}
}
/// An owning iterator over the entries of a `SkipMap`.
pub struct IntoIter<K, V> {
inner: base::IntoIter<K, V>,
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
fn next(&mut self) -> Option<(K, V)> {
self.inner.next()
}
}
impl<K, V> fmt::Debug for IntoIter<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad("IntoIter { .. }")
}
}
/// An iterator over the entries of a `SkipMap`.
pub struct Iter<'a, K: 'a, V: 'a> {
inner: base::RefIter<'a, K, V>,
}
impl<'a, K, V> Iterator for Iter<'a, K, V>
where
K: Ord,
{
type Item = Entry<'a, K, V>;
fn next(&mut self) -> Option<Entry<'a, K, V>> {
let guard = &epoch::pin();
self.inner.next(guard).map(Entry::new)
}
}
impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V>
where
K: Ord,
{
fn next_back(&mut self) -> Option<Entry<'a, K, V>> {
let guard = &epoch::pin();
self.inner.next_back(guard).map(Entry::new)
}
}
impl<'a, K, V> fmt::Debug for Iter<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad("Iter { .. }")
}
}
/// An iterator over the entries of a `SkipMap`.
pub struct Range<'a, Q, R, K: 'a, V: 'a>
where
K: Ord + Borrow<Q>,
R: RangeBounds<Q>,
Q: Ord + ?Sized,
{
pub(crate) inner: base::RefRange<'a, Q, R, K, V>,
}
impl<'a, Q, R, K, V> Iterator for Range<'a, Q, R, K, V>
where
K: Ord + Borrow<Q>,
R: RangeBounds<Q>,
Q: Ord + ?Sized,
{
type Item = Entry<'a, K, V>;
fn next(&mut self) -> Option<Entry<'a, K, V>> {
let guard = &epoch::pin();
self.inner.next(guard).map(Entry::new)
}
}
impl<'a, Q, R, K, V> DoubleEndedIterator for Range<'a, Q, R, K, V>
where
K: Ord + Borrow<Q>,
R: RangeBounds<Q>,
Q: Ord + ?Sized,
{
fn next_back(&mut self) -> Option<Entry<'a, K, V>> {
let guard = &epoch::pin();
self.inner.next_back(guard).map(Entry::new)
}
}
impl<'a, Q, R, K, V> fmt::Debug for Range<'a, Q, R, K, V>
where
K: Ord + Borrow<Q> + fmt::Debug,
V: fmt::Debug,
R: RangeBounds<Q> + fmt::Debug,
Q: Ord + ?Sized,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Range")
.field("range", &self.inner.range)
.field("head", &self.inner.head)
.field("tail", &self.inner.tail)
.finish()
}
} | where
K: Ord + Send + 'static,
V: Send + 'static, |
empresas.read.ts | import { Empresas as InputEmpresas } from '../empresas.entity';
export class ReadEmpresaDto extends PartialType(InputEmpresas) {} | import {OmitType,PartialType} from '@nestjs/swagger'; |
|
streaminfo.go | package meta
import (
"crypto/md5"
"errors"
"fmt"
"io"
"github.com/mewkiz/flac/internal/bits"
)
// StreamInfo contains the basic properties of a FLAC audio stream, such as its
// sample rate and channel count. It is the only mandatory metadata block and
// must be present as the first metadata block of a FLAC stream.
//
// ref: https://www.xiph.org/flac/format.html#metadata_block_streaminfo
type StreamInfo struct {
// Minimum block size (in samples) used in the stream; between 16 and 65535
// samples.
BlockSizeMin uint16
// Maximum block size (in samples) used in the stream; between 16 and 65535
// samples.
BlockSizeMax uint16
// Minimum frame size in bytes; a 0 value implies unknown.
FrameSizeMin uint32
// Maximum frame size in bytes; a 0 value implies unknown.
FrameSizeMax uint32
// Sample rate in Hz; between 1 and 655350 Hz.
SampleRate uint32
// Number of channels; between 1 and 8 channels.
NChannels uint8
// Sample size in bits-per-sample; between 4 and 32 bits.
BitsPerSample uint8
// Total number of inter-channel samples in the stream. One second of 44.1
// KHz audio will have 44100 samples regardless of the number of channels. A
// 0 value implies unknown.
NSamples uint64
// MD5 checksum of the unencoded audio data.
MD5sum [md5.Size]uint8
}
// parseStreamInfo reads and parses the body of a StreamInfo metadata block.
func (block *Block) parseStreamInfo() error {
// 16 bits: BlockSizeMin.
br := bits.NewReader(block.lr)
x, err := br.Read(16)
if err != nil {
return unexpected(err)
}
if x < 16 {
return fmt.Errorf("meta.Block.parseStreamInfo: invalid minimum block size (%d); expected >= 16", x)
}
si := new(StreamInfo)
block.Body = si
si.BlockSizeMin = uint16(x)
// 16 bits: BlockSizeMax.
x, err = br.Read(16)
if err != nil {
return unexpected(err)
}
if x < 16 {
return fmt.Errorf("meta.Block.parseStreamInfo: invalid maximum block size (%d); expected >= 16", x)
}
si.BlockSizeMax = uint16(x)
// 24 bits: FrameSizeMin.
x, err = br.Read(24)
if err != nil {
return unexpected(err)
}
si.FrameSizeMin = uint32(x)
// 24 bits: FrameSizeMax.
x, err = br.Read(24)
if err != nil |
si.FrameSizeMax = uint32(x)
// 20 bits: SampleRate.
x, err = br.Read(20)
if err != nil {
return unexpected(err)
}
if x == 0 {
return errors.New("meta.Block.parseStreamInfo: invalid sample rate (0)")
}
si.SampleRate = uint32(x)
// 3 bits: NChannels.
x, err = br.Read(3)
if err != nil {
return unexpected(err)
}
// x contains: (number of channels) - 1
si.NChannels = uint8(x + 1)
// 5 bits: BitsPerSample.
x, err = br.Read(5)
if err != nil {
return unexpected(err)
}
// x contains: (bits-per-sample) - 1
si.BitsPerSample = uint8(x + 1)
// 36 bits: NSamples.
si.NSamples, err = br.Read(36)
if err != nil {
return unexpected(err)
}
// 16 bytes: MD5sum.
_, err = io.ReadFull(block.lr, si.MD5sum[:])
return unexpected(err)
}
| {
return unexpected(err)
} |
i2s0.rs | #[doc = r"Register block"]
#[repr(C)]
pub struct RegisterBlock {
#[doc = "0x00 - WCLK Source Selection"]
pub aifwclksrc: AIFWCLKSRC,
#[doc = "0x04 - DMA Buffer Size Configuration"]
pub aifdmacfg: AIFDMACFG,
#[doc = "0x08 - Pin Direction"]
pub aifdircfg: AIFDIRCFG,
#[doc = "0x0c - Serial Interface Format Configuration"]
pub aiffmtcfg: AIFFMTCFG,
#[doc = "0x10 - Word Selection Bit Mask for Pin 0"]
pub aifwmask0: AIFWMASK0,
#[doc = "0x14 - Word Selection Bit Mask for Pin 1"]
pub aifwmask1: AIFWMASK1,
#[doc = "0x18 - Word Selection Bit Mask for Pin 2"]
pub aifwmask2: AIFWMASK2,
#[doc = "0x1c - Audio Interface PWM Debug Value"]
pub aifpwmvalue: AIFPWMVALUE,
#[doc = "0x20 - DMA Input Buffer Next Pointer"]
pub aifinptrnext: AIFINPTRNEXT,
#[doc = "0x24 - DMA Input Buffer Current Pointer"]
pub aifinptr: AIFINPTR,
#[doc = "0x28 - DMA Output Buffer Next Pointer"]
pub aifoutptrnext: AIFOUTPTRNEXT,
#[doc = "0x2c - DMA Output Buffer Current Pointer"]
pub aifoutptr: AIFOUTPTR,
_reserved12: [u8; 4usize],
#[doc = "0x34 - SampleStaMP Generator Control Register"]
pub stmpctl: STMPCTL,
#[doc = "0x38 - Captured XOSC Counter Value, Capture Channel 0"]
pub stmpxcntcapt0: STMPXCNTCAPT0,
#[doc = "0x3c - XOSC Period Value"]
pub stmpxper: STMPXPER,
#[doc = "0x40 - Captured WCLK Counter Value, Capture Channel 0"]
pub stmpwcntcapt0: STMPWCNTCAPT0,
#[doc = "0x44 - WCLK Counter Period Value"]
pub stmpwper: STMPWPER,
#[doc = "0x48 - WCLK Counter Trigger Value for Input Pins"]
pub stmpintrig: STMPINTRIG,
#[doc = "0x4c - WCLK Counter Trigger Value for Output Pins"]
pub stmpouttrig: STMPOUTTRIG,
#[doc = "0x50 - WCLK Counter Set Operation"]
pub stmpwset: STMPWSET,
#[doc = "0x54 - WCLK Counter Add Operation"]
pub stmpwadd: STMPWADD,
#[doc = "0x58 - XOSC Minimum Period Value Minimum Value of STMPXPER"]
pub stmpxpermin: STMPXPERMIN,
#[doc = "0x5c - Current Value of WCNT"]
pub stmpwcnt: STMPWCNT,
#[doc = "0x60 - Current Value of XCNT"]
pub stmpxcnt: STMPXCNT,
#[doc = "0x64 - Captured XOSC Counter Value, Capture Channel 1"]
pub stmpxcntcapt1: STMPXCNTCAPT1,
#[doc = "0x68 - Captured WCLK Counter Value, Capture Channel 1"]
pub stmpwcntcapt1: STMPWCNTCAPT1,
_reserved26: [u8; 4usize],
#[doc = "0x70 - Masked Interrupt Status Register"]
pub irqmask: IRQMASK,
#[doc = "0x74 - Raw Interrupt Status Register"]
pub irqflags: IRQFLAGS,
#[doc = "0x78 - Interrupt Set Register"]
pub irqset: IRQSET,
#[doc = "0x7c - Interrupt Clear Register"]
pub irqclr: IRQCLR,
}
#[doc = "WCLK Source Selection\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifwclksrc](aifwclksrc) module"]
pub type AIFWCLKSRC = crate::Reg<u32, _AIFWCLKSRC>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFWCLKSRC;
#[doc = "`read()` method returns [aifwclksrc::R](aifwclksrc::R) reader structure"]
impl crate::Readable for AIFWCLKSRC {}
#[doc = "`write(|w| ..)` method takes [aifwclksrc::W](aifwclksrc::W) writer structure"]
impl crate::Writable for AIFWCLKSRC {}
#[doc = "WCLK Source Selection"]
pub mod aifwclksrc;
#[doc = "DMA Buffer Size Configuration\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifdmacfg](aifdmacfg) module"]
pub type AIFDMACFG = crate::Reg<u32, _AIFDMACFG>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFDMACFG;
#[doc = "`read()` method returns [aifdmacfg::R](aifdmacfg::R) reader structure"]
impl crate::Readable for AIFDMACFG {}
#[doc = "`write(|w| ..)` method takes [aifdmacfg::W](aifdmacfg::W) writer structure"]
impl crate::Writable for AIFDMACFG {}
#[doc = "DMA Buffer Size Configuration"]
pub mod aifdmacfg;
#[doc = "Pin Direction\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifdircfg](aifdircfg) module"]
pub type AIFDIRCFG = crate::Reg<u32, _AIFDIRCFG>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFDIRCFG;
#[doc = "`read()` method returns [aifdircfg::R](aifdircfg::R) reader structure"]
impl crate::Readable for AIFDIRCFG {}
#[doc = "`write(|w| ..)` method takes [aifdircfg::W](aifdircfg::W) writer structure"]
impl crate::Writable for AIFDIRCFG {}
#[doc = "Pin Direction"]
pub mod aifdircfg;
#[doc = "Serial Interface Format Configuration\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aiffmtcfg](aiffmtcfg) module"]
pub type AIFFMTCFG = crate::Reg<u32, _AIFFMTCFG>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct | ;
#[doc = "`read()` method returns [aiffmtcfg::R](aiffmtcfg::R) reader structure"]
impl crate::Readable for AIFFMTCFG {}
#[doc = "`write(|w| ..)` method takes [aiffmtcfg::W](aiffmtcfg::W) writer structure"]
impl crate::Writable for AIFFMTCFG {}
#[doc = "Serial Interface Format Configuration"]
pub mod aiffmtcfg;
#[doc = "Word Selection Bit Mask for Pin 0\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifwmask0](aifwmask0) module"]
pub type AIFWMASK0 = crate::Reg<u32, _AIFWMASK0>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFWMASK0;
#[doc = "`read()` method returns [aifwmask0::R](aifwmask0::R) reader structure"]
impl crate::Readable for AIFWMASK0 {}
#[doc = "`write(|w| ..)` method takes [aifwmask0::W](aifwmask0::W) writer structure"]
impl crate::Writable for AIFWMASK0 {}
#[doc = "Word Selection Bit Mask for Pin 0"]
pub mod aifwmask0;
#[doc = "Word Selection Bit Mask for Pin 1\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifwmask1](aifwmask1) module"]
pub type AIFWMASK1 = crate::Reg<u32, _AIFWMASK1>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFWMASK1;
#[doc = "`read()` method returns [aifwmask1::R](aifwmask1::R) reader structure"]
impl crate::Readable for AIFWMASK1 {}
#[doc = "`write(|w| ..)` method takes [aifwmask1::W](aifwmask1::W) writer structure"]
impl crate::Writable for AIFWMASK1 {}
#[doc = "Word Selection Bit Mask for Pin 1"]
pub mod aifwmask1;
#[doc = "Word Selection Bit Mask for Pin 2\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifwmask2](aifwmask2) module"]
pub type AIFWMASK2 = crate::Reg<u32, _AIFWMASK2>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFWMASK2;
#[doc = "`read()` method returns [aifwmask2::R](aifwmask2::R) reader structure"]
impl crate::Readable for AIFWMASK2 {}
#[doc = "`write(|w| ..)` method takes [aifwmask2::W](aifwmask2::W) writer structure"]
impl crate::Writable for AIFWMASK2 {}
#[doc = "Word Selection Bit Mask for Pin 2"]
pub mod aifwmask2;
#[doc = "Audio Interface PWM Debug Value\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifpwmvalue](aifpwmvalue) module"]
pub type AIFPWMVALUE = crate::Reg<u32, _AIFPWMVALUE>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFPWMVALUE;
#[doc = "`read()` method returns [aifpwmvalue::R](aifpwmvalue::R) reader structure"]
impl crate::Readable for AIFPWMVALUE {}
#[doc = "`write(|w| ..)` method takes [aifpwmvalue::W](aifpwmvalue::W) writer structure"]
impl crate::Writable for AIFPWMVALUE {}
#[doc = "Audio Interface PWM Debug Value"]
pub mod aifpwmvalue;
#[doc = "DMA Input Buffer Next Pointer\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifinptrnext](aifinptrnext) module"]
pub type AIFINPTRNEXT = crate::Reg<u32, _AIFINPTRNEXT>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFINPTRNEXT;
#[doc = "`read()` method returns [aifinptrnext::R](aifinptrnext::R) reader structure"]
impl crate::Readable for AIFINPTRNEXT {}
#[doc = "`write(|w| ..)` method takes [aifinptrnext::W](aifinptrnext::W) writer structure"]
impl crate::Writable for AIFINPTRNEXT {}
#[doc = "DMA Input Buffer Next Pointer"]
pub mod aifinptrnext;
#[doc = "DMA Input Buffer Current Pointer\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifinptr](aifinptr) module"]
pub type AIFINPTR = crate::Reg<u32, _AIFINPTR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFINPTR;
#[doc = "`read()` method returns [aifinptr::R](aifinptr::R) reader structure"]
impl crate::Readable for AIFINPTR {}
#[doc = "`write(|w| ..)` method takes [aifinptr::W](aifinptr::W) writer structure"]
impl crate::Writable for AIFINPTR {}
#[doc = "DMA Input Buffer Current Pointer"]
pub mod aifinptr;
#[doc = "DMA Output Buffer Next Pointer\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifoutptrnext](aifoutptrnext) module"]
pub type AIFOUTPTRNEXT = crate::Reg<u32, _AIFOUTPTRNEXT>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFOUTPTRNEXT;
#[doc = "`read()` method returns [aifoutptrnext::R](aifoutptrnext::R) reader structure"]
impl crate::Readable for AIFOUTPTRNEXT {}
#[doc = "`write(|w| ..)` method takes [aifoutptrnext::W](aifoutptrnext::W) writer structure"]
impl crate::Writable for AIFOUTPTRNEXT {}
#[doc = "DMA Output Buffer Next Pointer"]
pub mod aifoutptrnext;
#[doc = "DMA Output Buffer Current Pointer\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [aifoutptr](aifoutptr) module"]
pub type AIFOUTPTR = crate::Reg<u32, _AIFOUTPTR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _AIFOUTPTR;
#[doc = "`read()` method returns [aifoutptr::R](aifoutptr::R) reader structure"]
impl crate::Readable for AIFOUTPTR {}
#[doc = "`write(|w| ..)` method takes [aifoutptr::W](aifoutptr::W) writer structure"]
impl crate::Writable for AIFOUTPTR {}
#[doc = "DMA Output Buffer Current Pointer"]
pub mod aifoutptr;
#[doc = "SampleStaMP Generator Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpctl](stmpctl) module"]
pub type STMPCTL = crate::Reg<u32, _STMPCTL>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPCTL;
#[doc = "`read()` method returns [stmpctl::R](stmpctl::R) reader structure"]
impl crate::Readable for STMPCTL {}
#[doc = "`write(|w| ..)` method takes [stmpctl::W](stmpctl::W) writer structure"]
impl crate::Writable for STMPCTL {}
#[doc = "SampleStaMP Generator Control Register"]
pub mod stmpctl;
#[doc = "Captured XOSC Counter Value, Capture Channel 0\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpxcntcapt0](stmpxcntcapt0) module"]
pub type STMPXCNTCAPT0 = crate::Reg<u32, _STMPXCNTCAPT0>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPXCNTCAPT0;
#[doc = "`read()` method returns [stmpxcntcapt0::R](stmpxcntcapt0::R) reader structure"]
impl crate::Readable for STMPXCNTCAPT0 {}
#[doc = "Captured XOSC Counter Value, Capture Channel 0"]
pub mod stmpxcntcapt0;
#[doc = "XOSC Period Value\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpxper](stmpxper) module"]
pub type STMPXPER = crate::Reg<u32, _STMPXPER>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPXPER;
#[doc = "`read()` method returns [stmpxper::R](stmpxper::R) reader structure"]
impl crate::Readable for STMPXPER {}
#[doc = "XOSC Period Value"]
pub mod stmpxper;
#[doc = "Captured WCLK Counter Value, Capture Channel 0\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpwcntcapt0](stmpwcntcapt0) module"]
pub type STMPWCNTCAPT0 = crate::Reg<u32, _STMPWCNTCAPT0>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPWCNTCAPT0;
#[doc = "`read()` method returns [stmpwcntcapt0::R](stmpwcntcapt0::R) reader structure"]
impl crate::Readable for STMPWCNTCAPT0 {}
#[doc = "Captured WCLK Counter Value, Capture Channel 0"]
pub mod stmpwcntcapt0;
#[doc = "WCLK Counter Period Value\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpwper](stmpwper) module"]
pub type STMPWPER = crate::Reg<u32, _STMPWPER>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPWPER;
#[doc = "`read()` method returns [stmpwper::R](stmpwper::R) reader structure"]
impl crate::Readable for STMPWPER {}
#[doc = "`write(|w| ..)` method takes [stmpwper::W](stmpwper::W) writer structure"]
impl crate::Writable for STMPWPER {}
#[doc = "WCLK Counter Period Value"]
pub mod stmpwper;
#[doc = "WCLK Counter Trigger Value for Input Pins\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpintrig](stmpintrig) module"]
pub type STMPINTRIG = crate::Reg<u32, _STMPINTRIG>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPINTRIG;
#[doc = "`read()` method returns [stmpintrig::R](stmpintrig::R) reader structure"]
impl crate::Readable for STMPINTRIG {}
#[doc = "`write(|w| ..)` method takes [stmpintrig::W](stmpintrig::W) writer structure"]
impl crate::Writable for STMPINTRIG {}
#[doc = "WCLK Counter Trigger Value for Input Pins"]
pub mod stmpintrig;
#[doc = "WCLK Counter Trigger Value for Output Pins\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpouttrig](stmpouttrig) module"]
pub type STMPOUTTRIG = crate::Reg<u32, _STMPOUTTRIG>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPOUTTRIG;
#[doc = "`read()` method returns [stmpouttrig::R](stmpouttrig::R) reader structure"]
impl crate::Readable for STMPOUTTRIG {}
#[doc = "`write(|w| ..)` method takes [stmpouttrig::W](stmpouttrig::W) writer structure"]
impl crate::Writable for STMPOUTTRIG {}
#[doc = "WCLK Counter Trigger Value for Output Pins"]
pub mod stmpouttrig;
#[doc = "WCLK Counter Set Operation\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpwset](stmpwset) module"]
pub type STMPWSET = crate::Reg<u32, _STMPWSET>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPWSET;
#[doc = "`read()` method returns [stmpwset::R](stmpwset::R) reader structure"]
impl crate::Readable for STMPWSET {}
#[doc = "`write(|w| ..)` method takes [stmpwset::W](stmpwset::W) writer structure"]
impl crate::Writable for STMPWSET {}
#[doc = "WCLK Counter Set Operation"]
pub mod stmpwset;
#[doc = "WCLK Counter Add Operation\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpwadd](stmpwadd) module"]
pub type STMPWADD = crate::Reg<u32, _STMPWADD>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPWADD;
#[doc = "`read()` method returns [stmpwadd::R](stmpwadd::R) reader structure"]
impl crate::Readable for STMPWADD {}
#[doc = "`write(|w| ..)` method takes [stmpwadd::W](stmpwadd::W) writer structure"]
impl crate::Writable for STMPWADD {}
#[doc = "WCLK Counter Add Operation"]
pub mod stmpwadd;
#[doc = "XOSC Minimum Period Value Minimum Value of STMPXPER\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpxpermin](stmpxpermin) module"]
pub type STMPXPERMIN = crate::Reg<u32, _STMPXPERMIN>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPXPERMIN;
#[doc = "`read()` method returns [stmpxpermin::R](stmpxpermin::R) reader structure"]
impl crate::Readable for STMPXPERMIN {}
#[doc = "`write(|w| ..)` method takes [stmpxpermin::W](stmpxpermin::W) writer structure"]
impl crate::Writable for STMPXPERMIN {}
#[doc = "XOSC Minimum Period Value Minimum Value of STMPXPER"]
pub mod stmpxpermin;
#[doc = "Current Value of WCNT\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpwcnt](stmpwcnt) module"]
pub type STMPWCNT = crate::Reg<u32, _STMPWCNT>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPWCNT;
#[doc = "`read()` method returns [stmpwcnt::R](stmpwcnt::R) reader structure"]
impl crate::Readable for STMPWCNT {}
#[doc = "Current Value of WCNT"]
pub mod stmpwcnt;
#[doc = "Current Value of XCNT\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpxcnt](stmpxcnt) module"]
pub type STMPXCNT = crate::Reg<u32, _STMPXCNT>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPXCNT;
#[doc = "`read()` method returns [stmpxcnt::R](stmpxcnt::R) reader structure"]
impl crate::Readable for STMPXCNT {}
#[doc = "Current Value of XCNT"]
pub mod stmpxcnt;
#[doc = "Captured XOSC Counter Value, Capture Channel 1\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpxcntcapt1](stmpxcntcapt1) module"]
pub type STMPXCNTCAPT1 = crate::Reg<u32, _STMPXCNTCAPT1>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPXCNTCAPT1;
#[doc = "`read()` method returns [stmpxcntcapt1::R](stmpxcntcapt1::R) reader structure"]
impl crate::Readable for STMPXCNTCAPT1 {}
#[doc = "Captured XOSC Counter Value, Capture Channel 1"]
pub mod stmpxcntcapt1;
#[doc = "Captured WCLK Counter Value, Capture Channel 1\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [stmpwcntcapt1](stmpwcntcapt1) module"]
pub type STMPWCNTCAPT1 = crate::Reg<u32, _STMPWCNTCAPT1>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _STMPWCNTCAPT1;
#[doc = "`read()` method returns [stmpwcntcapt1::R](stmpwcntcapt1::R) reader structure"]
impl crate::Readable for STMPWCNTCAPT1 {}
#[doc = "Captured WCLK Counter Value, Capture Channel 1"]
pub mod stmpwcntcapt1;
#[doc = "Masked Interrupt Status Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irqmask](irqmask) module"]
pub type IRQMASK = crate::Reg<u32, _IRQMASK>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _IRQMASK;
#[doc = "`read()` method returns [irqmask::R](irqmask::R) reader structure"]
impl crate::Readable for IRQMASK {}
#[doc = "`write(|w| ..)` method takes [irqmask::W](irqmask::W) writer structure"]
impl crate::Writable for IRQMASK {}
#[doc = "Masked Interrupt Status Register"]
pub mod irqmask;
#[doc = "Raw Interrupt Status Register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irqflags](irqflags) module"]
pub type IRQFLAGS = crate::Reg<u32, _IRQFLAGS>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _IRQFLAGS;
#[doc = "`read()` method returns [irqflags::R](irqflags::R) reader structure"]
impl crate::Readable for IRQFLAGS {}
#[doc = "Raw Interrupt Status Register"]
pub mod irqflags;
#[doc = "Interrupt Set Register\n\nThis register you can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irqset](irqset) module"]
pub type IRQSET = crate::Reg<u32, _IRQSET>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _IRQSET;
#[doc = "`write(|w| ..)` method takes [irqset::W](irqset::W) writer structure"]
impl crate::Writable for IRQSET {}
#[doc = "Interrupt Set Register"]
pub mod irqset;
#[doc = "Interrupt Clear Register\n\nThis register you can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [irqclr](irqclr) module"]
pub type IRQCLR = crate::Reg<u32, _IRQCLR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _IRQCLR;
#[doc = "`write(|w| ..)` method takes [irqclr::W](irqclr::W) writer structure"]
impl crate::Writable for IRQCLR {}
#[doc = "Interrupt Clear Register"]
pub mod irqclr;
| _AIFFMTCFG |
MiniSearch.ts | import SearchableMap from './SearchableMap/SearchableMap'
const OR = 'or'
const AND = 'and'
const AND_NOT = 'and_not'
/**
* Search options to customize the search behavior.
*/
export type SearchOptions = {
/**
* Names of the fields to search in. If omitted, all fields are searched.
*/
fields?: string[],
/**
* Function used to filter search results, for example on the basis of stored
* fields. It takes as argument each search result and should return a boolean
* to indicate if the result should be kept or not.
*/
filter?: (result: SearchResult) => boolean,
/**
* Key-value object of field names to boosting values. By default, fields are
* assigned a boosting factor of 1. If one assigns to a field a boosting value
* of 2, a result that matches the query in that field is assigned a score
* twice as high as a result matching the query in another field, all else
* being equal.
*/
boost?: { [fieldName: string]: number },
/**
* Relative weights to assign to prefix search results and fuzzy search
* results. Exact matches are assigned a weight of 1.
*/
weights?: { fuzzy: number, prefix: number },
/**
* Function to calculate a boost factor for documents. It takes as arguments
* the document ID, and a term that matches the search in that document, and
* should return a boosting factor.
*/
boostDocument?: (documentId: any, term: string) => number,
/**
* Controls whether to perform prefix search. It can be a simple boolean, or a
* function.
*
* If a boolean is passed, prefix search is performed if true.
*
* If a function is passed, it is called upon search with a search term, the
* positional index of that search term in the tokenized search query, and the
* tokenized search query. The function should return a boolean to indicate
* whether to perform prefix search for that search term.
*/
prefix?: boolean | ((term: string, index: number, terms: string[]) => boolean),
/**
* Controls whether to perform fuzzy search. It can be a simple boolean, or a
* number, or a function.
*
* If a boolean is given, fuzzy search with a default fuzziness parameter is
* performed if true.
*
* If a number higher or equal to 1 is given, fuzzy search is performed, with
* a mazimum edit distance (Levenshtein) equal to the number.
*
* If a number between 0 and 1 is given, fuzzy search is performed within a
* maximum edit distance corresponding to that fraction of the term length,
* approximated to the nearest integer. For example, 0.2 would mean an edit
* distance of 20% of the term length, so 1 character in a 5-characters term.
*
* If a function is passed, the function is called upon search with a search
* term, a positional index of that term in the tokenized search query, and
* the tokenized search query. It should return a boolean or a number, with
* the meaning documented above.
*/
fuzzy?: boolean | number | ((term: string, index: number, terms: string[]) => boolean | number),
/**
* The operand to combine partial results for each term. By default it is
* "OR", so results matching _any_ of the search terms are returned by a
* search. If "AND" is given, only results matching _all_ the search terms are
* returned by a search.
*/
combineWith?: string,
/**
* Function to tokenize the search query. By default, the same tokenizer used
* for indexing is used also for search.
*/
tokenize?: (text: string) => string[],
/**
* Function to process or normalize terms in the search query. By default, the
* same term processor used for indexing is used also for search.
*/
processTerm?: (term: string) => string | null | undefined | false
}
type SearchOptionsWithDefaults = SearchOptions & {
boost: { [fieldName: string]: number },
weights: { fuzzy: number, prefix: number },
prefix: boolean | ((term: string, index: number, terms: string[]) => boolean),
fuzzy: boolean | number | ((term: string, index: number, terms: string[]) => boolean | number),
combineWith: string
}
/**
* Configuration options passed to the [[MiniSearch]] constructor
*
* @typeParam T The type of documents being indexed.
*/
export type Options<T = any> = {
/**
* Names of the document fields to be indexed.
*/
fields: string[],
/**
* Name of the ID field, uniquely identifying a document.
*/
idField?: string,
/**
* Names of fields to store, so that search results would include them. By
* default none, so resuts would only contain the id field.
*/
storeFields?: string[],
/**
* Function used to extract the value of each field in documents. By default,
* the documents are assumed to be plain objects with field names as keys,
* but by specifying a custom `extractField` function one can completely
* customize how the fields are extracted.
*
* The function takes as arguments the document, and the name of the field to
* extract from it. It should return the field value as a string.
*/
extractField?: (document: T, fieldName: string) => string,
/*
* Function used to split a field value into individual terms to be indexed.
* The default tokenizer separates terms by space or punctuation, but a
* custom tokenizer can be provided for custom logic.
*
* The function takes as arguments string to tokenize, and the name of the
* field it comes from. It should return the terms as an array of strings.
* When used for tokenizing a search query instead of a document field, the
* `fieldName` is undefined.
*/
tokenize?: (text: string, fieldName?: string) => string[],
/**
* Function used to process a term before indexing or search. This can be
* used for normalization (such as stemming). By default, terms are
* downcased, and otherwise no other normalization is performed.
*
* The function takes as arguments a term to process, and the name of the
* field it comes from. It should return the processed term as a string, or a
* falsy value to reject the term entirely.
*/
processTerm?: (term: string, fieldName?: string) => string | null | undefined | false,
/**
* Default search options (see the [[SearchOptions]] type and the
* [[MiniSearch.search]] method for details)
*/
searchOptions?: SearchOptions
}
type OptionsWithDefaults<T = any> = Options<T> & {
storeFields: string[],
idField: string,
extractField: (document: T, fieldName: string) => string,
tokenize: (text: string, fieldName: string) => string[],
processTerm: (term: string, fieldName: string) => string | null | undefined | false,
searchOptions: SearchOptionsWithDefaults
}
/**
* The type of auto-suggestions
*/
export type Suggestion = {
/**
* The suggestion
*/
suggestion: string,
/**
* Suggestion as an array of terms
*/
terms: string[],
/**
* Score for the suggestion
*/
score: number
}
/**
* Match information for a search result. It is a key-value object where keys
* are terms that matched, and values are the list of fields that the term was
* found in.
*/
export type MatchInfo = {
[term: string]: string[]
}
/**
* Type of the search results. Each search result indicates the document ID, the
* terms that matched, the match information, the score, and all the stored
* fields.
*/
export type SearchResult = {
/**
* The document ID
*/
id: any,
/**
* List of terms that matched
*/
terms: string[],
/**
* Score of the search results
*/
score: number,
/**
* Match information, see [[MatchInfo]]
*/
match: MatchInfo,
/**
* Stored fields
*/
[key: string]: any
}
/**
* @ignore
*/
export type AsPlainObject = {
index: { _tree: {}, _prefix: string },
documentCount: number,
nextId: number,
documentIds: { [shortId: string]: any }
fieldIds: { [fieldName: string]: number }
fieldLength: { [shortId: string]: { [fieldId: string]: number } },
averageFieldLength: { [fieldId: string]: number },
storedFields: { [shortId: string]: any }
}
export type QueryCombination = SearchOptions & { queries: Query[] }
/**
* Search query expression, either a query string or an expression tree
* combining several queries with a combination of AND or OR.
*/
export type Query = QueryCombination | string
type QuerySpec = {
prefix: boolean,
fuzzy: number | boolean,
term: string
}
type IndexData = {
[fieldId: string]: { df: number, ds: { [shortId: string]: number } }
}
type RawResult = {
[shortId: string]: { score: number, match: MatchInfo, terms: string[] }
}
/**
* [[MiniSearch]] is the main entrypoint class, implementing a full-text search
* engine in memory.
*
* @typeParam T The type of the documents being indexed.
*
* ### Basic example:
*
* ```javascript
* const documents = [
* {
* id: 1,
* title: 'Moby Dick',
* text: 'Call me Ishmael. Some years ago...',
* category: 'fiction'
* },
* {
* id: 2,
* title: 'Zen and the Art of Motorcycle Maintenance',
* text: 'I can see by my watch...',
* category: 'fiction'
* },
* {
* id: 3,
* title: 'Neuromancer',
* text: 'The sky above the port was...',
* category: 'fiction'
* },
* {
* id: 4,
* title: 'Zen and the Art of Archery',
* text: 'At first sight it must seem...',
* category: 'non-fiction'
* },
* // ...and more
* ]
*
* // Create a search engine that indexes the 'title' and 'text' fields for
* // full-text search. Search results will include 'title' and 'category' (plus the
* // id field, that is always stored and returned)
* const miniSearch = new MiniSearch({
* fields: ['title', 'text'],
* storeFields: ['title', 'category']
* })
*
* // Add documents to the index
* miniSearch.addAll(documents)
*
* // Search for documents:
* let results = miniSearch.search('zen art motorcycle')
* // => [
* // { id: 2, title: 'Zen and the Art of Motorcycle Maintenance', category: 'fiction', score: 2.77258 },
* // { id: 4, title: 'Zen and the Art of Archery', category: 'non-fiction', score: 1.38629 }
* // ]
* ```
*/
export default class | <T = any> {
protected _options: OptionsWithDefaults<T>
protected _index: SearchableMap
protected _documentCount: number
protected _documentIds: { [shortId: string]: any }
protected _fieldIds: { [fieldName: string]: number }
protected _fieldLength: { [shortId: string]: { [fieldId: string]: number } }
protected _averageFieldLength: { [fieldId: string]: number }
protected _nextId: number
protected _storedFields: { [shortId: string]: any }
/**
* @param options Configuration options
*
* ### Examples:
*
* ```javascript
* // Create a search engine that indexes the 'title' and 'text' fields of your
* // documents:
* const miniSearch = new MiniSearch({ fields: ['title', 'text'] })
* ```
*
* ### ID Field:
*
* ```javascript
* // Your documents are assumed to include a unique 'id' field, but if you want
* // to use a different field for document identification, you can set the
* // 'idField' option:
* const miniSearch = new MiniSearch({ idField: 'key', fields: ['title', 'text'] })
* ```
*
* ### Options and defaults:
*
* ```javascript
* // The full set of options (here with their default value) is:
* const miniSearch = new MiniSearch({
* // idField: field that uniquely identifies a document
* idField: 'id',
*
* // extractField: function used to get the value of a field in a document.
* // By default, it assumes the document is a flat object with field names as
* // property keys and field values as string property values, but custom logic
* // can be implemented by setting this option to a custom extractor function.
* extractField: (document, fieldName) => document[fieldName],
*
* // tokenize: function used to split fields into individual terms. By
* // default, it is also used to tokenize search queries, unless a specific
* // `tokenize` search option is supplied. When tokenizing an indexed field,
* // the field name is passed as the second argument.
* tokenize: (string, _fieldName) => string.split(SPACE_OR_PUNCTUATION),
*
* // processTerm: function used to process each tokenized term before
* // indexing. It can be used for stemming and normalization. Return a falsy
* // value in order to discard a term. By default, it is also used to process
* // search queries, unless a specific `processTerm` option is supplied as a
* // search option. When processing a term from a indexed field, the field
* // name is passed as the second argument.
* processTerm: (term, _fieldName) => term.toLowerCase(),
*
* // searchOptions: default search options, see the `search` method for
* // details
* searchOptions: undefined,
*
* // fields: document fields to be indexed. Mandatory, but not set by default
* fields: undefined
*
* // storeFields: document fields to be stored and returned as part of the
* // search results.
* storeFields: []
* })
* ```
*/
constructor (options: Options<T>) {
if (options?.fields == null) {
throw new Error('MiniSearch: option "fields" must be provided')
}
this._options = {
...defaultOptions,
...options,
searchOptions: { ...defaultSearchOptions, ...(options.searchOptions || {}) }
}
this._index = new SearchableMap()
this._documentCount = 0
this._documentIds = {}
this._fieldIds = {}
this._fieldLength = {}
this._averageFieldLength = {}
this._nextId = 0
this._storedFields = {}
this.addFields(this._options.fields)
}
/**
* Adds a document to the index
*
* @param document The document to be indexed
*/
add (document: T): void {
const { extractField, tokenize, processTerm, fields, idField } = this._options
const id = extractField(document, idField)
if (id == null) {
throw new Error(`MiniSearch: document does not have ID field "${idField}"`)
}
const shortDocumentId = this.addDocumentId(id)
this.saveStoredFields(shortDocumentId, document)
fields.forEach(field => {
const fieldValue = extractField(document, field)
if (fieldValue == null) { return }
const tokens = tokenize(fieldValue.toString(), field)
this.addFieldLength(shortDocumentId, this._fieldIds[field], this.documentCount - 1, tokens.length)
tokens.forEach(term => {
const processedTerm = processTerm(term, field)
if (processedTerm) {
this.addTerm(this._fieldIds[field], shortDocumentId, processedTerm)
}
})
})
}
/**
* Adds all the given documents to the index
*
* @param documents An array of documents to be indexed
*/
addAll (documents: T[]): void {
documents.forEach(document => this.add(document))
}
/**
* Adds all the given documents to the index asynchronously.
*
* Returns a promise that resolves (to `undefined`) when the indexing is done.
* This method is useful when index many documents, to avoid blocking the main
* thread. The indexing is performed asynchronously and in chunks.
*
* @param documents An array of documents to be indexed
* @param options Configuration options
* @return A promise resolving to `undefined` when the indexing is done
*/
addAllAsync (documents: T[], options: { chunkSize?: number } = {}): Promise<void> {
const { chunkSize = 10 } = options
const acc: { chunk: T[], promise: Promise<void> } = { chunk: [], promise: Promise.resolve() }
const { chunk, promise } = documents.reduce(({ chunk, promise }, document: T, i: number) => {
chunk.push(document)
if ((i + 1) % chunkSize === 0) {
return {
chunk: [],
promise: promise
.then(() => new Promise(resolve => setTimeout(resolve, 0)))
.then(() => this.addAll(chunk))
}
} else {
return { chunk, promise }
}
}, acc)
return promise.then(() => this.addAll(chunk))
}
/**
* Removes the given document from the index.
*
* The document to delete must NOT have changed between indexing and deletion,
* otherwise the index will be corrupted. Therefore, when reindexing a document
* after a change, the correct order of operations is:
*
* 1. remove old version
* 2. apply changes
* 3. index new version
*
* @param document The document to be removed
*/
remove (document: T): void {
const { tokenize, processTerm, extractField, fields, idField } = this._options
const id = extractField(document, idField)
if (id == null) {
throw new Error(`MiniSearch: document does not have ID field "${idField}"`)
}
const [shortDocumentId] = Object.entries(this._documentIds)
.find(([_, longId]) => id === longId) || []
if (shortDocumentId == null) {
throw new Error(`MiniSearch: cannot remove document with ID ${id}: it is not in the index`)
}
fields.forEach(field => {
const fieldValue = extractField(document, field)
if (fieldValue == null) { return }
const tokens = tokenize(fieldValue.toString(), field)
tokens.forEach(term => {
const processedTerm = processTerm(term, field)
if (processedTerm) {
this.removeTerm(this._fieldIds[field], shortDocumentId, processedTerm)
}
})
this.removeFieldLength(shortDocumentId, this._fieldIds[field], this.documentCount, tokens.length)
})
delete this._storedFields[shortDocumentId]
delete this._documentIds[shortDocumentId]
delete this._fieldLength[shortDocumentId]
this._documentCount -= 1
}
/**
* Removes all the given documents from the index. If called with no arguments,
* it removes _all_ documents from the index.
*
* @param documents The documents to be removed. If this argument is omitted,
* all documents are removed. Note that, for removing all documents, it is
* more efficient to call this method with no arguments than to pass all
* documents.
*/
removeAll (documents?: T[]): void {
if (documents) {
documents.forEach(document => this.remove(document))
} else if (arguments.length > 0) {
throw new Error('Expected documents to be present. Omit the argument to remove all documents.')
} else {
this._index = new SearchableMap()
this._documentCount = 0
this._documentIds = {}
this._fieldLength = {}
this._averageFieldLength = {}
this._storedFields = {}
this._nextId = 0
}
}
/**
* Search for documents matching the given search query.
*
* The result is a list of scored document IDs matching the query, sorted by
* descending score, and each including data about which terms were matched and
* in which fields.
*
* ### Basic usage:
*
* ```javascript
* // Search for "zen art motorcycle" with default options: terms have to match
* // exactly, and individual terms are joined with OR
* miniSearch.search('zen art motorcycle')
* // => [ { id: 2, score: 2.77258, match: { ... } }, { id: 4, score: 1.38629, match: { ... } } ]
* ```
*
* ### Restrict search to specific fields:
*
* ```javascript
* // Search only in the 'title' field
* miniSearch.search('zen', { fields: ['title'] })
* ```
*
* ### Field boosting:
*
* ```javascript
* // Boost a field
* miniSearch.search('zen', { boost: { title: 2 } })
* ```
*
* ### Prefix search:
*
* ```javascript
* // Search for "moto" with prefix search (it will match documents
* // containing terms that start with "moto" or "neuro")
* miniSearch.search('moto neuro', { prefix: true })
* ```
*
* ### Fuzzy search:
*
* ```javascript
* // Search for "ismael" with fuzzy search (it will match documents containing
* // terms similar to "ismael", with a maximum edit distance of 0.2 term.length
* // (rounded to nearest integer)
* miniSearch.search('ismael', { fuzzy: 0.2 })
* ```
*
* ### Combining strategies:
*
* ```javascript
* // Mix of exact match, prefix search, and fuzzy search
* miniSearch.search('ismael mob', {
* prefix: true,
* fuzzy: 0.2
* })
* ```
*
* ### Advanced prefix and fuzzy search:
*
* ```javascript
* // Perform fuzzy and prefix search depending on the search term. Here
* // performing prefix and fuzzy search only on terms longer than 3 characters
* miniSearch.search('ismael mob', {
* prefix: term => term.length > 3
* fuzzy: term => term.length > 3 ? 0.2 : null
* })
* ```
*
* ### Combine with AND:
*
* ```javascript
* // Combine search terms with AND (to match only documents that contain both
* // "motorcycle" and "art")
* miniSearch.search('motorcycle art', { combineWith: 'AND' })
* ```
*
* ### Combine with AND_NOT:
*
* There is also an AND_NOT combinator, that finds documents that match the
* first term, but do not match any of the other terms. This combinator is
* rarely useful with simple queries, and is meant to be used with advanced
* query combinations (see later for more details).
*
* ### Filtering results:
*
* ```javascript
* // Filter only results in the 'fiction' category (assuming that 'category'
* // is a stored field)
* miniSearch.search('motorcycle art', {
* filter: (result) => result.category === 'fiction'
* })
* ```
*
* ### Advanced combination of queries:
*
* It is possible to combine different subqueries with OR, AND, and AND_NOT,
* and even with different search options, by passing a query expression
* tree object as the first argument, instead of a string.
*
* ```javascript
* // Search for documents that contain "zen" and ("motorcycle" or "archery")
* miniSearch.search({
* combineWith: 'AND',
* queries: [
* 'zen',
* {
* combineWith: 'OR',
* queries: ['motorcycle', 'archery']
* }
* ]
* })
*
* // Search for documents that contain ("apple" or "pear") but not "juice" and
* // not "tree"
* miniSearch.search({
* combineWith: 'AND_NOT',
* queries: [
* {
* combineWith: 'OR',
* queries: ['apple', 'pear']
* },
* 'juice',
* 'tree'
* ]
* })
* ```
*
* Each node in the expression tree can be either a string, or an object that
* supports all `SearchOptions` fields, plus a `queries` array field for
* subqueries.
*
* Note that, while this can become complicated to do by hand for complex or
* deeply nested queries, it provides a formalized expression tree API for
* external libraries that implement a parser for custom query languages.
*
* @param query Search query
* @param options Search options. Each option, if not given, defaults to the corresponding value of `searchOptions` given to the constructor, or to the library default.
*/
search (query: Query, searchOptions: SearchOptions = {}): SearchResult[] {
const combinedResults = this.executeQuery(query, searchOptions)
return Object.entries(combinedResults)
.reduce((results: SearchResult[], [docId, { score, match, terms }]) => {
const result = {
id: this._documentIds[docId],
terms: uniq(terms),
score,
match
}
Object.assign(result, this._storedFields[docId])
if (searchOptions.filter == null || searchOptions.filter(result)) {
results.push(result)
}
return results
}, [])
.sort(({ score: a }, { score: b }) => a < b ? 1 : -1)
}
/**
* Provide suggestions for the given search query
*
* The result is a list of suggested modified search queries, derived from the
* given search query, each with a relevance score, sorted by descending score.
*
* ### Basic usage:
*
* ```javascript
* // Get suggestions for 'neuro':
* miniSearch.autoSuggest('neuro')
* // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 0.46240 } ]
* ```
*
* ### Multiple words:
*
* ```javascript
* // Get suggestions for 'zen ar':
* miniSearch.autoSuggest('zen ar')
* // => [
* // { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
* // { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
* // ]
* ```
*
* ### Fuzzy suggestions:
*
* ```javascript
* // Correct spelling mistakes using fuzzy search:
* miniSearch.autoSuggest('neromancer', { fuzzy: 0.2 })
* // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 1.03998 } ]
* ```
*
* ### Filtering:
*
* ```javascript
* // Get suggestions for 'zen ar', but only within the 'fiction' category
* // (assuming that 'category' is a stored field):
* miniSearch.autoSuggest('zen ar', {
* filter: (result) => result.category === 'fiction'
* })
* // => [
* // { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
* // { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
* // ]
* ```
*
* @param queryString Query string to be expanded into suggestions
* @param options Search options. The supported options and default values
* are the same as for the `search` method, except that by default prefix
* search is performed on the last term in the query.
* @return A sorted array of suggestions sorted by relevance score.
*/
autoSuggest (queryString: string, options: SearchOptions = {}): Suggestion[] {
options = { ...defaultAutoSuggestOptions, ...options }
const suggestions = this.search(queryString, options).reduce((
suggestions: { [phrase: string]: Omit<Suggestion, 'suggestion'> & { count: number } },
{ score, terms }
) => {
const phrase = terms.join(' ')
if (suggestions[phrase] == null) {
suggestions[phrase] = { score, terms, count: 1 }
} else {
suggestions[phrase].score += score
suggestions[phrase].count += 1
}
return suggestions
}, {})
return Object.entries(suggestions)
.map(([suggestion, { score, terms, count }]) => ({ suggestion, terms, score: score / count }))
.sort(({ score: a }, { score: b }) => a < b ? 1 : -1)
}
/**
* Number of documents in the index
*/
get documentCount (): number {
return this._documentCount
}
/**
* Deserializes a JSON index (serialized with `miniSearch.toJSON()`) and
* instantiates a MiniSearch instance. It should be given the same options
* originally used when serializing the index.
*
* ### Usage:
*
* ```javascript
* // If the index was serialized with:
* let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
* miniSearch.addAll(documents)
*
* const json = JSON.stringify(miniSearch)
* // It can later be deserialized like this:
* miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
* ```
*
* @param json JSON-serialized index
* @param options configuration options, same as the constructor
* @return An instance of MiniSearch deserialized from the given JSON.
*/
static loadJSON<T = any> (json: string, options: Options<T>): MiniSearch<T> {
if (options == null) {
throw new Error('MiniSearch: loadJSON should be given the same options used when serializing the index')
}
return MiniSearch.loadJS(JSON.parse(json), options)
}
/**
* Returns the default value of an option. It will throw an error if no option
* with the given name exists.
*
* @param optionName Name of the option
* @return The default value of the given option
*
* ### Usage:
*
* ```javascript
* // Get default tokenizer
* MiniSearch.getDefault('tokenize')
*
* // Get default term processor
* MiniSearch.getDefault('processTerm')
*
* // Unknown options will throw an error
* MiniSearch.getDefault('notExisting')
* // => throws 'MiniSearch: unknown option "notExisting"'
* ```
*/
static getDefault (optionName: string): any {
if (defaultOptions.hasOwnProperty(optionName)) {
return getOwnProperty(defaultOptions, optionName)
} else {
throw new Error(`MiniSearch: unknown option "${optionName}"`)
}
}
/**
* @ignore
*/
static loadJS<T = any> (js: AsPlainObject, options: Options<T>): MiniSearch<T> {
const {
index,
documentCount,
nextId,
documentIds,
fieldIds,
fieldLength,
averageFieldLength,
storedFields
} = js
const miniSearch = new MiniSearch(options)
miniSearch._index = new SearchableMap(index._tree, index._prefix)
miniSearch._documentCount = documentCount
miniSearch._nextId = nextId
miniSearch._documentIds = documentIds
miniSearch._fieldIds = fieldIds
miniSearch._fieldLength = fieldLength
miniSearch._averageFieldLength = averageFieldLength
miniSearch._fieldIds = fieldIds
miniSearch._storedFields = storedFields || {}
return miniSearch
}
/**
* @ignore
*/
private executeQuery (query: Query, searchOptions: SearchOptions = {}): RawResult {
if (typeof query === 'string') {
return this.executeSearch(query, searchOptions)
} else {
const results = query.queries.map((subquery) => {
const options = { ...searchOptions, ...query, queries: undefined }
return this.executeQuery(subquery, options)
})
return this.combineResults(results, query.combineWith)
}
}
/**
* @ignore
*/
private executeSearch (queryString: string, searchOptions: SearchOptions = {}): RawResult {
const { tokenize, processTerm, searchOptions: globalSearchOptions } = this._options
const options = { tokenize, processTerm, ...globalSearchOptions, ...searchOptions }
const { tokenize: searchTokenize, processTerm: searchProcessTerm } = options
const terms = searchTokenize(queryString)
.map((term: string) => searchProcessTerm(term))
.filter((term) => !!term) as string[]
const queries: QuerySpec[] = terms.map(termToQuerySpec(options))
const results = queries.map(query => this.executeQuerySpec(query, options))
return this.combineResults(results, options.combineWith)
}
/**
* @ignore
*/
private executeQuerySpec (query: QuerySpec, searchOptions: SearchOptions): RawResult {
const options: SearchOptionsWithDefaults = { ...this._options.searchOptions, ...searchOptions }
const boosts = (options.fields || this._options.fields).reduce((boosts, field) =>
({ ...boosts, [field]: getOwnProperty(boosts, field) || 1 }), options.boost || {})
const {
boostDocument,
weights
} = options
const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights }
const exactMatch = this.termResults(query.term, boosts, boostDocument, this._index.get(query.term))
if (!query.fuzzy && !query.prefix) { return exactMatch }
const results: RawResult[] = [exactMatch]
if (query.prefix) {
this._index.atPrefix(query.term).forEach((term: string, data: {}) => {
const weightedDistance = (0.3 * (term.length - query.term.length)) / term.length
results.push(this.termResults(term, boosts, boostDocument, data, prefixWeight, weightedDistance))
})
}
if (query.fuzzy) {
const fuzzy = (query.fuzzy === true) ? 0.2 : query.fuzzy
const maxDistance = fuzzy < 1 ? Math.round(query.term.length * fuzzy) : fuzzy
Object.entries(this._index.fuzzyGet(query.term, maxDistance)).forEach(([term, [data, distance]]) => {
const weightedDistance = distance / term.length
results.push(this.termResults(term, boosts, boostDocument, data, fuzzyWeight, weightedDistance))
})
}
return results.reduce(combinators[OR])
}
/**
* @ignore
*/
private combineResults (results: RawResult[], combineWith = OR): RawResult {
if (results.length === 0) { return {} }
const operator = combineWith.toLowerCase()
return results.reduce(combinators[operator]) || {}
}
/**
* Allows serialization of the index to JSON, to possibly store it and later
* deserialize it with `MiniSearch.loadJSON`.
*
* Normally one does not directly call this method, but rather call the
* standard JavaScript `JSON.stringify()` passing the `MiniSearch` instance,
* and JavaScript will internally call this method. Upon deserialization, one
* must pass to `loadJSON` the same options used to create the original
* instance that was serialized.
*
* ### Usage:
*
* ```javascript
* // Serialize the index:
* let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
* miniSearch.addAll(documents)
* const json = JSON.stringify(miniSearch)
*
* // Later, to deserialize it:
* miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
* ```
*
* @return A plain-object serializeable representation of the search index.
*/
toJSON (): AsPlainObject {
return {
index: this._index,
documentCount: this._documentCount,
nextId: this._nextId,
documentIds: this._documentIds,
fieldIds: this._fieldIds,
fieldLength: this._fieldLength,
averageFieldLength: this._averageFieldLength,
storedFields: this._storedFields
}
}
/**
* @ignore
*/
private termResults (
term: string,
boosts: { [field: string]: number },
boostDocument: ((id: any, term: string) => number) | undefined,
indexData: IndexData,
weight: number = 1,
editDistance: number = 0
): RawResult {
if (indexData == null) { return {} }
return Object.entries(boosts).reduce((
results: { [shortId: string]: { score: number, match: MatchInfo, terms: string[] } },
[field, boost]
) => {
const fieldId = this._fieldIds[field]
const { df, ds } = indexData[fieldId] || { ds: {} }
Object.entries(ds).forEach(([documentId, tf]) => {
const docBoost = boostDocument ? boostDocument(this._documentIds[documentId], term) : 1
if (!docBoost) { return }
const normalizedLength = this._fieldLength[documentId][fieldId] / this._averageFieldLength[fieldId]
results[documentId] = results[documentId] || { score: 0, match: {}, terms: [] }
results[documentId].terms.push(term)
results[documentId].match[term] = getOwnProperty(results[documentId].match, term) || []
results[documentId].score += docBoost * score(tf, df, this._documentCount, normalizedLength, boost, editDistance)
results[documentId].match[term].push(field)
})
return results
}, {})
}
/**
* @ignore
*/
private addTerm (fieldId: number, documentId: string, term: string): void {
this._index.update(term, (indexData: IndexData) => {
indexData = indexData || {}
const fieldIndex = indexData[fieldId] || { df: 0, ds: {} }
if (fieldIndex.ds[documentId] == null) { fieldIndex.df += 1 }
fieldIndex.ds[documentId] = (fieldIndex.ds[documentId] || 0) + 1
return { ...indexData, [fieldId]: fieldIndex }
})
}
/**
* @ignore
*/
private removeTerm (fieldId: number, documentId: string, term: string): void {
if (!this._index.has(term)) {
this.warnDocumentChanged(documentId, fieldId, term)
return
}
this._index.update(term, (indexData: IndexData) => {
const fieldIndex = indexData[fieldId]
if (fieldIndex == null || fieldIndex.ds[documentId] == null) {
this.warnDocumentChanged(documentId, fieldId, term)
return indexData
}
if (fieldIndex.ds[documentId] <= 1) {
if (fieldIndex.df <= 1) {
delete indexData[fieldId]
return indexData
}
fieldIndex.df -= 1
}
if (fieldIndex.ds[documentId] <= 1) {
delete fieldIndex.ds[documentId]
return indexData
}
fieldIndex.ds[documentId] -= 1
return { ...indexData, [fieldId]: fieldIndex }
})
if (Object.keys(this._index.get(term)).length === 0) {
this._index.delete(term)
}
}
/**
* @ignore
*/
private warnDocumentChanged (shortDocumentId: string, fieldId: number, term: string): void {
if (console == null || console.warn == null) { return }
const fieldName = Object.entries(this._fieldIds).find(([name, id]) => id === fieldId)![0]
console.warn(`MiniSearch: document with ID ${this._documentIds[shortDocumentId]} has changed before removal: term "${term}" was not present in field "${fieldName}". Removing a document after it has changed can corrupt the index!`)
}
/**
* @ignore
*/
private addDocumentId (documentId: any): string {
const shortDocumentId = this._nextId.toString(36)
this._documentIds[shortDocumentId] = documentId
this._documentCount += 1
this._nextId += 1
return shortDocumentId
}
/**
* @ignore
*/
private addFields (fields: string[]): void {
fields.forEach((field, i) => { this._fieldIds[field] = i })
}
/**
* @ignore
*/
private addFieldLength (documentId: string, fieldId: number, count: number, length: number): void {
this._averageFieldLength[fieldId] = this._averageFieldLength[fieldId] || 0
const totalLength = (this._averageFieldLength[fieldId] * count) + length
this._fieldLength[documentId] = this._fieldLength[documentId] || {}
this._fieldLength[documentId][fieldId] = length
this._averageFieldLength[fieldId] = totalLength / (count + 1)
}
/**
* @ignore
*/
private removeFieldLength (documentId: string, fieldId: number, count: number, length: number): void {
const totalLength = (this._averageFieldLength[fieldId] * count) - length
this._averageFieldLength[fieldId] = totalLength / (count - 1)
}
/**
* @ignore
*/
private saveStoredFields (documentId: string, doc: T): void {
const { storeFields, extractField } = this._options
if (storeFields == null || storeFields.length === 0) { return }
this._storedFields[documentId] = this._storedFields[documentId] || {}
storeFields.forEach((fieldName) => {
const fieldValue = extractField(doc, fieldName)
if (fieldValue === undefined) { return }
this._storedFields[documentId][fieldName] = fieldValue
})
}
}
const getOwnProperty = (object: any, property: string) =>
Object.prototype.hasOwnProperty.call(object, property) ? object[property] : undefined
type CombinatorFunction = (a: RawResult, b: RawResult) => RawResult
const combinators: { [kind: string]: CombinatorFunction } = {
[OR]: (a: RawResult, b: RawResult) => {
return Object.entries(b).reduce((combined: RawResult, [documentId, { score, match, terms }]) => {
if (combined[documentId] == null) {
combined[documentId] = { score, match, terms }
} else {
combined[documentId].score += score
combined[documentId].score *= 1.5
combined[documentId].terms.push(...terms)
Object.assign(combined[documentId].match, match)
}
return combined
}, a || {})
},
[AND]: (a: RawResult, b: RawResult) => {
return Object.entries(b).reduce((combined: RawResult, [documentId, { score, match, terms }]) => {
if (a[documentId] === undefined) { return combined }
combined[documentId] = combined[documentId] || {}
combined[documentId].score = a[documentId].score + score
combined[documentId].match = { ...a[documentId].match, ...match }
combined[documentId].terms = [...a[documentId].terms, ...terms]
return combined
}, {})
},
[AND_NOT]: (a: RawResult, b: RawResult) => {
return Object.entries(b).reduce((combined: RawResult, [documentId, { score, match, terms }]) => {
delete combined[documentId]
return combined
}, a || {})
}
}
const tfIdf = (tf: number, df: number, n: number): number => tf * Math.log(n / df)
const score = (
termFrequency: number,
documentFrequency: number,
documentCount: number,
normalizedLength: number,
boost: number,
editDistance: number
): number => {
const weight = boost / (1 + (0.333 * boost * editDistance))
return weight * tfIdf(termFrequency, documentFrequency, documentCount) / normalizedLength
}
const termToQuerySpec = (options: SearchOptions) => (term: string, i: number, terms: string[]): QuerySpec => {
const fuzzy = (typeof options.fuzzy === 'function')
? options.fuzzy(term, i, terms)
: (options.fuzzy || false)
const prefix = (typeof options.prefix === 'function')
? options.prefix(term, i, terms)
: (options.prefix === true)
return { term, fuzzy, prefix }
}
const uniq = <T>(array: T[]): T[] =>
array.filter((element: T, i: number, array: T[]) => array.indexOf(element) === i)
const defaultOptions = {
idField: 'id',
extractField: (document: { [key: string]: any }, fieldName: string) => document[fieldName],
tokenize: (text: string, fieldName?: string) => text.split(SPACE_OR_PUNCTUATION),
processTerm: (term: string, fieldName?: string) => term.toLowerCase(),
fields: undefined,
searchOptions: undefined,
storeFields: []
}
const defaultSearchOptions = {
combineWith: OR,
prefix: false,
fuzzy: false,
boost: {},
weights: { fuzzy: 0.9, prefix: 0.75 }
}
const defaultAutoSuggestOptions = {
prefix: (term: string, i: number, terms: string[]): boolean =>
i === terms.length - 1
}
// This regular expression matches any Unicode space or punctuation character
// Adapted from https://unicode.org/cldr/utility/list-unicodeset.jsp?a=%5Cp%7BZ%7D%5Cp%7BP%7D&abb=on&c=on&esc=on
const SPACE_OR_PUNCTUATION = /[\n\r -#%-*,-/:;?@[-\]_{}\u00A0\u00A1\u00A7\u00AB\u00B6\u00B7\u00BB\u00BF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u1680\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2000-\u200A\u2010-\u2029\u202F-\u2043\u2045-\u2051\u2053-\u205F\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u3000-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]+/u
| MiniSearch |
dfs_search.py | from graph import Digraph, Node, WeightedEdge
def load_map(map_filename):
"""
Parses the map file and constructs a directed graph
Assumes:
Each entry in the map file consists of the following four positive
integers, separated by a blank space:
32 76 54 23
This entry would become an edge from 32 to 76.
Returns:
a Digraph representing the map
"""
g = Digraph()
with open(map_filename, 'r') as file:
read_data = file.read().split('\n')
for elem in read_data:
read_data[read_data.index(elem)] = elem.split(' ')
read_data.remove([''])
for elem in read_data:
start = Node(elem[0])
dest = Node(elem[1])
try:
g.add_node(start)
except ValueError:
pass
try:
g.add_node(dest)
except ValueError:
pass
edge1 = WeightedEdge(start, dest, int(elem[2]), int(elem[3]))
try:
g.add_edge(edge1)
except ValueError:
pass
return g
def get_best_path(digraph, start, end, path, max_dist_outdoors, best_dist,
best_path):
|
def directed_dfs(digraph, start, end, max_total_dist, max_dist_outdoors):
"""
Finds the shortest path from start to end using a directed depth-first
search.
Returns:
The shortest-path from start to end, represented by
a list of building numbers (in strings).
If there exists no path that satisfies max_total_dist and
max_dist_outdoors constraints, then raises a ValueError.
"""
search_result = get_best_path(digraph, start, end, [[], 0, 0], max_dist_outdoors, 0, [])
try:
if search_result[-1] <= max_total_dist:
return search_result[0]
else:
raise ValueError
except TypeError:
raise ValueError
| """
Finds the shortest path between buildings.
Returns:
A tuple with the shortest-path from start to end, represented by
a list of building numbers and the distance of that path.
If there exists no path that satisfies max_total_dist and
max_dist_outdoors constraints, then return None.
"""
start = Node(start)
end = Node(end)
path[0].append(start.get_name())
if start not in digraph.nodes or end not in digraph.nodes:
raise ValueError
elif start == end:
return tuple([path[0].copy(), path[1]])
else:
for edge in digraph.edges[start]:
if edge.get_destination().get_name() not in path[0]:
if len(best_path) == 0 or len(path[0]) < len(best_path):
if path[2] + edge.get_outdoor_distance() <= max_dist_outdoors:
path[1] += edge.get_total_distance()
path[2] += edge.get_outdoor_distance()
next_path = get_best_path(digraph, edge.get_destination(), end, path,
max_dist_outdoors, best_dist, best_path)
path[0].remove(edge.get_destination().get_name())
path[1] -= edge.get_total_distance()
path[2] -= edge.get_outdoor_distance()
else:
continue
if next_path is not None:
if best_dist == 0 or next_path[1] < best_dist:
best_path = next_path[0]
best_dist = next_path[1]
if best_dist == 0:
return None
return tuple([best_path, best_dist]) |
sum.go | package functions
import (
"github.com/TIBCOSoftware/flogo-lib/logger"
)
func AddSampleSum(a, b interface{}) interface{} |
func AggregateBlocksSum(blocks []interface{}, start int, size int) interface{} {
switch blocks[0].(type) {
case int:
return sumInt(blocks)
case float64:
return sumFloat(blocks)
case []int:
return sumIntArray(blocks)
case []float64:
return sumFloatArray(blocks)
}
//todo handle unsupported type
return 0
}
func sumInt(blocks []interface{}) interface{} {
total := 0
for _, block := range blocks {
total += block.(int)
}
return total
}
func sumFloat(blocks []interface{}) interface{} {
total := 0.0
for _, block := range blocks {
total += block.(float64)
}
return total
}
func sumIntArray(blocks []interface{}) interface{} {
firstBlock := blocks[0].([]int)
total := make([]int, len(firstBlock))
for _, block := range blocks {
arrBlock := block.([]int)
for i, val := range arrBlock {
total[i] += val
}
}
return total
}
func sumFloatArray(blocks []interface{}) interface{} {
firstBlock := blocks[0].([]float64)
total := make([]float64, len(firstBlock))
for _, block := range blocks {
arrBlock := block.([]float64)
for i, val := range arrBlock {
total[i] += val
}
}
return total
}
| {
if a == nil {
return b
} else if b == nil {
return a
}
switch x := a.(type) {
case int:
return x + b.(int)
case float64:
return x + b.(float64)
case []int:
y := b.([]int)
for idx, value := range x {
x[idx] = value + y[idx]
}
return x
case []float64:
y := b.([]float64)
for idx, value := range x {
x[idx] = value + y[idx]
}
return x
}
logger.Errorf("unknown")
panic("invalid input")
} |
global_configmap_v1.go | /*
Copyright (C) 2019 Synopsys, Inc.
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.
*/
package v1 |
horizonapi "github.com/blackducksoftware/horizon/pkg/api"
"github.com/blackducksoftware/horizon/pkg/components"
blackduckapi "github.com/blackducksoftware/synopsys-operator/pkg/api/blackduck/v1"
"github.com/blackducksoftware/synopsys-operator/pkg/apps/store"
"github.com/blackducksoftware/synopsys-operator/pkg/apps/types"
apputils "github.com/blackducksoftware/synopsys-operator/pkg/apps/utils"
"github.com/blackducksoftware/synopsys-operator/pkg/protoform"
"github.com/blackducksoftware/synopsys-operator/pkg/util"
"k8s.io/client-go/kubernetes"
)
// BdConfigmap holds the Black Duck config map configuration
type BdConfigmap struct {
config *protoform.Config
kubeClient *kubernetes.Clientset
blackDuck *blackduckapi.Blackduck
}
func init() {
store.Register(types.BlackDuckGlobalConfigmapV1, NewBdConfigmap)
}
// NewBdConfigmap returns the Black Duck config map configuration
func NewBdConfigmap(config *protoform.Config, kubeClient *kubernetes.Clientset, cr interface{}) (types.ConfigMapInterface, error) {
blackDuck, ok := cr.(*blackduckapi.Blackduck)
if !ok {
return nil, fmt.Errorf("unable to cast the interface to Black Duck object")
}
return &BdConfigmap{config: config, kubeClient: kubeClient, blackDuck: blackDuck}, nil
}
// GetCM returns the config map
func (b *BdConfigmap) GetCM() (*components.ConfigMap, error) {
hubConfig := components.NewConfigMap(horizonapi.ConfigMapConfig{Namespace: b.blackDuck.Spec.Namespace, Name: apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "config")})
hubData := map[string]string{
"RUN_SECRETS_DIR": "/tmp/secrets",
"HUB_VERSION": b.blackDuck.Spec.Version,
}
blackduckServiceData := map[string]string{
// TODO: commented the below 2 environs until the HUB-20482 is fixed. once it if fixed, uncomment them
//"HUB_AUTHENTICATION_HOST": util.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "authentication"),
//"AUTHENTICATION_HOST": fmt.Sprintf("%s:%d", util.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "authentication"), int32(8443)),
"CLIENT_CERT_CN": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "binaryscanner"),
"CFSSL": fmt.Sprintf("%s:8888", apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "cfssl")),
"HUB_CFSSL_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "cfssl"),
"BLACKDUCK_CFSSL_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "cfssl"),
"BLACKDUCK_CFSSL_PORT": "8888",
"HUB_DOC_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "documentation"),
"HUB_JOBRUNNER_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "jobrunner"),
"HUB_LOGSTASH_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "logstash"),
"RABBIT_MQ_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "rabbitmq"),
"BROKER_URL": fmt.Sprintf("amqps://%s/protecodesc", apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "rabbitmq")),
"HUB_REGISTRATION_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "registration"),
"HUB_SCAN_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "scan"),
"HUB_SOLR_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "solr"),
// TODO: commented the below 2 environs until the HUB-20412 is fixed. once it if fixed, uncomment them
// "BLACKDUCK_UPLOAD_CACHE_HOST": util.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "uploadcache"),
// "HUB_UPLOAD_CACHE_HOST": util.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "uploadcache"),
// TODO: commented the below environs until the HUB-20462 is fixed. once it if fixed, uncomment them
// "HUB_WEBAPP_HOST": util.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "webapp"),
"HUB_WEBSERVER_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "webserver"),
"HUB_ZOOKEEPER_HOST": apputils.GetResourceName(b.blackDuck.Name, util.BlackDuckName, "zookeeper"),
}
hubData = util.MergeEnvMaps(blackduckServiceData, hubData)
for _, value := range b.blackDuck.Spec.Environs {
values := strings.SplitN(value, ":", 2)
if len(values) == 2 {
mapKey := strings.TrimSpace(values[0])
mapValue := strings.TrimSpace(values[1])
if len(mapKey) > 0 && len(mapValue) > 0 {
hubData[mapKey] = mapValue
}
}
}
// merge default and input environs
environs := GetBlackDuckKnobs()
hubData = util.MergeEnvMaps(hubData, environs)
hubConfig.AddData(hubData)
hubConfig.AddLabels(apputils.GetVersionLabel("configmap", b.blackDuck.Name, b.blackDuck.Spec.Version))
return hubConfig, nil
}
// GetBlackDuckKnobs returns the default Black Duck knobs
func GetBlackDuckKnobs() map[string]string {
return map[string]string{
"IPV4_ONLY": "0",
"USE_ALERT": "0",
"USE_BINARY_UPLOADS": "0",
"RABBIT_MQ_PORT": "5671",
"BROKER_USE_SSL": "yes",
"SCANNER_CONCURRENCY": "1",
"HTTPS_VERIFY_CERTS": "yes",
"RABBITMQ_DEFAULT_VHOST": "protecodesc",
"RABBITMQ_SSL_FAIL_IF_NO_PEER_CERT": "false",
"ENABLE_SOURCE_UPLOADS": "false",
"DATA_RETENTION_IN_DAYS": "180",
"MAX_TOTAL_SOURCE_SIZE_MB": "4000",
}
} |
import (
"fmt"
"strings" |
TestCgShader.py | #!/usr/bin/env python
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renderer = vtk.vtkRenderer()
renWin.AddRenderer(renderer)
src1 = vtk.vtkSphereSource()
src1.SetRadius(5)
src1.SetPhiResolution(20)
src1.SetThetaResolution(20)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(src1.GetOutputPort())
actor = vtk.vtkActor() | # Load the material. Here, we are loading a material
# defined in the Vtk Library. One can also specify
# a filename to a material description xml.
actor.GetProperty().LoadMaterial("CgTwisted")
# Turn shading on. Otherwise, shaders are not used.
actor.GetProperty().ShadingOn()
# Pass a shader variable need by CgTwisted.
actor.GetProperty().AddShaderVariable("Rate",1.0)
renderer.AddActor(actor)
renWin.Render()
renderer.GetActiveCamera().Azimuth(-50)
renderer.GetActiveCamera().Roll(70)
renWin.Render()
# --- end of script -- | actor.SetMapper(mapper) |
BeamSpotOnline_cfi.py | import FWCore.ParameterSet.Config as cms
import RecoVertex.BeamSpotProducer.beamSpotOnlineProducer_cfi as _mod
onlineBeamSpotProducer = _mod.beamSpotOnlineProducer.clone(
src = 'scalersRawToDigi',
setSigmaZ = -1, #negative value disables it. | from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify(onlineBeamSpotProducer, useTransientRecord = True) | gtEvmLabel = 'gtEvmDigis'
)
|
cron_scheudule.py | import os
import time
from pathlib import Path # from path home
import schedule
print(Path.home()) # C:\Users\angel
old_files_folder_name = "old_files"
print("Hello ")
def clean_up_downloads():
print("Cleaning up Downloads")
# get all items from the downloads filder
download_folder_path = os.path.join(Path.home(), "Downloads", "Downloads")
download_items = os.listdir(download_folder_path)
moved_items = 0
| if old_files_folder_name not in download_items:
print(f"No {old_files_folder_name} folder yet, creating folder")
os.mkdir(old_files_folder_path) # create folder "old_files"
# create new folder with todays timestamp
timestamp = time.strftime("%Y_%m_%d") # Year month and day
datetime_folder_path = os.path.join(old_files_folder_path, timestamp)
if not os.path.exists(datetime_folder_path):
print(f"No {datetime_folder_path} folder yet, creating folder")
os.mkdir(datetime_folder_path)
else:
print(f"{timestamp} folder already exists in {old_files_folder_name}")
# rename all items to move them into the current datetime folder
to_be_moved = [item for item in download_items if item != old_files_folder_name] # also moves folders
for item in to_be_moved:
print(f"Moving {item} to {datetime_folder_path} folder")
old_path = os.path.join(download_folder_path, item)
new_path = os.path.join(datetime_folder_path, item)
os.rename(old_path, new_path)
moved_items += 1
print(f"Moved {moved_items} of {len(to_be_moved)} items")
# clean up the downloads folder every monday
# i execute the file on friday 20:21
schedule.every().friday.at("20:22").do(clean_up_downloads)
# keep the script running and sleep in between the checks
while True:
print("here")
schedule.run_pending()
# sleep 24h
time.sleep(1) # 60 * 60 * 24 | # create the old files folder if not present
old_files_folder_path = os.path.join(download_folder_path, old_files_folder_name) |
forms.py | import os
import re
from django import forms
from django.conf import settings
from django.core.files.storage import default_storage as storage
from django.utils.translation import ugettext as _, ugettext_lazy as _lazy
import commonware.log
from olympia import amo
from olympia.accounts.views import fxa_error_message
from olympia.amo.fields import HttpHttpsOnlyURLField
from olympia.users import notifications
from olympia.amo.utils import clean_nl, has_links, slug_validator
from olympia.lib import happyforms
from olympia.translations import LOCALES
from . import tasks
from .models import (
UserProfile, UserNotification, BlacklistedName)
from .widgets import (
NotificationsSelectMultiple, RequiredCheckboxInput, RequiredEmailInput,
RequiredTextarea)
log = commonware.log.getLogger('z.users')
admin_re = re.compile('(?=.*\d)(?=.*[a-zA-Z])')
class UserDeleteForm(forms.Form):
email = forms.CharField(max_length=255, required=True,
widget=RequiredEmailInput)
confirm = forms.BooleanField(required=True, widget=RequiredCheckboxInput)
def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request', None)
super(UserDeleteForm, self).__init__(*args, **kwargs)
self.fields['email'].widget.attrs['placeholder'] = (
self.request.user.email)
def clean_email(self):
user_email = self.request.user.email
if not user_email == self.cleaned_data['email']:
raise forms.ValidationError(_('Email must be {email}.').format(
email=user_email))
def clean(self):
amouser = self.request.user
if amouser.is_developer:
# This is tampering because the form isn't shown on the page if the
# user is a developer
log.warning(u'[Tampering] Attempt to delete developer account (%s)'
% self.request.user)
raise forms.ValidationError("")
class UserEditForm(happyforms.ModelForm):
username = forms.CharField(max_length=50, required=False)
display_name = forms.CharField(label=_lazy(u'Display Name'), max_length=50,
required=False)
location = forms.CharField(label=_lazy(u'Location'), max_length=100,
required=False)
occupation = forms.CharField(label=_lazy(u'Occupation'), max_length=100,
required=False)
homepage = HttpHttpsOnlyURLField(label=_lazy(u'Homepage'), required=False)
email = forms.EmailField(
required=False,
help_text=fxa_error_message(
_(u'Firefox Accounts users cannot currently change their email '
u'address.')),
widget=forms.EmailInput(attrs={'readonly': 'readonly'}))
photo = forms.FileField(label=_lazy(u'Profile Photo'), required=False)
notifications = forms.MultipleChoiceField(
choices=[],
widget=NotificationsSelectMultiple,
initial=notifications.NOTIFICATIONS_DEFAULT,
required=False)
lang = forms.TypedChoiceField(label=_lazy(u'Default locale'),
choices=LOCALES)
def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request', None)
instance = kwargs.get('instance')
if instance and instance.has_anonymous_username():
kwargs.setdefault('initial', {})
kwargs['initial']['username'] = ''
super(UserEditForm, self).__init__(*args, **kwargs)
errors = {'invalid': _('This URL has an invalid format. '
'Valid URLs look like '
'http://example.com/my_page.')}
self.fields['homepage'].error_messages = errors
if not self.instance.lang and self.request:
self.initial['lang'] = self.request.LANG
if self.instance:
default = dict((i, n.default_checked) for i, n
in notifications.NOTIFICATIONS_BY_ID.items())
user = dict((n.notification_id, n.enabled) for n
in self.instance.notifications.all())
default.update(user)
# Add choices to Notification.
choices = notifications.NOTIFICATIONS_CHOICES
if not self.instance.is_developer:
choices = notifications.NOTIFICATIONS_CHOICES_NOT_DEV
# Append a "NEW" message to new notification options.
saved = self.instance.notifications.values_list('notification_id',
flat=True)
self.choices_status = {}
for idx, label in choices:
self.choices_status[idx] = idx not in saved
self.fields['notifications'].choices = choices
self.fields['notifications'].initial = [i for i, v
in default.items() if v]
self.fields['notifications'].widget.form_instance = self
class Meta:
model = UserProfile
fields = (
'username', 'email', 'display_name', 'location', 'occupation',
'homepage', 'photo', 'lang', 'bio', 'display_collections',
'display_collections_fav', 'notifications',
)
def clean_username(self):
|
def clean_display_name(self):
name = self.cleaned_data['display_name']
if BlacklistedName.blocked(name):
raise forms.ValidationError(_('This display name cannot be used.'))
return name
def clean_email(self):
# TODO(django 1.9): Change the field to disabled=True and remove this.
return self.instance.email
def clean_photo(self):
photo = self.cleaned_data['photo']
if not photo:
return
if photo.content_type not in ('image/png', 'image/jpeg'):
raise forms.ValidationError(
_('Images must be either PNG or JPG.'))
if photo.size > settings.MAX_PHOTO_UPLOAD_SIZE:
raise forms.ValidationError(
_('Please use images smaller than %dMB.' %
(settings.MAX_PHOTO_UPLOAD_SIZE / 1024 / 1024 - 1)))
return photo
def clean_bio(self):
bio = self.cleaned_data['bio']
normalized = clean_nl(unicode(bio))
if has_links(normalized):
# There's some links, we don't want them.
raise forms.ValidationError(_('No links are allowed.'))
return bio
def save(self, log_for_developer=True):
u = super(UserEditForm, self).save(commit=False)
data = self.cleaned_data
photo = data['photo']
if photo:
u.picture_type = 'image/png'
tmp_destination = u.picture_path + '__unconverted'
with storage.open(tmp_destination, 'wb') as fh:
for chunk in photo.chunks():
fh.write(chunk)
tasks.resize_photo.delay(tmp_destination, u.picture_path,
set_modified_on=[u])
for (i, n) in notifications.NOTIFICATIONS_BY_ID.items():
enabled = n.mandatory or (str(i) in data['notifications'])
UserNotification.update_or_create(
user=u, notification_id=i, update={'enabled': enabled})
log.debug(u'User (%s) updated their profile' % u)
u.save()
return u
class AdminUserEditForm(UserEditForm):
"""This is the form used by admins to edit users' info."""
email = forms.EmailField(widget=RequiredEmailInput)
admin_log = forms.CharField(required=True, label='Reason for change',
widget=RequiredTextarea(attrs={'rows': 4}))
notes = forms.CharField(required=False, label='Notes',
widget=forms.Textarea(attrs={'rows': 4}))
anonymize = forms.BooleanField(required=False)
def changed_fields(self):
"""Returns changed_data ignoring these fields."""
return (set(self.changed_data) -
set(['admin_log', 'notifications', 'photo']))
def changes(self):
"""A dictionary of changed fields, old, new."""
details = dict([(k, (self.initial[k], self.cleaned_data[k]))
for k in self.changed_fields()])
return details
def clean_anonymize(self):
if (self.cleaned_data['anonymize'] and
self.changed_fields() != set(['anonymize'])):
raise forms.ValidationError(_('To anonymize, enter a reason for'
' the change but do not change any'
' other field.'))
return self.cleaned_data['anonymize']
def clean_email(self):
return self.cleaned_data['email']
def save(self, *args, **kw):
profile = super(AdminUserEditForm, self).save(log_for_developer=False)
if self.cleaned_data['anonymize']:
amo.log(amo.LOG.ADMIN_USER_ANONYMIZED, self.instance,
self.cleaned_data['admin_log'])
profile.anonymize() # This also logs
else:
amo.log(amo.LOG.ADMIN_USER_EDITED, self.instance,
self.cleaned_data['admin_log'], details=self.changes())
log.info('Admin edit user: %s changed fields: %s' %
(self.instance, self.changed_fields()))
return profile
class BlacklistedNameAddForm(forms.Form):
"""Form for adding blacklisted names in bulk fashion."""
names = forms.CharField(widget=forms.Textarea(
attrs={'cols': 40, 'rows': 16}))
def clean_names(self):
names = self.cleaned_data['names'].strip()
if not names:
raise forms.ValidationError(
_('Please enter at least one name to blacklist.'))
names = os.linesep.join(
[s.strip() for s in names.splitlines() if s.strip()])
return names
| name = self.cleaned_data['username']
if not name:
if self.instance.has_anonymous_username():
name = self.instance.username
else:
name = self.instance.anonymize_username()
# All-digits usernames are disallowed since they can be
# confused for user IDs in URLs. (See bug 862121.)
if name.isdigit():
raise forms.ValidationError(
_('Usernames cannot contain only digits.'))
slug_validator(
name, lower=False,
message=_('Enter a valid username consisting of letters, numbers, '
'underscores or hyphens.'))
if BlacklistedName.blocked(name):
raise forms.ValidationError(_('This username cannot be used.'))
# FIXME: Bug 858452. Remove this check when collation of the username
# column is changed to case insensitive.
if (UserProfile.objects.exclude(id=self.instance.id)
.filter(username__iexact=name).exists()):
raise forms.ValidationError(_('This username is already in use.'))
return name |
deserialize_script.rs | extern crate tapyrus;
use tapyrus::util::address::Address;
use tapyrus::network::constants::Network;
use tapyrus::blockdata::script;
use tapyrus::consensus::encode;
fn do_test(data: &[u8]) {
let s: Result<script::Script, _> = encode::deserialize(data);
if let Ok(script) = s {
let _: Result<Vec<script::Instruction>, script::Error> = script.instructions().collect();
let mut b = script::Builder::new();
for ins in script.instructions_minimal() {
if ins.is_err() {
return;
}
match ins.ok().unwrap() {
script::Instruction::Op(op) => { b = b.push_opcode(op); }
script::Instruction::PushBytes(bytes) => {
// Any one-byte pushes, except -0, which can be interpreted as numbers, should be
// reserialized as numbers. (For -1 through 16, this will use special ops; for
// others it'll just reserialize them as pushes.)
if bytes.len() == 1 && bytes[0] != 0x80 && bytes[0] != 0x00 {
if let Ok(num) = script::read_scriptint(bytes) {
b = b.push_int(num);
} else {
b = b.push_slice(bytes);
}
} else {
b = b.push_slice(bytes);
}
}
}
}
assert_eq!(b.into_script(), script);
assert_eq!(data, &encode::serialize(&script)[..]);
// Check if valid address and if that address roundtrips.
if let Some(addr) = Address::from_script(&script, Network::Prod) {
assert_eq!(addr.script_pubkey(), script);
}
}
}
#[cfg(feature = "afl")]
#[macro_use] extern crate afl;
#[cfg(feature = "afl")]
fn main() {
fuzz!(|data| {
do_test(&data);
});
}
#[cfg(feature = "honggfuzz")]
#[macro_use] extern crate honggfuzz;
#[cfg(feature = "honggfuzz")]
fn main() {
loop {
fuzz!(|data| {
do_test(data);
});
}
}
#[cfg(test)]
mod tests {
fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
let mut b = 0;
for (idx, c) in hex.as_bytes().iter().enumerate() {
b <<= 4;
match *c {
b'A'...b'F' => b |= c - b'A' + 10,
b'a'...b'f' => b |= c - b'a' + 10,
b'0'...b'9' => b |= c - b'0',
_ => panic!("Bad hex"),
} | }
}
}
#[test]
fn duplicate_crash() {
let mut a = Vec::new();
extend_vec_from_hex("00", &mut a);
super::do_test(&a);
}
} | if (idx & 1) == 1 {
out.push(b);
b = 0; |
rrdp.rs | //! Parsing the XML representations.
#![cfg(feature = "rrdp")]
use std::{fmt, io, ops, str};
use log::info;
use ring::digest;
use uuid::Uuid;
use crate::uri;
use crate::xml::decode::{Reader, Name, Error};
//------------ NotificationFile ----------------------------------------------
pub struct NotificationFile {
pub session_id: Uuid,
pub serial: u64,
pub snapshot: UriAndHash,
pub deltas: Vec<(u64, UriAndHash)>,
}
impl NotificationFile {
pub fn parse<R: io::BufRead>(reader: R) -> Result<Self, Error> {
let mut reader = Reader::new(reader);
let mut session_id = None;
let mut serial = None;
let mut outer = reader.start(|element| {
if element.name() != NOTIFICATION {
return Err(Error::Malformed)
}
element.attributes(|name, value| match name {
b"version" => {
if value.ascii_into::<u8>()? != 1 {
return Err(Error::Malformed)
}
Ok(())
}
b"session_id" => {
session_id = Some(value.ascii_into()?);
Ok(())
}
b"serial" => {
serial = Some(value.ascii_into()?);
Ok(())
}
_ => Err(Error::Malformed)
})
})?;
let mut snapshot = None;
let mut deltas = Vec::new();
while let Some(mut content) = outer.take_opt_element(&mut reader,
|element| {
match element.name() {
SNAPSHOT => {
if snapshot.is_some() {
return Err(Error::Malformed)
}
let mut uri = None;
let mut hash = None;
element.attributes(|name, value| match name {
b"uri" => {
uri = Some(value.ascii_into()?);
Ok(())
}
b"hash" => {
hash = Some(value.ascii_into()?);
Ok(())
}
_ => Err(Error::Malformed)
})?;
match (uri, hash) {
(Some(uri), Some(hash)) => {
snapshot = Some(UriAndHash::new(uri, hash));
Ok(())
}
_ => Err(Error::Malformed)
}
}
DELTA => {
let mut serial = None;
let mut uri = None;
let mut hash = None;
element.attributes(|name, value| match name {
b"serial" => {
serial = Some(value.ascii_into()?);
Ok(())
}
b"uri" => {
uri = Some(value.ascii_into()?);
Ok(())
}
b"hash" => {
hash = Some(value.ascii_into()?);
Ok(())
}
_ => Err(Error::Malformed)
})?;
match (serial, uri, hash) {
(Some(serial), Some(uri), Some(hash)) => {
deltas.push((serial, UriAndHash::new(uri, hash)));
Ok(())
}
_ => Err(Error::Malformed)
}
}
_ => Err(Error::Malformed)
}
})? {
content.take_end(&mut reader)?;
}
outer.take_end(&mut reader)?;
reader.end()?;
match (session_id, serial, snapshot) {
(Some(session_id), Some(serial), Some(snapshot)) => {
Ok(NotificationFile { session_id, serial, snapshot, deltas })
}
_ => Err(Error::Malformed)
}
}
}
//------------ ProcessSnapshot -----------------------------------------------
pub trait ProcessSnapshot {
type Err: From<Error>;
fn meta(
&mut self,
session_id: Uuid,
serial: u64,
) -> Result<(), Self::Err>;
fn publish(
&mut self,
uri: uri::Rsync,
data: Vec<u8>,
) -> Result<(), Self::Err>;
fn process<R: io::BufRead>(
&mut self,
reader: R
) -> Result<(), Self::Err> {
let mut reader = Reader::new(reader);
let mut session_id = None;
let mut serial = None;
let mut outer = reader.start(|element| {
if element.name() != SNAPSHOT {
info!("Bad outer: not snapshot, but {:?}", element.name());
return Err(Error::Malformed)
}
element.attributes(|name, value| match name {
b"version" => {
if value.ascii_into::<u8>()? != 1 {
info!("Bad version");
return Err(Error::Malformed)
}
Ok(())
}
b"session_id" => {
session_id = Some(value.ascii_into()?);
Ok(())
}
b"serial" => {
serial = Some(value.ascii_into()?);
Ok(())
}
_ => {
info!("Bad attribute on snapshot.");
Err(Error::Malformed)
}
})
})?;
match (session_id, serial) {
(Some(session_id), Some(serial)) => {
self.meta(session_id, serial)?;
}
_ => {
info!("Missing session or serial");
return Err(Error::Malformed.into())
}
}
loop {
let mut uri = None;
let inner = outer.take_opt_element(&mut reader, |element| {
if element.name() != PUBLISH {
info!("Bad inner: not publish");
return Err(Error::Malformed)
}
element.attributes(|name, value| match name {
b"uri" => {
uri = Some(value.ascii_into()?);
Ok(())
}
_ => {
info!("Bad attribute on publish.");
Err(Error::Malformed)
}
})
})?;
let mut inner = match inner {
Some(inner) => inner,
None => break
};
let uri = match uri {
Some(uri) => uri,
None => return Err(Error::Malformed.into())
};
let data = inner.take_text(&mut reader, |text| {
let text: Vec<_> = text.to_ascii()?.as_bytes()
.iter().filter_map(|b| {
if b.is_ascii_whitespace() { None }
else { Some(*b) }
}).collect();
base64::decode(&text).map_err(|_| {
Error::Malformed
})
})?;
self.publish(uri, data)?;
inner.take_end(&mut reader)?;
}
outer.take_end(&mut reader)?;
reader.end()?;
Ok(())
}
}
//------------ ProcessDelta --------------------------------------------------
pub trait ProcessDelta {
type Err: From<Error>;
fn meta(
&mut self,
session_id: Uuid,
serial: u64,
) -> Result<(), Self::Err>;
fn publish(
&mut self,
uri: uri::Rsync,
hash: Option<DigestHex>,
data: Vec<u8>,
) -> Result<(), Self::Err>;
fn withdraw(
&mut self,
uri: uri::Rsync,
hash: DigestHex,
) -> Result<(), Self::Err>;
fn process<R: io::BufRead>(
&mut self,
reader: R
) -> Result<(), Self::Err> {
let mut reader = Reader::new(reader);
let mut session_id = None;
let mut serial = None;
let mut outer = reader.start(|element| {
if element.name() != DELTA {
return Err(Error::Malformed)
}
element.attributes(|name, value| match name {
b"version" => {
if value.ascii_into::<u8>()? != 1 {
return Err(Error::Malformed)
}
Ok(())
}
b"session_id" => {
session_id = Some(value.ascii_into()?);
Ok(())
}
b"serial" => {
serial = Some(value.ascii_into()?);
Ok(())
}
_ => Err(Error::Malformed)
})
})?;
match (session_id, serial) {
(Some(session_id), Some(serial)) => {
self.meta(session_id, serial)?;
}
_ => return Err(Error::Malformed.into()),
}
loop {
let mut action = None;
let mut uri = None;
let mut hash = None;
let inner = outer.take_opt_element(&mut reader, |element| {
match element.name() {
PUBLISH => action = Some(Action::Publish),
WITHDRAW => action = Some(Action::Withdraw),
_ => return Err(Error::Malformed),
};
element.attributes(|name, value| match name {
b"uri" => {
uri = Some(value.ascii_into()?);
Ok(())
}
b"hash" => {
hash = Some(value.ascii_into()?);
Ok(())
}
_ => Err(Error::Malformed) | })
})?;
let mut inner = match inner {
Some(inner) => inner,
None => break
};
let uri = match uri {
Some(uri) => uri,
None => return Err(Error::Malformed.into())
};
match action.unwrap() { // Or we'd have exited already.
Action::Publish => {
let data = inner.take_text(&mut reader, |text| {
let text: Vec<_> = text.to_ascii()?.as_bytes()
.iter().filter_map(|b| {
if b.is_ascii_whitespace() { None }
else { Some(*b) }
}).collect();
base64::decode(&text)
.map_err(|_| Error::Malformed)
})?;
self.publish(uri, hash, data)?;
}
Action::Withdraw => {
let hash = match hash {
Some(hash) => hash,
None => return Err(Error::Malformed.into())
};
self.withdraw(uri, hash)?;
}
}
inner.take_end(&mut reader)?;
}
outer.take_end(&mut reader)?;
reader.end()?;
Ok(())
}
}
//------------ UriAndHash ----------------------------------------------------
#[derive(Clone, Debug)]
pub struct UriAndHash {
uri: uri::Https,
hash: DigestHex,
}
impl UriAndHash {
pub fn new(uri: uri::Https, hash: DigestHex) -> Self {
UriAndHash { uri, hash }
}
pub fn uri(&self) -> &uri::Https {
&self.uri
}
pub fn hash(&self) -> &DigestHex {
&self.hash
}
}
//------------ DigestHex -----------------------------------------------------
/// A helper type to encode a digest as a sequence of hex-digits.
#[derive(Clone, Debug)]
pub struct DigestHex(Vec<u8>);
impl From<Vec<u8>> for DigestHex {
fn from(value: Vec<u8>) -> DigestHex {
DigestHex(value)
}
}
impl From<digest::Digest> for DigestHex {
fn from(value: digest::Digest) -> DigestHex {
DigestHex(Vec::from(value.as_ref()))
}
}
impl str::FromStr for DigestHex {
type Err = &'static str;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut res = Vec::new();
let mut s = s.chars();
while let Some(first) = s.next() {
let first = first.to_digit(16).ok_or("invalid digest")?;
let second = s.next().ok_or("invalid digest")?
.to_digit(16).ok_or("invalid digest")?;
res.push((first << 4 | second) as u8);
}
Ok(DigestHex(res))
}
}
impl ops::Deref for DigestHex {
type Target = [u8];
fn deref(&self) -> &[u8] {
self.0.as_ref()
}
}
impl AsRef<[u8]> for DigestHex {
fn as_ref(&self) -> &[u8] {
self.0.as_ref()
}
}
impl fmt::Display for DigestHex {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for &ch in self.0.as_slice() {
write!(f, "{:02x}", ch)?;
}
Ok(())
}
}
//------------ Action --------------------------------------------------------
enum Action {
Publish,
Withdraw,
}
//------------ Xml Names -----------------------------------------------------
const NS: &[u8] = b"http://www.ripe.net/rpki/rrdp";
const NOTIFICATION: Name = Name::qualified(NS, b"notification");
const SNAPSHOT: Name = Name::qualified(NS, b"snapshot");
const DELTA: Name = Name::qualified(NS, b"delta");
const PUBLISH: Name = Name::qualified(NS, b"publish");
const WITHDRAW: Name = Name::qualified(NS, b"withdraw");
//============ Tests =========================================================
#[cfg(test)]
mod test {
use super::*;
pub struct Test;
impl ProcessSnapshot for Test {
type Err = Error;
fn meta(
&mut self,
_session_id: Uuid,
_serial: u64,
) -> Result<(), Self::Err> {
Ok(())
}
fn publish(
&mut self,
_uri: uri::Rsync,
_data: Vec<u8>,
) -> Result<(), Self::Err> {
Ok(())
}
}
impl ProcessDelta for Test {
type Err = Error;
fn meta(
&mut self,
_session_id: Uuid,
_serial: u64,
) -> Result<(), Self::Err> {
Ok(())
}
fn publish(
&mut self,
_uri: uri::Rsync,
_hash: Option<DigestHex>,
_data: Vec<u8>,
) -> Result<(), Self::Err> {
Ok(())
}
fn withdraw(
&mut self,
_uri: uri::Rsync,
_hash: DigestHex,
) -> Result<(), Self::Err> {
Ok(())
}
}
#[test]
fn ripe_notification() {
NotificationFile::parse(
include_bytes!("../test-data/ripe-notification.xml").as_ref()
).unwrap();
}
#[test]
fn ripe_snapshot() {
<Test as ProcessSnapshot>::process(
&mut Test,
include_bytes!("../test-data/ripe-snapshot.xml").as_ref()
).unwrap();
}
#[test]
fn ripe_delta() {
<Test as ProcessDelta>::process(
&mut Test,
include_bytes!("../test-data/ripe-delta.xml").as_ref()
).unwrap();
}
} | |
unity.py | from __future__ import unicode_literals
from .common import InfoExtractor
from .youtube import YoutubeIE
class | (InfoExtractor):
_VALID_URL = (
r"https?://(?:www\.)?unity3d\.com/learn/tutorials/(?:[^/]+/)*(?P<id>[^/?#&]+)"
)
_TESTS = [
{
"url": "https://unity3d.com/learn/tutorials/topics/animation/animate-anything-mecanim",
"info_dict": {
"id": "jWuNtik0C8E",
"ext": "mp4",
"title": "Live Training 22nd September 2014 - Animate Anything",
"description": "md5:e54913114bd45a554c56cdde7669636e",
"duration": 2893,
"uploader": "Unity",
"uploader_id": "Unity3D",
"upload_date": "20140926",
},
},
{
"url": "https://unity3d.com/learn/tutorials/projects/2d-ufo-tutorial/following-player-camera?playlist=25844",
"only_matching": True,
},
]
def _real_extract(self, url):
video_id = self._match_id(url)
webpage = self._download_webpage(url, video_id)
youtube_id = self._search_regex(
r'data-video-id="([_0-9a-zA-Z-]+)"', webpage, "youtube ID"
)
return self.url_result(youtube_id, ie=YoutubeIE.ie_key(), video_id=video_id)
| UnityIE |
smph21.rs | #[doc = "Reader of register SMPH21"]
pub type R = crate::R<u32, super::SMPH21>;
#[doc = "Writer for register SMPH21"]
pub type W = crate::W<u32, super::SMPH21>;
#[doc = "Register SMPH21 `reset()`'s with value 0x01"]
impl crate::ResetValue for super::SMPH21 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x01
}
}
#[doc = "Reader of field `RESERVED1`"]
pub type RESERVED1_R = crate::R<u32, u32>;
#[doc = "Write proxy for field `RESERVED1`"]
pub struct RESERVED1_W<'a> { | }
impl<'a> RESERVED1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u32) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x7fff_ffff << 1)) | (((value as u32) & 0x7fff_ffff) << 1);
self.w
}
}
#[doc = "Reader of field `STAT`"]
pub type STAT_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `STAT`"]
pub struct STAT_W<'a> {
w: &'a mut W,
}
impl<'a> STAT_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
impl R {
#[doc = "Bits 1:31 - 31:1\\]
Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
#[inline(always)]
pub fn reserved1(&self) -> RESERVED1_R {
RESERVED1_R::new(((self.bits >> 1) & 0x7fff_ffff) as u32)
}
#[doc = "Bit 0 - 0:0\\]
Status when reading: 0: Semaphore is taken 1: Semaphore is available Reading the register causes it to change value to 0. Releasing the semaphore is done by writing 1."]
#[inline(always)]
pub fn stat(&self) -> STAT_R {
STAT_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bits 1:31 - 31:1\\]
Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
#[inline(always)]
pub fn reserved1(&mut self) -> RESERVED1_W {
RESERVED1_W { w: self }
}
#[doc = "Bit 0 - 0:0\\]
Status when reading: 0: Semaphore is taken 1: Semaphore is available Reading the register causes it to change value to 0. Releasing the semaphore is done by writing 1."]
#[inline(always)]
pub fn stat(&mut self) -> STAT_W {
STAT_W { w: self }
}
} | w: &'a mut W, |
plugins.py | # This file is part of Rubber and thus covered by the GPL
# (c) Emmanuel Beffara, 2002--2006
"""
Mechanisms to dynamically load extra modules to help the LaTeX compilation.
All the modules must be derived from the TexModule class.
"""
import imp
from os.path import *
from msg import _, msg
import sys
class TexModule (object):
"""
This is the base class for modules. Each module should define a class
named 'Module' that derives from this one. The default implementation
provides all required methods with no effects.
"""
def __init__ (self, env, dict):
"""
The constructor receives two arguments: 'env' is the compiling
environment, 'dict' is a dictionary that describes the command that
caused the module to load.
"""
def pre_compile (self):
"""
This method is called before the first LaTeX compilation. It is
supposed to build any file that LaTeX would require to compile the
document correctly. The method must return true on failure.
"""
return 0
def post_compile (self):
"""
This method is called after each LaTeX compilation. It is supposed to
process the compilation results and possibly request a new
compilation. The method must return true on failure.
"""
return 0
def last_compile (self):
"""
This method is called after the last LaTeX compilation.
It is supposed to terminate the compilation for its specific needs.
The method must return true on failure.
"""
return 0
def clean (self):
"""
This method is called when cleaning the compiled files. It is supposed
to remove all the files that this modules generates.
"""
def command (self, cmd, args):
"""
This is called when a directive for the module is found in the source.
The method can raise 'AttributeError' when the directive does not
exist and 'TypeError' if the syntax is wrong. By default, when called
with argument "foo" it calls the method "do_foo" if it exists, and
fails otherwise.
"""
getattr(self, "do_" + cmd)(*args)
def get_errors (self):
"""
This is called if something has failed during an operation performed
by this module. The method returns a generator with items of the same
form as in LaTeXDep.get_errors.
"""
if None:
yield None
class Plugins (object):
"""
This class gathers operations related to the management of external Python
modules. Modules are requested through the `register' method, and
they are searched for first in the current directory, then in the
(possibly) specified Python package (using Python's path).
"""
def __init__ (self, path=None):
"""
Initialize the module set, possibly setting a path name in which
modules will be searched for.
"""
self.modules = {}
if not path:
self.path = [dirname(__file__)]
sys.path.append(self.path[0])
else:
self.path = path
def __getitem__ (self, name):
"""
Return the module object of the given name.
"""
return self.modules[name]
def register (self, name):
|
def clear(self):
"""
Empty the module table, unregistering every module registered. No
modules are unloaded, however, but this has no other effect than
speeding the registration if the modules are loaded again.
"""
self.modules.clear()
class Modules (Plugins):
"""
This class gathers all operations related to the management of modules.
The modules are searched for first in the current directory, then as
scripts in the 'modules' directory in the program's data directort, then
as a Python module in the package `rubber.latex'.
"""
def __init__ (self, env):
#Plugins.__init__(self, rubber.rules.latex.__path__)
Plugins.__init__(self)
self.env = env
self.objects = {}
self.commands = {}
def __getitem__ (self, name):
"""
Return the module object of the given name.
"""
return self.objects[name]
def has_key (self, name):
"""
Check if a given module is loaded.
"""
return self.objects.has_key(name)
def register (self, name, dict={}):
"""
Attempt to register a package with the specified name. If a module is
found, create an object from the module's class called `Module',
passing it the environment and `dict' as arguments, and execute all
delayed commands for this module. The dictionary describes the
command that caused the registration.
"""
if self.has_key(name):
msg.debug(_("module %s already registered") % name)
return 2
# First look for a script
moddir = ""
mod = None
for path in "", join(moddir, "modules"):
file = join(path, name + ".rub")
if exists(file):
mod = ScriptModule(self.env, file)
msg.log(_("script module %s registered") % name)
break
# Then look for a Python module
if not mod:
if Plugins.register(self, name) == 0:
msg.debug(_("no support found for %s") % name)
return 0
mod = self.modules[name].Module(self.env, dict)
msg.log(_("built-in module %s registered") % name)
# Run any delayed commands.
if self.commands.has_key(name):
for (cmd, args, vars) in self.commands[name]:
msg.push_pos(vars)
try:
mod.command(cmd, args)
except AttributeError:
msg.warn(_("unknown directive '%s.%s'") % (name, cmd))
except TypeError:
msg.warn(_("wrong syntax for '%s.%s'") % (name, cmd))
msg.pop_pos()
del self.commands[name]
self.objects[name] = mod
return 1
def clear (self):
"""
Unregister all modules.
"""
Plugins.clear(self)
self.objects = {}
self.commands = {}
def command (self, mod, cmd, args):
"""
Send a command to a particular module. If this module is not loaded,
store the command so that it will be sent when the module is register.
"""
if self.objects.has_key(mod):
self.objects[mod].command(cmd, args)
else:
if not self.commands.has_key(mod):
self.commands[mod] = []
self.commands[mod].append((cmd, args, self.env.vars.copy()))
| """
Attempt to register a module with the specified name. If an
appropriate module is found, load it and store it in the object's
dictionary. Return 0 if no module was found, 1 if a module was found
and loaded, and 2 if the module was found but already loaded.
"""
if self.modules.has_key(name):
return 2
try:
file, path, descr = imp.find_module(name, [""])
except ImportError:
if not self.path:
return 0
try:
file, path, descr = imp.find_module(name, self.path)
except ImportError:
return 0
module = imp.load_module(name, file, path, descr)
file.close()
self.modules[name] = module
return 1 |
serverwriter.go | // Copyright (c) 2018 Palantir Technologies. All rights reserved.
//
// 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 conjure
import (
"fmt"
"go/token"
"strings"
"github.com/palantir/goastwriter/astgen"
"github.com/palantir/goastwriter/decl"
"github.com/palantir/goastwriter/expression"
"github.com/palantir/goastwriter/statement"
werror "github.com/palantir/witchcraft-go-error"
"github.com/pkg/errors"
"github.com/palantir/conjure-go/v4/conjure-api/conjure/spec"
"github.com/palantir/conjure-go/v4/conjure/transforms"
"github.com/palantir/conjure-go/v4/conjure/types"
"github.com/palantir/conjure-go/v4/conjure/visitors"
"github.com/palantir/conjure-go/v4/conjure/werrorexpressions"
)
const (
registerPrefix = "RegisterRoutes"
errorName = "err"
okName = "ok"
implName = "impl"
// Handler
handlerName = "handler"
// Router
routerVarName = "router"
routerImportPackage = "wrouter"
routerImportClass = "Router"
routerPathParamsMapFunc = "PathParams"
resourceName = "resource"
// Server
serverResourceImportPackage = "wresource"
serverResourceFunctionName = "New"
restImportPackage = "rest"
// Handler
handlerStructNameSuffix = "Handler"
handlerFunctionNamePrefix = "Handle"
// Auth
funcParseBearerTokenHeader = "ParseBearerTokenHeader"
authCookieVar = "authCookie"
// ResponseWriter
responseWriterVarName = "rw"
responseArgVarName = "respArg"
httpPackageName = "http"
responseWriterType = "ResponseWriter"
// Request
requestVarName = "req"
requestVarType = "*" + httpPackageName + ".Request"
requestHeaderFunc = "Header"
requestURLField = "URL"
urlQueryFunc = "Query"
// Codecs
codecsJSON = "codecs.JSON"
codecEncodeFunc = "Encode"
codecDecodeFunc = "Decode"
codecContentTypeFunc = "ContentType"
)
func ASTForServerRouteRegistration(serviceDefinition spec.ServiceDefinition, info types.PkgInfo) ([]astgen.ASTDecl, error) {
info.AddImports(
"github.com/palantir/conjure-go-runtime/conjure-go-contract/codecs",
"github.com/palantir/witchcraft-go-server/rest",
"github.com/palantir/witchcraft-go-server/witchcraft",
"github.com/palantir/witchcraft-go-server/witchcraft/wresource",
"github.com/palantir/witchcraft-go-server/wrouter")
info.SetImports("werror", "github.com/palantir/witchcraft-go-error")
serviceName := serviceDefinition.ServiceName.Name
funcName := registerPrefix + strings.Title(serviceName)
serviceImplName := transforms.Export(serviceName)
body, err := getRegisterRoutesBody(serviceDefinition)
if err != nil {
return nil, err
}
registerRoutesFunc := &decl.Function{
Comment: funcName + " registers handlers for the " + serviceName + " endpoints with a witchcraft wrouter.\n" +
"This should typically be called in a witchcraft server's InitFunc.\n" +
"impl provides an implementation of each endpoint, which can assume the request parameters have been parsed\n" +
"in accordance with the Conjure specification.",
Name: funcName,
FuncType: expression.FuncType{
Params: []*expression.FuncParam{
{
Names: []string{routerVarName},
Type: expression.Type(fmt.Sprintf("%s.%s", routerImportPackage, routerImportClass)),
},
{
Names: []string{implName},
Type: expression.Type(serviceImplName),
},
},
ReturnTypes: []expression.Type{
expression.ErrorType,
},
},
Body: body,
}
components := []astgen.ASTDecl{
registerRoutesFunc,
}
return components, nil
}
func getRegisterRoutesBody(serviceDefinition spec.ServiceDefinition) ([]astgen.ASTStmt, error) {
var body []astgen.ASTStmt
// Create the handler struct
body = append(body, &statement.Assignment{
LHS: []astgen.ASTExpr{
expression.VariableVal(handlerName),
},
Tok: token.DEFINE,
RHS: createHandlerSpec(serviceDefinition),
})
// Create the witchcraft resource
body = append(body, &statement.Assignment{
LHS: []astgen.ASTExpr{
expression.VariableVal(resourceName),
},
Tok: token.DEFINE,
RHS: expression.NewCallFunction(serverResourceImportPackage, serverResourceFunctionName, []astgen.ASTExpr{
expression.StringVal(strings.ToLower(serviceDefinition.ServiceName.Name)),
expression.VariableVal(routerVarName),
}...),
})
// For each endpoint, register a route on the provided router
// if err := resource.Get(...); err != nil {
// return werror.Wrap(err, ...)
// }
// TODO(bmoylan): Register safe params - Nothing in the conjure def tells us what is safe or unsafe. How do we know? Kevin says this is markers
for _, endpoint := range serviceDefinition.Endpoints {
endpointTitleName := strings.Title(string(endpoint.EndpointName))
stmt := statement.If{ | token.DEFINE,
expression.NewCallFunction(resourceName, getResourceFunction(endpoint), []astgen.ASTExpr{
expression.StringVal(endpointTitleName),
expression.StringVal(getPathToRegister(endpoint)),
astForRestJSONHandler(expression.NewSelector(expression.VariableVal(handlerName), "Handle"+endpointTitleName)),
}...),
),
Cond: &expression.Binary{
LHS: expression.VariableVal(errorName),
Op: token.NEQ,
RHS: expression.Nil,
},
Body: []astgen.ASTStmt{
&statement.Return{
Values: []astgen.ASTExpr{
werrorexpressions.CreateWrapWErrorExpression(errorName, "failed to add route", map[string]string{"routeName": endpointTitleName}),
},
},
},
}
body = append(body, &stmt)
}
// Return nil if everything registered
body = append(body, &statement.Return{
Values: []astgen.ASTExpr{expression.Nil},
})
return body, nil
}
func createHandlerSpec(serviceDefinition spec.ServiceDefinition) astgen.ASTExpr {
return expression.NewCompositeLit(
expression.Type(getHandlerStuctName(serviceDefinition)),
expression.NewKeyValue(implName, expression.VariableVal(implName)),
)
}
func getPathToRegister(endpointDefinition spec.EndpointDefinition) string {
return string(endpointDefinition.HttpPath)
}
func getResourceFunction(endpointDefinition spec.EndpointDefinition) string {
switch endpointDefinition.HttpMethod {
case spec.HttpMethodGet:
return "Get"
case spec.HttpMethodPost:
return "Post"
case spec.HttpMethodPut:
return "Put"
case spec.HttpMethodDelete:
return "Delete"
default:
return "Unknown"
}
}
func AstForServerInterface(serviceDefinition spec.ServiceDefinition, info types.PkgInfo) ([]astgen.ASTDecl, error) {
serviceName := serviceDefinition.ServiceName.Name
interfaceAST, _, err := serverServiceInterfaceAST(serviceDefinition, info, serviceASTConfig{})
if err != nil {
return nil, errors.Wrapf(err, "failed to generate interface for service %q", serviceName)
}
components := []astgen.ASTDecl{
interfaceAST,
}
return components, nil
}
func AstForServerFunctionHandler(serviceDefinition spec.ServiceDefinition, info types.PkgInfo) ([]astgen.ASTDecl, error) {
var components []astgen.ASTDecl
implStructs := getHandlerStruct(serviceDefinition)
components = append(components, implStructs)
methods, err := getHandleMethods(serviceDefinition, info)
if err != nil {
return nil, err
}
for _, method := range methods {
components = append(components, method)
}
return components, nil
}
func getHandleMethods(serviceDefinition spec.ServiceDefinition, info types.PkgInfo) ([]*decl.Method, error) {
var methods []*decl.Method
for _, endpoint := range serviceDefinition.Endpoints {
method, err := getHandleMethod(serviceDefinition, endpoint, info)
if err != nil {
return nil, err
}
methods = append(methods, method)
}
return methods, nil
}
func getHandleMethod(serviceDefinition spec.ServiceDefinition, endpoint spec.EndpointDefinition, info types.PkgInfo) (*decl.Method, error) {
info.AddImports("net/http")
body, err := getHandleMethodBody(serviceDefinition, endpoint, info)
if err != nil {
return nil, err
}
receiverName := getReceiverName(serviceDefinition)
titleEndpoint := strings.Title(string(endpoint.EndpointName))
methods := &decl.Method{
ReceiverName: receiverName,
ReceiverType: expression.Type(getHandlerStuctName(serviceDefinition)).Pointer(),
Function: decl.Function{
Name: handlerFunctionNamePrefix + titleEndpoint,
FuncType: expression.FuncType{
Params: []*expression.FuncParam{
{
Names: []string{responseWriterVarName},
Type: expression.Type(strings.Join([]string{httpPackageName, responseWriterType}, ".")),
},
{
Names: []string{requestVarName},
Type: expression.Type(requestVarType),
},
},
ReturnTypes: []expression.Type{expression.ErrorType},
},
Body: body,
},
}
return methods, nil
}
func getHandleMethodBody(serviceDefinition spec.ServiceDefinition, endpoint spec.EndpointDefinition, info types.PkgInfo) ([]astgen.ASTStmt, error) {
var body []astgen.ASTStmt
pathParams, err := visitors.GetPathParams(endpoint.Args)
if err != nil {
return nil, err
}
headerParams, err := visitors.GetHeaderParams(endpoint.Args)
if err != nil {
return nil, err
}
queryParams, err := visitors.GetQueryParams(endpoint.Args)
if err != nil {
return nil, err
}
bodyParams, err := visitors.GetBodyParams(endpoint.Args)
if err != nil {
return nil, err
}
var bodyParam *visitors.ArgumentDefinitionBodyParam
switch len(bodyParams) {
case 0:
case 1:
bodyParam = &bodyParams[0]
default:
return nil, errors.New("only 1 body param is supported: Conjure IR generator should have caught this")
}
authStatements, err := getAuthStatements(endpoint.Auth, info)
if err != nil {
return nil, err
}
body = append(body, authStatements...)
pathParamStatements, err := getPathParamStatements(pathParams, info)
if err != nil {
return nil, err
}
body = append(body, pathParamStatements...)
queryParamStatements, err := getQueryParamStatements(queryParams, info)
if err != nil {
return nil, err
}
body = append(body, queryParamStatements...)
headerParamStatements, err := getHeaderParamStatements(headerParams, info)
if err != nil {
return nil, err
}
body = append(body, headerParamStatements...)
bodyParamStatements, err := getBodyParamStatements(bodyParam, info)
if err != nil {
return nil, err
}
body = append(body, bodyParamStatements...)
varsToPassIntoImpl := []astgen.ASTExpr{expression.NewCallFunction(requestVarName, "Context")}
if endpoint.Auth != nil {
if headerAuth, err := visitors.GetPossibleHeaderAuth(*endpoint.Auth); err != nil {
return nil, err
} else if headerAuth != nil {
varsToPassIntoImpl = append(varsToPassIntoImpl, expression.NewCallExpression(
expression.Type(types.Bearertoken.GoType(info)),
expression.VariableVal(authHeaderVar),
))
}
if cookieAuth, err := visitors.GetPossibleCookieAuth(*endpoint.Auth); err != nil {
return nil, err
} else if cookieAuth != nil {
varsToPassIntoImpl = append(varsToPassIntoImpl, expression.VariableVal(cookieTokenVar))
}
}
for _, arg := range endpoint.Args {
varsToPassIntoImpl = append(varsToPassIntoImpl, expression.VariableVal(transforms.SafeName(string(arg.ArgName))))
}
returnStatements, err := getReturnStatements(serviceDefinition, endpoint, varsToPassIntoImpl, info)
if err != nil {
return nil, err
}
body = append(body, returnStatements...)
return body, nil
}
func getReturnStatements(
serviceDefinition spec.ServiceDefinition,
endpoint spec.EndpointDefinition,
varsToPassIntoImpl []astgen.ASTExpr,
info types.PkgInfo,
) ([]astgen.ASTStmt, error) {
var body []astgen.ASTStmt
receiverName := getReceiverName(serviceDefinition)
endpointName := string(endpoint.EndpointName)
endpointNameFirstLetterUpper := strings.Title(endpointName)
// This is make the call to the interface
makeFunctionCall := expression.NewCallFunction(receiverName+"."+implName, endpointNameFirstLetterUpper, varsToPassIntoImpl...)
if endpoint.Returns == nil {
// The endpoint doesn't return anything, just return the interface call
body = append(body, &statement.Return{
Values: []astgen.ASTExpr{makeFunctionCall},
})
return body, nil
}
// Make the call
body = append(body, &statement.Assignment{
LHS: []astgen.ASTExpr{
expression.VariableVal(responseArgVarName),
expression.VariableVal(errorName),
},
Tok: token.DEFINE,
RHS: makeFunctionCall,
})
// Return an error if present
body = append(body, getIfErrNotNilReturnErrExpression())
var codec types.Typer
if isBinary, err := isBinaryType(*endpoint.Returns); err != nil {
return nil, err
} else if isBinary {
codec = types.CodecBinary
} else {
codec = types.CodecJSON
}
info.AddImports(codec.ImportPaths()...)
body = append(body, statement.NewExpression(&expression.CallExpression{
Function: &expression.Selector{
Receiver: expression.NewCallFunction(responseWriterVarName, "Header"),
Selector: "Add",
},
Args: []astgen.ASTExpr{
expression.StringVal("Content-Type"),
expression.NewCallFunction(codec.GoType(info), codecContentTypeFunc),
},
}))
// Return error from writing object into response
body = append(body, &statement.Return{
Values: []astgen.ASTExpr{
expression.NewCallFunction(codec.GoType(info), codecEncodeFunc,
expression.VariableVal(responseWriterVarName),
expression.VariableVal(responseArgVarName),
),
},
})
return body, nil
}
func getBodyParamStatements(bodyParam *visitors.ArgumentDefinitionBodyParam, info types.PkgInfo) ([]astgen.ASTStmt, error) {
if bodyParam == nil {
return nil, nil
}
var body []astgen.ASTStmt
argName := transforms.SafeName(string(bodyParam.ArgumentDefinition.ArgName))
typer, err := visitors.NewConjureTypeProviderTyper(bodyParam.ArgumentDefinition.Type, info)
if err != nil {
typJSON, _ := bodyParam.ArgumentDefinition.Type.MarshalJSON()
return nil, errors.Wrapf(err, "failed to process return type %s", string(typJSON))
}
info.AddImports(typer.ImportPaths()...)
if isBinary, err := isBinaryType(bodyParam.ArgumentDefinition.Type); err != nil {
return nil, err
} else if isBinary {
// If the body argument is binary, pass req.Body directly to the impl.
body = append(body, &statement.Assignment{
LHS: []astgen.ASTExpr{expression.VariableVal(argName)},
Tok: token.DEFINE,
RHS: expression.NewSelector(expression.VariableVal(requestVarName), "Body"),
})
} else {
// If the request is not binary, it is JSON. Unmarshal the req.Body.
// Create the empty type of this object
body = append(body, statement.NewDecl(decl.NewVar(argName, expression.Type(typer.GoType(info)))))
// Decode request
body = append(body, &statement.If{
Init: &statement.Assignment{
LHS: []astgen.ASTExpr{expression.VariableVal(errorName)},
Tok: token.DEFINE,
RHS: expression.NewCallFunction(
codecsJSON,
codecDecodeFunc,
expression.NewSelector(expression.VariableVal(requestVarName), "Body"),
expression.NewUnary(token.AND, expression.VariableVal(argName))),
},
Cond: getIfErrNotNilExpression(),
Body: []astgen.ASTStmt{statement.NewReturn(generateNewRestError("StatusBadRequest"))},
})
}
return body, nil
}
// rest.NewError(err, rest.StatusCode(http.$statusCode))
func generateNewRestError(statusCode string) *expression.CallExpression {
return expression.NewCallFunction(restImportPackage, "NewError",
expression.VariableVal(errorName),
expression.NewCallFunction(restImportPackage, "StatusCode",
expression.NewSelector(
expression.VariableVal(httpPackageName),
statusCode,
),
),
)
}
func getAuthStatements(auth *spec.AuthType, info types.PkgInfo) ([]astgen.ASTStmt, error) {
var body []astgen.ASTStmt
if auth == nil {
return body, nil
}
if headerAuth, err := visitors.GetPossibleHeaderAuth(*auth); err != nil {
return nil, err
} else if headerAuth != nil {
body = append(body,
// authHeader, err := rest.ParseBearerTokenHeader(req)
// if err != nil {
// return rest.NewError(err, rest.StatusCode(http.StatusForbidden))
// }
&statement.Assignment{
LHS: []astgen.ASTExpr{
expression.VariableVal(authHeaderVar),
expression.VariableVal(errorName),
},
Tok: token.DEFINE,
RHS: expression.NewCallFunction(restImportPackage, funcParseBearerTokenHeader, expression.VariableVal(requestVarName)),
},
&statement.If{
Cond: getIfErrNotNilExpression(),
Body: []astgen.ASTStmt{statement.NewReturn(generateNewRestError("StatusForbidden"))},
},
)
return body, nil
}
if cookieAuth, err := visitors.GetPossibleCookieAuth(*auth); err != nil {
return nil, err
} else if cookieAuth != nil {
// authCookie, err := req.Cookie("P_TOKEN")
// if err != nil {
// return rest.NewError(err, rest.StatusCode(http.StatusForbidden))
// }
// cookieToken := bearertoken.Token(authCookie.Value)
body = append(body,
&statement.Assignment{
LHS: []astgen.ASTExpr{
expression.VariableVal(authCookieVar),
expression.VariableVal(errorName),
},
Tok: token.DEFINE,
RHS: expression.NewCallFunction(requestVarName, "Cookie", expression.StringVal(cookieAuth.CookieName)),
},
&statement.If{
Cond: getIfErrNotNilExpression(),
Body: []astgen.ASTStmt{statement.NewReturn(
// rest.NewError(err, rest.StatusCode(http.StatusForbidden))
expression.NewCallFunction(restImportPackage, "NewError",
expression.VariableVal(errorName),
expression.NewCallFunction(restImportPackage, "StatusCode",
expression.NewSelector(
expression.VariableVal(httpPackageName),
"StatusForbidden",
),
),
),
)},
},
statement.NewAssignment(
expression.VariableVal(cookieTokenVar),
token.DEFINE,
expression.NewCallExpression(expression.Type(types.Bearertoken.GoType(info)),
expression.NewSelector(expression.VariableVal(authCookieVar), "Value"),
),
),
)
return body, nil
}
return nil, werror.Error("Unrecognized auth type", werror.SafeParam("authType", auth))
}
func getPathParamStatements(pathParams []visitors.ArgumentDefinitionPathParam, info types.PkgInfo) ([]astgen.ASTStmt, error) {
if len(pathParams) == 0 {
return nil, nil
}
var body []astgen.ASTStmt
// Validate path params
pathParamVar := "pathParams"
// Use call back to get the path params for this request
body = append(body, &statement.Assignment{
LHS: []astgen.ASTExpr{
expression.VariableVal(pathParamVar),
},
Tok: token.DEFINE,
RHS: expression.NewCallFunction(routerImportPackage, routerPathParamsMapFunc, expression.VariableVal(requestVarName)),
}, &statement.If{
Cond: &expression.Binary{
LHS: expression.VariableVal(pathParamVar),
Op: token.EQL,
RHS: expression.Nil,
},
Body: []astgen.ASTStmt{&statement.Return{Values: []astgen.ASTExpr{
werrorexpressions.CreateWErrorExpression("path params not found on request: ensure this endpoint is registered with wrouter", nil),
}}},
})
for _, pathParam := range pathParams {
arg := pathParam.ArgumentDefinition
isString, err := visitors.IsSpecificConjureType(arg.Type, visitors.IsString)
if err != nil {
return nil, err
}
var strVar expression.VariableVal
if isString {
strVar = expression.VariableVal(transforms.SafeName(string(arg.ArgName)))
} else {
strVar = expression.VariableVal(arg.ArgName + "Str")
}
// For each path param, pull out the value and if it is present in the map
// argNameStr, ok := pathParams["argName"]
body = append(body, &statement.Assignment{
LHS: []astgen.ASTExpr{
strVar,
expression.VariableVal("ok"),
},
Tok: token.DEFINE,
RHS: &expression.Index{
Receiver: expression.VariableVal(pathParamVar),
Index: expression.StringVal(visitors.GetParamID(arg)),
},
})
// Check if the param does not exist
// if !ok { return werror... }
errorIfNotPresent := werrorexpressions.CreateWErrorExpression("path param not present", map[string]string{"pathParamName": string(arg.ArgName)})
createWError := &statement.Assignment{
LHS: []astgen.ASTExpr{expression.VariableVal(errorName)},
Tok: token.DEFINE,
RHS: errorIfNotPresent,
}
body = append(body, &statement.If{
Cond: expression.NewUnary(token.NOT, expression.VariableVal(okName)),
Body: []astgen.ASTStmt{
createWError,
&statement.Return{Values: []astgen.ASTExpr{generateNewRestError("StatusBadRequest")}},
},
})
// type-specific unmarshal behavior
if !isString {
argName := spec.ArgumentName(transforms.SafeName(string(arg.ArgName)))
paramStmts, err := visitors.StatementsForHTTPParam(argName, arg.Type, strVar, info)
if err != nil {
return nil, err
}
body = append(body, paramStmts...)
}
}
return body, nil
}
func getHeaderParamStatements(headerParams []visitors.ArgumentDefinitionHeaderParam, info types.PkgInfo) ([]astgen.ASTStmt, error) {
var body []astgen.ASTStmt
for _, headerParam := range headerParams {
arg := headerParam.ArgumentDefinition
// Pull out the header from the request
// req.Header.Get("paramID")
getHeader := &expression.CallExpression{
Function: &expression.Selector{
Receiver: &expression.Selector{
Receiver: expression.VariableVal(requestVarName),
Selector: requestHeaderFunc,
},
Selector: "Get",
},
Args: []astgen.ASTExpr{
expression.StringVal(visitors.GetParamID(headerParam.ArgumentDefinition)),
},
}
// type-specific unmarshal behavior
argName := spec.ArgumentName(transforms.SafeName(string(arg.ArgName)))
paramStmts, err := visitors.StatementsForHTTPParam(argName, arg.Type, getHeader, info)
if err != nil {
return nil, err
}
body = append(body, paramStmts...)
}
return body, nil
}
func getQueryParamStatements(queryParams []visitors.ArgumentDefinitionQueryParam, info types.PkgInfo) ([]astgen.ASTStmt, error) {
var body []astgen.ASTStmt
for _, queryParam := range queryParams {
arg := queryParam.ArgumentDefinition
// Pull out the query param from the request URL
// req.URL.Query.Get("paramID")
getQuery, err := getQueryFetchExpression(queryParam)
if err != nil {
return nil, err
}
ifErrNotNilReturnErrStatement("err", nil)
argName := spec.ArgumentName(transforms.SafeName(string(arg.ArgName)))
paramStmts, err := visitors.StatementsForHTTPParam(argName, arg.Type, getQuery, info)
if err != nil {
return nil, err
}
body = append(body, paramStmts...)
}
return body, nil
}
func getQueryFetchExpression(queryParam visitors.ArgumentDefinitionQueryParam) (astgen.ASTExpr, error) {
arg := queryParam.ArgumentDefinition
typeProvider, err := visitors.NewConjureTypeProvider(arg.Type)
if err != nil {
return nil, err
}
if typeProvider.IsSpecificType(visitors.IsSet) || typeProvider.IsSpecificType(visitors.IsList) {
// req.URL.Query()["paramID"]
selector := visitors.GetParamID(queryParam.ArgumentDefinition)
return expression.NewIndex(&expression.CallExpression{
Function: &expression.Selector{
Receiver: &expression.Selector{
Receiver: expression.VariableVal(requestVarName),
Selector: requestURLField,
},
Selector: urlQueryFunc,
},
}, expression.StringVal(selector)), nil
}
// req.URL.Query.Get("paramID")
return &expression.CallExpression{
Function: &expression.Selector{
Receiver: &expression.CallExpression{
Function: &expression.Selector{
Receiver: &expression.Selector{
Receiver: expression.VariableVal(requestVarName),
Selector: requestURLField,
},
Selector: urlQueryFunc,
},
},
Selector: "Get",
},
Args: []astgen.ASTExpr{
expression.StringVal(visitors.GetParamID(queryParam.ArgumentDefinition)),
},
}, nil
}
func getHandlerStruct(serviceDefinition spec.ServiceDefinition) *decl.Struct {
return &decl.Struct{
Name: getHandlerStuctName(serviceDefinition),
StructType: expression.StructType{
Fields: []*expression.StructField{
{
Name: implName,
Type: expression.Type(serviceDefinition.ServiceName.Name),
},
},
},
}
}
func getIfErrNotNilReturnErrExpression() astgen.ASTStmt {
return &statement.If{
Cond: getIfErrNotNilExpression(),
Body: []astgen.ASTStmt{&statement.Return{Values: []astgen.ASTExpr{expression.VariableVal(errorName)}}},
}
}
func getIfErrNotNilExpression() astgen.ASTExpr {
return &expression.Binary{
LHS: expression.VariableVal(errorName),
Op: token.NEQ,
RHS: expression.Nil,
}
}
func getHandlerStuctName(serviceDefinition spec.ServiceDefinition) string {
name := serviceDefinition.ServiceName.Name
firstCharLower := strings.ToLower(string(name[0]))
return strings.Join([]string{firstCharLower, name[1:], handlerStructNameSuffix}, "")
}
func getReceiverName(serviceDefinition spec.ServiceDefinition) string {
return string(getHandlerStuctName(serviceDefinition)[0])
}
// rest.NewJSONHandler(funcExpr, rest.StatusCodeMapper, rest.ErrHandler)
func astForRestJSONHandler(funcExpr astgen.ASTExpr) astgen.ASTExpr {
return expression.NewCallFunction(restImportPackage, "NewJSONHandler",
funcExpr,
expression.NewSelector(expression.VariableVal(restImportPackage), "StatusCodeMapper"),
expression.NewSelector(expression.VariableVal(restImportPackage), "ErrHandler"),
)
} | Init: statement.NewAssignment(
expression.VariableVal(errorName), |
tmpl.go | package main
const authTmpl = `
<!DOCTYPE html>
<html lang="tw">
<head>
<title></title>
<meta charset="UTF-8"> | var URL = 'https://notify-bot.line.me/oauth/authorize?';
URL += 'response_type=code';
URL += '&client_id={{.ClientID}}';
URL += '&redirect_uri={{.CallbackURL}}';
URL += '&scope=notify';
URL += '&state=NO_STATE';
window.location.href = URL;
}
</script>
</head>
<body>
<button onclick="oAuth2();"> 連結到 LineNotify 按鈕 </button>
</body>
` | <meta name="viewport" content="width=device-width, initial-scale=1">
<script>
function oAuth2() { |
amqp-connection-options.storage.ts | import { AMQPConnectionOptions } from '../../interface';
export class AMQConnectionOptionsStorage {
/**
* Add Queue Module Options to storage for connection
*
* @param {string} name Name of the connection, will be used as key
* @param {Options} options The options object
*/
public static add(name: string, options: AMQPConnectionOptions): void {
this.storage.set(name, options);
}
/**
* Retreive stored from storage for connection
*
* @param {string} name Name of the connection
*
* @returns {Options | null} The stored connection or null
*/
public static get(name: string): AMQPConnectionOptions | null {
if (!name) {
return null;
}
return this.storage.get(name) || null;
}
/**
* Get all connection keys | public static getKeys(): string[] {
return Array.from(this.storage.keys());
}
private static readonly storage = new Map<string, AMQPConnectionOptions>();
} | *
* @returns {string[]}
*/ |
StudentsManager.js | import React from 'react';
import { Helmet } from 'react-helmet';
import { Box, Container } from '@material-ui/core';
import LectureList from 'src/components/customer/LectureList';
import CustomerListToolbar from 'src/components/customer/CustomerListToolbar';
export default function StudentsManager () {
return (
<>
<Helmet>
<title>Students | 1984</title>
</Helmet>
<Box
sx={{
backgroundColor: 'background.default',
minHeight: '100%',
py: 3
}}
>
<Container maxWidth={false}>
<CustomerListToolbar />
<Box sx={{ pt: 3 }}>
<LectureList/> | </Box>
</>
);
} | </Box>
</Container> |
getRunAppsInfo.py | #!/usr/bin/env python3
"""This module provides the PID and the log file name of the running DQM
applications (consumers), thus completing the information generated by
ExtractAppInfoFromXML.
When used as a script the following options are accepted:
-f Show all columns
-h show headers
"""
from __future__ import print_function
import sys
import os.path
import getopt as gop
import ExtractAppInfoFromXML as appinf
# ssh srv-c2d05-18.cms ps -eo pid,cmd | grep 22101
################################################################################
def getAppPID(srv,port):
try:
print("Connecting to server: "+srv+" and fetching PID for application running on port: "+port)
cf=os.popen('ssh '+srv+' ps -eo pid,cmd | grep '+port)
l=cf.readline();
if l=="":
cf.close()
return "App Not Running"
else:
pidv=l.split()
cf.close();
return pidv[0]
except:
sys.stderr.write( "Something went really bad\n" )
return -1
################################################################################
def getAppLogFileName(srv,pid):
# try:
#pid=getAppPID(srv,port)
if pid=="App Not Running":
return "No active log file"
else:
print("Connecting to server: "+srv+" and fetching LogFile for application with PID: "+pid)
cf=os.popen('ssh '+srv+' ls -l /tmp | grep '+pid)
l=cf.readline();
if l=="":
cf.close()
return "App Not Running???"
else:
logfilev=l.split()
cf.close();
return logfilev[-1]
# except Exception,e:
# sys.stderr.write( "Something went really bad\n" + e[0])
# return -1
################################################################################
def | (filename):
(table,grid)=appinf.getAppInfo(filename,2,1,3,4)
for apps in grid:
apps.insert(3,getAppPID(apps[1],apps[2]))
apps.insert(4,getAppLogFileName(apps[1],apps[3]))
return grid
################################################################################
#Script operation #
################################################################################
if __name__ == "__main__":
fullinfo=False
headers=False
try:
(args,filename)=gop.getopt(sys.argv[1:],"hf",["help"])
except getopt.GetoptError:
sys.stderr.write( "Sintax Error unrecognised option" )
sys.stderr.write( __doc__ )
sys.exit(2)
for item in args:
if item[0]=="-h":
headers=True
elif item[0]=="-f":
fullinfo=True
elif item[0]=="--help":
sys.stdout.write(__doc__)
sys.exit(2)
if len(filename)==0:
sys.stderr.write( "\nERROR: xdaq XML config file name not present, please specify\n\n" )
sys.stdout.write(__doc__)
elif len(filename) > 1:
sys.stderr.write( "\nERROR: Too many file names or other arguments, please specify only 1\n\n" )
sys.stdout.write(__doc__)
sys.exit(2)
elif not os.path.exists(filename[0]):
sys.stderr.write( "\nERROR: xdaq XML config file does not exist please verify\n\n" )
sys.stdout.write(__doc__)
sys.exit(2)
grid=getRunningAppsInfo(filename[0])
if fullinfo:
if headers:
grid.insert(0,["Application","Server","Port","PID","LogfileName","App Config File"])
else:
if headers:
i=0;
for record in grid:
newrecord=[record[0],record[3],record[4]]
grid[i]=newrecord
del record
i+=1
grid.insert(0,["Application","PID","LogfileName"])
else:
i=0;
for record in grid:
newrecord=[record[0],record[3],record[4]]
grid[i]=newrecord
del record
i+=1
appinf.printGrid(grid)
| getRunningAppsInfo |
foreign.spec.ts | // Copyright (c) Jupyter Development Team.
// Distributed under the terms of the Modified BSD License.
import expect = require('expect.js');
import {
uuid
} from '@jupyterlab/coreutils';
import {
KernelMessage, Session
} from '@jupyterlab/services';
import {
Signal
} from '@phosphor/signaling';
import {
Panel
} from '@phosphor/widgets';
import {
IClientSession
} from '@jupyterlab/apputils';
import {
ForeignHandler
} from '@jupyterlab/console';
import {
CodeCellModel, CodeCell
} from '@jupyterlab/cells';
import {
createCodeCellFactory
} from '../notebook/utils';
import {
createClientSession, defaultRenderMime
} from '../utils';
class TestParent extends Panel implements ForeignHandler.IReceiver {
addCell(cell: CodeCell): void {
this.addWidget(cell);
}
}
class | extends ForeignHandler {
injected = new Signal<this, void>(this);
received = new Signal<this, void>(this);
rejected = new Signal<this, void>(this);
methods: string[] = [];
protected onIOPubMessage(sender: IClientSession, msg: KernelMessage.IIOPubMessage): boolean {
let injected = super.onIOPubMessage(sender, msg);
this.received.emit(void 0);
if (injected) {
this.injected.emit(void 0);
} else {
// If the message was not injected but otherwise would have been, emit
// a rejected signal. This should only happen if `enabled` is `false`.
let session = (msg.parent_header as KernelMessage.IHeader).session;
let msgType = msg.header.msg_type;
if (session !== this.session.kernel.clientId && relevantTypes.has(msgType)) {
this.rejected.emit(void 0);
}
}
return injected;
}
}
const rendermime = defaultRenderMime();
function cellFactory(): CodeCell {
let contentFactory = createCodeCellFactory();
let model = new CodeCellModel({});
let cell = new CodeCell({ model, rendermime, contentFactory });
return cell;
}
const relevantTypes = [
'execute_input',
'execute_result',
'display_data',
'stream',
'error',
'clear_output'
].reduce((acc, val) => {
acc.add(val);
return acc;
}, new Set<string>());
describe('@jupyterlab/console', () => {
describe('ForeignHandler', () => {
let local: Session.ISession;
let foreign: Session.ISession;
let handler: TestHandler;
let session: IClientSession;
before(() => {
let path = uuid();
let sessions = [Session.startNew({ path }), Session.startNew({ path })];
return Promise.all(sessions).then(([one, two]) => {
local = one;
foreign = two;
}).then(() => {
return createClientSession({ path: local.path });
}).then(s => {
session = s;
return s.initialize();
});
});
beforeEach(() => {
let parent = new TestParent();
handler = new TestHandler({ session, parent, cellFactory });
});
afterEach(() => {
handler.dispose();
});
after(() => {
local.dispose();
foreign.dispose();
return session.shutdown().then(() => {
session.dispose();
});
});
describe('#constructor()', () => {
it('should create a new foreign handler', () => {
expect(handler).to.be.a(ForeignHandler);
});
});
describe('#enabled', () => {
it('should default to `true`', () => {
expect(handler.enabled).to.be(true);
});
it('should allow foreign cells to be injected if `true`', done => {
let code = 'print("#enabled:true")';
handler.injected.connect(() => { done(); });
foreign.kernel.requestExecute({ code, stop_on_error: true });
});
it('should reject foreign cells if `false`', done => {
let code = 'print("#enabled:false")';
handler.enabled = false;
handler.rejected.connect(() => { done(); });
foreign.kernel.requestExecute({ code, stop_on_error: true });
});
});
describe('#isDisposed', () => {
it('should indicate whether the handler is disposed', () => {
expect(handler.isDisposed).to.be(false);
handler.dispose();
expect(handler.isDisposed).to.be(true);
});
});
describe('#session', () => {
it('should be a client session object', () => {
expect(handler.session.path).to.ok();
});
});
describe('#parent', () => {
it('should be set upon instantiation', () => {
let parent = new TestParent();
handler = new TestHandler({
session: handler.session, parent, cellFactory
});
expect(handler.parent).to.be(parent);
});
});
describe('#dispose()', () => {
it('should dispose the resources held by the handler', () => {
expect(handler.isDisposed).to.be(false);
handler.dispose();
expect(handler.isDisposed).to.be(true);
});
it('should be safe to call multiple times', () => {
expect(handler.isDisposed).to.be(false);
handler.dispose();
handler.dispose();
expect(handler.isDisposed).to.be(true);
});
});
describe('#onIOPubMessage()', () => {
it('should be called when messages come through', done => {
let code = 'print("onIOPubMessage:disabled")';
handler.enabled = false;
handler.received.connect(() => { done(); });
foreign.kernel.requestExecute({ code, stop_on_error: true });
});
it('should inject relevant cells into the parent', done => {
let code = 'print("#onIOPubMessage:enabled")';
let parent = handler.parent as TestParent;
expect(parent.widgets.length).to.be(0);
handler.injected.connect(() => {
expect(parent.widgets.length).to.be.greaterThan(0);
done();
});
foreign.kernel.requestExecute({ code, stop_on_error: true });
});
it('should not reject relevant iopub messages', done => {
let code = 'print("#onIOPubMessage:relevant")';
let called = 0;
handler.rejected.connect(() => {
done(new Error('rejected relevant iopub message'));
});
handler.injected.connect(() => {
if (++called === 2) {
done();
}
});
foreign.kernel.requestExecute({ code, stop_on_error: true });
});
});
});
});
| TestHandler |
BACnetObjectType.go | //
// 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.
//
package model
import (
"encoding/xml"
"fmt"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
"io"
)
// Code generated by build-utils. DO NOT EDIT.
type BACnetObjectType uint16
type IBACnetObjectType interface {
Serialize(io utils.WriteBuffer) error
xml.Marshaler
xml.Unmarshaler
}
const (
BACnetObjectType_ANALOG_INPUT BACnetObjectType = 0x000
BACnetObjectType_ANALOG_OUTPUT BACnetObjectType = 0x001
BACnetObjectType_ANALOG_VALUE BACnetObjectType = 0x002
BACnetObjectType_BINARY_INPUT BACnetObjectType = 0x003
BACnetObjectType_BINARY_OUTPUT BACnetObjectType = 0x004
BACnetObjectType_BINARY_VALUE BACnetObjectType = 0x005
BACnetObjectType_MULTISTATE_INPUT BACnetObjectType = 0x00D
BACnetObjectType_MULTISTATE_OUTPUT BACnetObjectType = 0x00E
BACnetObjectType_MULTISTATE_VALUE BACnetObjectType = 0x013
BACnetObjectType_SCHEDULE BACnetObjectType = 0x011
BACnetObjectType_DEVICE BACnetObjectType = 0x008
BACnetObjectType_CALENDAR BACnetObjectType = 0x006
BACnetObjectType_COMMAND BACnetObjectType = 0x007
BACnetObjectType_EVENT_ENROLLMENT BACnetObjectType = 0x009
BACnetObjectType_FILE BACnetObjectType = 0x00A
BACnetObjectType_GROUP BACnetObjectType = 0x00B
BACnetObjectType_LOOP BACnetObjectType = 0x00C
BACnetObjectType_NOTIFICATION_CLASS BACnetObjectType = 0x00F
BACnetObjectType_PROGRAM BACnetObjectType = 0x010
BACnetObjectType_AVERAGING BACnetObjectType = 0x012
BACnetObjectType_TREND_LOG BACnetObjectType = 0x014
BACnetObjectType_LIFE_SAFETY_POINT BACnetObjectType = 0x015
BACnetObjectType_LIFE_SAFETY_ZONE BACnetObjectType = 0x016
BACnetObjectType_ACCUMULATOR BACnetObjectType = 0x017
BACnetObjectType_PULSE_CONVERTER BACnetObjectType = 0x018
BACnetObjectType_EVENT_LOG BACnetObjectType = 0x019
BACnetObjectType_GLOBAL_GROUP BACnetObjectType = 0x01A
BACnetObjectType_TREND_LOG_MULTIPLE BACnetObjectType = 0x01B
BACnetObjectType_LOAD_CONTROL BACnetObjectType = 0x01C
BACnetObjectType_STRUCTURED_VIEW BACnetObjectType = 0x01D
BACnetObjectType_ACCESS_DOOR BACnetObjectType = 0x01E
BACnetObjectType_TIMER BACnetObjectType = 0x01F
BACnetObjectType_ACCESS_CREDENTIAL BACnetObjectType = 0x020
BACnetObjectType_ACCESS_POINT BACnetObjectType = 0x021
BACnetObjectType_ACCESS_RIGHTS BACnetObjectType = 0x022
BACnetObjectType_ACCESS_USER BACnetObjectType = 0x023
BACnetObjectType_ACCESS_ZONE BACnetObjectType = 0x024
BACnetObjectType_CREDENTIAL_DATA_INPUT BACnetObjectType = 0x025
BACnetObjectType_NETWORK_SECURITY BACnetObjectType = 0x026
BACnetObjectType_BITSTRING_VALUE BACnetObjectType = 0x027
BACnetObjectType_CHARACTERSTRING_VALUE BACnetObjectType = 0x028
BACnetObjectType_DATEPATTERN_VALUE BACnetObjectType = 0x029
BACnetObjectType_DATE_VALUE BACnetObjectType = 0x02A
BACnetObjectType_DATETIMEPATTERN_VALUE BACnetObjectType = 0x02B
BACnetObjectType_DATETIME_VALUE BACnetObjectType = 0x02C
BACnetObjectType_INTEGER_VALUE BACnetObjectType = 0x02D
BACnetObjectType_LARGE_ANALOG_VALUE BACnetObjectType = 0x02E
BACnetObjectType_OCTETSTRING_VALUE BACnetObjectType = 0x02F
BACnetObjectType_POSITIVE_INTEGER_VALUE BACnetObjectType = 0x030
BACnetObjectType_TIMEPATTERN_VALUE BACnetObjectType = 0x031
BACnetObjectType_TIME_VALUE BACnetObjectType = 0x032
BACnetObjectType_NOTIFICATION_FORWARDER BACnetObjectType = 0x033
BACnetObjectType_ALERT_ENROLLMENT BACnetObjectType = 0x034
BACnetObjectType_CHANNEL BACnetObjectType = 0x035
BACnetObjectType_LIGHTING_OUTPUT BACnetObjectType = 0x036
BACnetObjectType_BINARY_LIGHTING_OUTPUT BACnetObjectType = 0x037
BACnetObjectType_NETWORK_PORT BACnetObjectType = 0x038
BACnetObjectType_ELEVATOR_GROUP BACnetObjectType = 0x039
BACnetObjectType_ESCALATOR BACnetObjectType = 0x03A
)
var BACnetObjectTypeValues []BACnetObjectType
func init() {
BACnetObjectTypeValues = []BACnetObjectType{
BACnetObjectType_ANALOG_INPUT,
BACnetObjectType_ANALOG_OUTPUT,
BACnetObjectType_ANALOG_VALUE,
BACnetObjectType_BINARY_INPUT,
BACnetObjectType_BINARY_OUTPUT,
BACnetObjectType_BINARY_VALUE,
BACnetObjectType_MULTISTATE_INPUT,
BACnetObjectType_MULTISTATE_OUTPUT,
BACnetObjectType_MULTISTATE_VALUE,
BACnetObjectType_SCHEDULE,
BACnetObjectType_DEVICE,
BACnetObjectType_CALENDAR,
BACnetObjectType_COMMAND,
BACnetObjectType_EVENT_ENROLLMENT,
BACnetObjectType_FILE,
BACnetObjectType_GROUP,
BACnetObjectType_LOOP,
BACnetObjectType_NOTIFICATION_CLASS,
BACnetObjectType_PROGRAM,
BACnetObjectType_AVERAGING,
BACnetObjectType_TREND_LOG,
BACnetObjectType_LIFE_SAFETY_POINT,
BACnetObjectType_LIFE_SAFETY_ZONE,
BACnetObjectType_ACCUMULATOR,
BACnetObjectType_PULSE_CONVERTER,
BACnetObjectType_EVENT_LOG,
BACnetObjectType_GLOBAL_GROUP,
BACnetObjectType_TREND_LOG_MULTIPLE,
BACnetObjectType_LOAD_CONTROL,
BACnetObjectType_STRUCTURED_VIEW,
BACnetObjectType_ACCESS_DOOR,
BACnetObjectType_TIMER,
BACnetObjectType_ACCESS_CREDENTIAL,
BACnetObjectType_ACCESS_POINT,
BACnetObjectType_ACCESS_RIGHTS,
BACnetObjectType_ACCESS_USER,
BACnetObjectType_ACCESS_ZONE,
BACnetObjectType_CREDENTIAL_DATA_INPUT,
BACnetObjectType_NETWORK_SECURITY,
BACnetObjectType_BITSTRING_VALUE,
BACnetObjectType_CHARACTERSTRING_VALUE,
BACnetObjectType_DATEPATTERN_VALUE,
BACnetObjectType_DATE_VALUE,
BACnetObjectType_DATETIMEPATTERN_VALUE,
BACnetObjectType_DATETIME_VALUE,
BACnetObjectType_INTEGER_VALUE,
BACnetObjectType_LARGE_ANALOG_VALUE,
BACnetObjectType_OCTETSTRING_VALUE,
BACnetObjectType_POSITIVE_INTEGER_VALUE,
BACnetObjectType_TIMEPATTERN_VALUE,
BACnetObjectType_TIME_VALUE,
BACnetObjectType_NOTIFICATION_FORWARDER,
BACnetObjectType_ALERT_ENROLLMENT,
BACnetObjectType_CHANNEL,
BACnetObjectType_LIGHTING_OUTPUT,
BACnetObjectType_BINARY_LIGHTING_OUTPUT,
BACnetObjectType_NETWORK_PORT,
BACnetObjectType_ELEVATOR_GROUP,
BACnetObjectType_ESCALATOR,
}
}
func BACnetObjectTypeByValue(value uint16) BACnetObjectType {
switch value {
case 0x000:
return BACnetObjectType_ANALOG_INPUT
case 0x001:
return BACnetObjectType_ANALOG_OUTPUT
case 0x002:
return BACnetObjectType_ANALOG_VALUE
case 0x003:
return BACnetObjectType_BINARY_INPUT
case 0x004:
return BACnetObjectType_BINARY_OUTPUT
case 0x005:
return BACnetObjectType_BINARY_VALUE
case 0x006:
return BACnetObjectType_CALENDAR
case 0x007:
return BACnetObjectType_COMMAND
case 0x008:
return BACnetObjectType_DEVICE
case 0x009:
return BACnetObjectType_EVENT_ENROLLMENT
case 0x00A:
return BACnetObjectType_FILE
case 0x00B:
return BACnetObjectType_GROUP
case 0x00C:
return BACnetObjectType_LOOP
case 0x00D:
return BACnetObjectType_MULTISTATE_INPUT
case 0x00E:
return BACnetObjectType_MULTISTATE_OUTPUT
case 0x00F:
return BACnetObjectType_NOTIFICATION_CLASS
case 0x010:
return BACnetObjectType_PROGRAM
case 0x011:
return BACnetObjectType_SCHEDULE
case 0x012:
return BACnetObjectType_AVERAGING
case 0x013:
return BACnetObjectType_MULTISTATE_VALUE
case 0x014:
return BACnetObjectType_TREND_LOG
case 0x015:
return BACnetObjectType_LIFE_SAFETY_POINT
case 0x016:
return BACnetObjectType_LIFE_SAFETY_ZONE
case 0x017:
return BACnetObjectType_ACCUMULATOR
case 0x018:
return BACnetObjectType_PULSE_CONVERTER
case 0x019:
return BACnetObjectType_EVENT_LOG
case 0x01A:
return BACnetObjectType_GLOBAL_GROUP
case 0x01B:
return BACnetObjectType_TREND_LOG_MULTIPLE
case 0x01C:
return BACnetObjectType_LOAD_CONTROL
case 0x01D:
return BACnetObjectType_STRUCTURED_VIEW
case 0x01E:
return BACnetObjectType_ACCESS_DOOR
case 0x01F:
return BACnetObjectType_TIMER
case 0x020:
return BACnetObjectType_ACCESS_CREDENTIAL
case 0x021:
return BACnetObjectType_ACCESS_POINT
case 0x022:
return BACnetObjectType_ACCESS_RIGHTS
case 0x023:
return BACnetObjectType_ACCESS_USER
case 0x024:
return BACnetObjectType_ACCESS_ZONE
case 0x025:
return BACnetObjectType_CREDENTIAL_DATA_INPUT
case 0x026:
return BACnetObjectType_NETWORK_SECURITY
case 0x027:
return BACnetObjectType_BITSTRING_VALUE
case 0x028:
return BACnetObjectType_CHARACTERSTRING_VALUE
case 0x029:
return BACnetObjectType_DATEPATTERN_VALUE
case 0x02A:
return BACnetObjectType_DATE_VALUE
case 0x02B:
return BACnetObjectType_DATETIMEPATTERN_VALUE
case 0x02C:
return BACnetObjectType_DATETIME_VALUE
case 0x02D:
return BACnetObjectType_INTEGER_VALUE
case 0x02E:
return BACnetObjectType_LARGE_ANALOG_VALUE
case 0x02F:
return BACnetObjectType_OCTETSTRING_VALUE
case 0x030:
return BACnetObjectType_POSITIVE_INTEGER_VALUE
case 0x031:
return BACnetObjectType_TIMEPATTERN_VALUE
case 0x032:
return BACnetObjectType_TIME_VALUE
case 0x033:
return BACnetObjectType_NOTIFICATION_FORWARDER
case 0x034:
return BACnetObjectType_ALERT_ENROLLMENT
case 0x035:
return BACnetObjectType_CHANNEL
case 0x036:
return BACnetObjectType_LIGHTING_OUTPUT
case 0x037:
return BACnetObjectType_BINARY_LIGHTING_OUTPUT
case 0x038:
return BACnetObjectType_NETWORK_PORT
case 0x039:
return BACnetObjectType_ELEVATOR_GROUP
case 0x03A:
return BACnetObjectType_ESCALATOR
}
return 0
}
func BACnetObjectTypeByName(value string) BACnetObjectType |
func CastBACnetObjectType(structType interface{}) BACnetObjectType {
castFunc := func(typ interface{}) BACnetObjectType {
if sBACnetObjectType, ok := typ.(BACnetObjectType); ok {
return sBACnetObjectType
}
return 0
}
return castFunc(structType)
}
func (m BACnetObjectType) LengthInBits() uint16 {
return 10
}
func (m BACnetObjectType) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
func BACnetObjectTypeParse(io utils.ReadBuffer) (BACnetObjectType, error) {
val, err := io.ReadUint16("BACnetObjectType", 10)
if err != nil {
return 0, nil
}
return BACnetObjectTypeByValue(val), nil
}
func (e BACnetObjectType) Serialize(io utils.WriteBuffer) error {
err := io.WriteUint16("BACnetObjectType", 10, uint16(e), utils.WithAdditionalStringRepresentation(e.name()))
return err
}
func (m *BACnetObjectType) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
var token xml.Token
var err error
for {
token, err = d.Token()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
switch token.(type) {
case xml.CharData:
tok := token.(xml.CharData)
*m = BACnetObjectTypeByName(string(tok))
}
}
}
func (m BACnetObjectType) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
if err := e.EncodeElement(m.String(), start); err != nil {
return err
}
return nil
}
func (e BACnetObjectType) name() string {
switch e {
case BACnetObjectType_ANALOG_INPUT:
return "ANALOG_INPUT"
case BACnetObjectType_ANALOG_OUTPUT:
return "ANALOG_OUTPUT"
case BACnetObjectType_ANALOG_VALUE:
return "ANALOG_VALUE"
case BACnetObjectType_BINARY_INPUT:
return "BINARY_INPUT"
case BACnetObjectType_BINARY_OUTPUT:
return "BINARY_OUTPUT"
case BACnetObjectType_BINARY_VALUE:
return "BINARY_VALUE"
case BACnetObjectType_CALENDAR:
return "CALENDAR"
case BACnetObjectType_COMMAND:
return "COMMAND"
case BACnetObjectType_DEVICE:
return "DEVICE"
case BACnetObjectType_EVENT_ENROLLMENT:
return "EVENT_ENROLLMENT"
case BACnetObjectType_FILE:
return "FILE"
case BACnetObjectType_GROUP:
return "GROUP"
case BACnetObjectType_LOOP:
return "LOOP"
case BACnetObjectType_MULTISTATE_INPUT:
return "MULTISTATE_INPUT"
case BACnetObjectType_MULTISTATE_OUTPUT:
return "MULTISTATE_OUTPUT"
case BACnetObjectType_NOTIFICATION_CLASS:
return "NOTIFICATION_CLASS"
case BACnetObjectType_PROGRAM:
return "PROGRAM"
case BACnetObjectType_SCHEDULE:
return "SCHEDULE"
case BACnetObjectType_AVERAGING:
return "AVERAGING"
case BACnetObjectType_MULTISTATE_VALUE:
return "MULTISTATE_VALUE"
case BACnetObjectType_TREND_LOG:
return "TREND_LOG"
case BACnetObjectType_LIFE_SAFETY_POINT:
return "LIFE_SAFETY_POINT"
case BACnetObjectType_LIFE_SAFETY_ZONE:
return "LIFE_SAFETY_ZONE"
case BACnetObjectType_ACCUMULATOR:
return "ACCUMULATOR"
case BACnetObjectType_PULSE_CONVERTER:
return "PULSE_CONVERTER"
case BACnetObjectType_EVENT_LOG:
return "EVENT_LOG"
case BACnetObjectType_GLOBAL_GROUP:
return "GLOBAL_GROUP"
case BACnetObjectType_TREND_LOG_MULTIPLE:
return "TREND_LOG_MULTIPLE"
case BACnetObjectType_LOAD_CONTROL:
return "LOAD_CONTROL"
case BACnetObjectType_STRUCTURED_VIEW:
return "STRUCTURED_VIEW"
case BACnetObjectType_ACCESS_DOOR:
return "ACCESS_DOOR"
case BACnetObjectType_TIMER:
return "TIMER"
case BACnetObjectType_ACCESS_CREDENTIAL:
return "ACCESS_CREDENTIAL"
case BACnetObjectType_ACCESS_POINT:
return "ACCESS_POINT"
case BACnetObjectType_ACCESS_RIGHTS:
return "ACCESS_RIGHTS"
case BACnetObjectType_ACCESS_USER:
return "ACCESS_USER"
case BACnetObjectType_ACCESS_ZONE:
return "ACCESS_ZONE"
case BACnetObjectType_CREDENTIAL_DATA_INPUT:
return "CREDENTIAL_DATA_INPUT"
case BACnetObjectType_NETWORK_SECURITY:
return "NETWORK_SECURITY"
case BACnetObjectType_BITSTRING_VALUE:
return "BITSTRING_VALUE"
case BACnetObjectType_CHARACTERSTRING_VALUE:
return "CHARACTERSTRING_VALUE"
case BACnetObjectType_DATEPATTERN_VALUE:
return "DATEPATTERN_VALUE"
case BACnetObjectType_DATE_VALUE:
return "DATE_VALUE"
case BACnetObjectType_DATETIMEPATTERN_VALUE:
return "DATETIMEPATTERN_VALUE"
case BACnetObjectType_DATETIME_VALUE:
return "DATETIME_VALUE"
case BACnetObjectType_INTEGER_VALUE:
return "INTEGER_VALUE"
case BACnetObjectType_LARGE_ANALOG_VALUE:
return "LARGE_ANALOG_VALUE"
case BACnetObjectType_OCTETSTRING_VALUE:
return "OCTETSTRING_VALUE"
case BACnetObjectType_POSITIVE_INTEGER_VALUE:
return "POSITIVE_INTEGER_VALUE"
case BACnetObjectType_TIMEPATTERN_VALUE:
return "TIMEPATTERN_VALUE"
case BACnetObjectType_TIME_VALUE:
return "TIME_VALUE"
case BACnetObjectType_NOTIFICATION_FORWARDER:
return "NOTIFICATION_FORWARDER"
case BACnetObjectType_ALERT_ENROLLMENT:
return "ALERT_ENROLLMENT"
case BACnetObjectType_CHANNEL:
return "CHANNEL"
case BACnetObjectType_LIGHTING_OUTPUT:
return "LIGHTING_OUTPUT"
case BACnetObjectType_BINARY_LIGHTING_OUTPUT:
return "BINARY_LIGHTING_OUTPUT"
case BACnetObjectType_NETWORK_PORT:
return "NETWORK_PORT"
case BACnetObjectType_ELEVATOR_GROUP:
return "ELEVATOR_GROUP"
case BACnetObjectType_ESCALATOR:
return "ESCALATOR"
}
return ""
}
func (e BACnetObjectType) String() string {
return e.name()
}
func (m BACnetObjectType) Box(s string, i int) utils.AsciiBox {
boxName := "BACnetObjectType"
if s != "" {
boxName += "/" + s
}
return utils.BoxString(boxName, fmt.Sprintf("%#0*x %s", 3, uint16(m), m.name()), -1)
}
| {
switch value {
case "ANALOG_INPUT":
return BACnetObjectType_ANALOG_INPUT
case "ANALOG_OUTPUT":
return BACnetObjectType_ANALOG_OUTPUT
case "ANALOG_VALUE":
return BACnetObjectType_ANALOG_VALUE
case "BINARY_INPUT":
return BACnetObjectType_BINARY_INPUT
case "BINARY_OUTPUT":
return BACnetObjectType_BINARY_OUTPUT
case "BINARY_VALUE":
return BACnetObjectType_BINARY_VALUE
case "CALENDAR":
return BACnetObjectType_CALENDAR
case "COMMAND":
return BACnetObjectType_COMMAND
case "DEVICE":
return BACnetObjectType_DEVICE
case "EVENT_ENROLLMENT":
return BACnetObjectType_EVENT_ENROLLMENT
case "FILE":
return BACnetObjectType_FILE
case "GROUP":
return BACnetObjectType_GROUP
case "LOOP":
return BACnetObjectType_LOOP
case "MULTISTATE_INPUT":
return BACnetObjectType_MULTISTATE_INPUT
case "MULTISTATE_OUTPUT":
return BACnetObjectType_MULTISTATE_OUTPUT
case "NOTIFICATION_CLASS":
return BACnetObjectType_NOTIFICATION_CLASS
case "PROGRAM":
return BACnetObjectType_PROGRAM
case "SCHEDULE":
return BACnetObjectType_SCHEDULE
case "AVERAGING":
return BACnetObjectType_AVERAGING
case "MULTISTATE_VALUE":
return BACnetObjectType_MULTISTATE_VALUE
case "TREND_LOG":
return BACnetObjectType_TREND_LOG
case "LIFE_SAFETY_POINT":
return BACnetObjectType_LIFE_SAFETY_POINT
case "LIFE_SAFETY_ZONE":
return BACnetObjectType_LIFE_SAFETY_ZONE
case "ACCUMULATOR":
return BACnetObjectType_ACCUMULATOR
case "PULSE_CONVERTER":
return BACnetObjectType_PULSE_CONVERTER
case "EVENT_LOG":
return BACnetObjectType_EVENT_LOG
case "GLOBAL_GROUP":
return BACnetObjectType_GLOBAL_GROUP
case "TREND_LOG_MULTIPLE":
return BACnetObjectType_TREND_LOG_MULTIPLE
case "LOAD_CONTROL":
return BACnetObjectType_LOAD_CONTROL
case "STRUCTURED_VIEW":
return BACnetObjectType_STRUCTURED_VIEW
case "ACCESS_DOOR":
return BACnetObjectType_ACCESS_DOOR
case "TIMER":
return BACnetObjectType_TIMER
case "ACCESS_CREDENTIAL":
return BACnetObjectType_ACCESS_CREDENTIAL
case "ACCESS_POINT":
return BACnetObjectType_ACCESS_POINT
case "ACCESS_RIGHTS":
return BACnetObjectType_ACCESS_RIGHTS
case "ACCESS_USER":
return BACnetObjectType_ACCESS_USER
case "ACCESS_ZONE":
return BACnetObjectType_ACCESS_ZONE
case "CREDENTIAL_DATA_INPUT":
return BACnetObjectType_CREDENTIAL_DATA_INPUT
case "NETWORK_SECURITY":
return BACnetObjectType_NETWORK_SECURITY
case "BITSTRING_VALUE":
return BACnetObjectType_BITSTRING_VALUE
case "CHARACTERSTRING_VALUE":
return BACnetObjectType_CHARACTERSTRING_VALUE
case "DATEPATTERN_VALUE":
return BACnetObjectType_DATEPATTERN_VALUE
case "DATE_VALUE":
return BACnetObjectType_DATE_VALUE
case "DATETIMEPATTERN_VALUE":
return BACnetObjectType_DATETIMEPATTERN_VALUE
case "DATETIME_VALUE":
return BACnetObjectType_DATETIME_VALUE
case "INTEGER_VALUE":
return BACnetObjectType_INTEGER_VALUE
case "LARGE_ANALOG_VALUE":
return BACnetObjectType_LARGE_ANALOG_VALUE
case "OCTETSTRING_VALUE":
return BACnetObjectType_OCTETSTRING_VALUE
case "POSITIVE_INTEGER_VALUE":
return BACnetObjectType_POSITIVE_INTEGER_VALUE
case "TIMEPATTERN_VALUE":
return BACnetObjectType_TIMEPATTERN_VALUE
case "TIME_VALUE":
return BACnetObjectType_TIME_VALUE
case "NOTIFICATION_FORWARDER":
return BACnetObjectType_NOTIFICATION_FORWARDER
case "ALERT_ENROLLMENT":
return BACnetObjectType_ALERT_ENROLLMENT
case "CHANNEL":
return BACnetObjectType_CHANNEL
case "LIGHTING_OUTPUT":
return BACnetObjectType_LIGHTING_OUTPUT
case "BINARY_LIGHTING_OUTPUT":
return BACnetObjectType_BINARY_LIGHTING_OUTPUT
case "NETWORK_PORT":
return BACnetObjectType_NETWORK_PORT
case "ELEVATOR_GROUP":
return BACnetObjectType_ELEVATOR_GROUP
case "ESCALATOR":
return BACnetObjectType_ESCALATOR
}
return 0
} |
agent_ddpg.py | import numpy as np
import random
import copy
from collections import namedtuple, deque
import torch
import torch.nn.functional as F
import torch.optim as optim
from model_ddpg import Actor, Critic
from replay_buffer import ReplayBuffer, PrioritizedReplayBuffer
BUFFER_SIZE = int(1e6) # replay buffer size
START_SIZE = 1024 # when to start training
BATCH_SIZE = 512 # minibatch size
GAMMA = 0.99 # discount factor
TAU = 1e-3 # for soft update of target parameters
LR_ACTOR = 1e-3 # learning rate of the actor
LR_CRITIC = 1e-3 # learning rate of the critic
WEIGHT_DECAY = 0 # L2 weight decay
TRAIN_EVERY = 5 # how often to train a batch
TRAIN_STEPS = 3 # how many training steps when a batch is trained
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
class Agent():
"""Interacts with and learns from the environment."""
def __init__(self, num_agents, state_size, action_size, random_seed, use_per=False):
"""Initialize an Agent object.
Params
======
num_agents (int): number of agents
state_size (int): dimension of each state
action_size (int): dimension of each action
random_seed (int): random seed
use_per (bool): whether to use prioritized replay buffer
"""
self.num_agents = num_agents
self.state_size = state_size
self.action_size = action_size
self.seed = random.seed(random_seed)
self.use_per = use_per
# Actor Network (w/ Target Network)
self.actor_local = Actor(state_size, action_size, random_seed).to(device)
self.actor_target = Actor(state_size, action_size, random_seed).to(device)
self.actor_optimizer = optim.Adam(self.actor_local.parameters(), lr=LR_ACTOR)
# Critic Network (w/ Target Network)
self.critic_local = Critic(state_size, action_size, random_seed).to(device)
self.critic_target = Critic(state_size, action_size, random_seed).to(device)
self.critic_optimizer = optim.Adam(self.critic_local.parameters(), lr=LR_CRITIC, weight_decay=WEIGHT_DECAY)
# Noise process
self.noise = OUNoise(action_size, random_seed)
# Replay memory
if use_per:
self.memory = PrioritizedReplayBuffer(BUFFER_SIZE, BATCH_SIZE)
else:
self.memory = ReplayBuffer(BUFFER_SIZE, BATCH_SIZE, random_seed)
# Initialize time step
self.t_step = 0
def get_critic_Q(self, states, actions, rewards, next_states, dones, gamma, is_train=True):
# Get max predicted Q values (for next states) from target model
if is_train:
actions_next = self.actor_target(next_states)
Q_targets_next = self.critic_target(next_states, actions_next)
# Compute Q targets for current states (y_i)
Q_targets = rewards + (gamma * (1 - dones) * Q_targets_next)
Q_expected = self.critic_local(states, actions)
else:
self.actor_local.eval()
self.actor_target.eval()
self.critic_local.eval()
self.critic_target.eval()
with torch.no_grad():
actions_next = self.actor_target(next_states)
Q_targets_next = self.critic_target(next_states, actions_next)
# Compute Q targets for current states (y_i)
Q_targets = rewards + (gamma * (1 - dones) * Q_targets_next)
Q_expected = self.critic_local(states, actions)
self.actor_local.train()
self.actor_target.train()
self.critic_local.train()
self.critic_target.train()
return Q_expected, Q_targets
def step(self, states, actions, rewards, next_states, dones):
"""Save experience in replay memory, and use random sample from buffer to learn."""
# Save experience / reward
if self.use_per:
# Convert numpy array to torch tensor
states = torch.from_numpy(states).float().to(device)
actions = torch.from_numpy(actions).float().to(device)
rewards = torch.from_numpy(np.array(rewards)).float().unsqueeze(1).to(device)
next_states = torch.from_numpy(next_states).float().to(device)
dones = torch.from_numpy(np.array(dones).astype(np.uint8)).float().unsqueeze(1).to(device)
# Get max predicted Q values (for next states) from target model
Q_expected, Q_targets = self.get_critic_Q(states, actions, rewards, next_states, dones, GAMMA, is_train=False)
# Convert torch tensor to numpy array
states = states.cpu().data.numpy()
actions = actions.cpu().data.numpy()
rewards = rewards.cpu().data.numpy().squeeze(1).tolist()
next_states = next_states.cpu().data.numpy()
dones = dones.cpu().data.numpy().squeeze(1).astype(np.bool).tolist()
# Calculate error
errors = Q_expected - Q_targets
errors = errors.cpu().data.numpy().squeeze(1)
for i in range(self.num_agents):
self.memory.add(states[i], actions[i], rewards[i], next_states[i], dones[i], errors[i])
else:
for i in range(self.num_agents):
self.memory.add(states[i], actions[i], rewards[i], next_states[i], dones[i])
# Update time step
self.t_step += 1
# If enough samples are available in memory,
if len(self.memory) >= START_SIZE:
# Get random subset and learn every TRAIN_EVERY time steps,
if self.t_step % TRAIN_EVERY == 0:
for _ in range(TRAIN_STEPS):
if self.use_per:
experiences, idx_tree, is_weight = self.memory.sample()
self.learn(experiences, GAMMA, idx_tree, is_weight)
else:
experiences = self.memory.sample()
self.learn(experiences, GAMMA)
def act(self, states, add_noise=True):
"""Returns epsilon-greedy actions for given state as per current policy."""
states = torch.from_numpy(states).float().to(device)
self.actor_local.eval()
with torch.no_grad():
actions = self.actor_local(states).cpu().data.numpy()
self.actor_local.train()
if add_noise:
actions += np.concatenate([np.expand_dims(self.noise.sample(), axis=0) for _ in range(self.num_agents)], axis=0)
return np.clip(actions, -1, 1)
def reset(self):
self.noise.reset()
def learn(self, experiences, gamma, idx_tree=None, is_weight=None):
|
def soft_update(self, local_model, target_model, tau):
"""Soft update model parameters.
θ_target = τ*θ_local + (1 - τ)*θ_target
Params
======
local_model: PyTorch model (weights will be copied from)
target_model: PyTorch model (weights will be copied to)
tau (float): interpolation parameter
"""
for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):
target_param.data.copy_(tau*local_param.data + (1.0-tau)*target_param.data)
class OUNoise:
"""Ornstein-Uhlenbeck process."""
def __init__(self, size, seed, mu=0., theta=0.15, sigma=0.2):
"""Initialize parameters and noise process."""
self.mu = mu * np.ones(size)
self.theta = theta
self.sigma = sigma
self.seed = random.seed(seed)
self.reset()
def reset(self):
"""Reset the internal state (= noise) to mean (mu)."""
self.state = copy.copy(self.mu)
def sample(self):
"""Update internal state and return it as a noise sample."""
x = self.state
dx = self.theta * (self.mu - x) + self.sigma * np.array([random.random() for i in range(len(x))])
self.state = x + dx
return self.state | """Update policy and value parameters using given batch of experience tuples.
Q_targets = r + γ * critic_target(next_state, actor_target(next_state))
where:
actor_target(state) -> action
critic_target(state, action) -> Q-value
Params
======
experiences (Tuple[torch.Tensor]): tuple of (s, a, r, s', done) tuples
gamma (float): discount factor
"""
states, actions, rewards, next_states, dones = experiences
# ---------------------------- update critic ---------------------------- #
# Get predicted next-state actions and Q values from target models
Q_expected, Q_targets = self.get_critic_Q(states, actions, rewards, next_states, dones, gamma, is_train=True)
# Compute critic loss
if self.use_per:
assert ((is_weight is not None) and (is_weight.size > 0))
is_weight = torch.from_numpy(is_weight).float().to(device)
critic_loss = (is_weight * F.smooth_l1_loss(Q_expected, Q_targets, reduction='none').squeeze()).mean()
else:
critic_loss = F.mse_loss(Q_expected, Q_targets)
# Minimize the loss
self.critic_optimizer.zero_grad()
critic_loss.backward()
# torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1) # use gradient norm clipping
self.critic_optimizer.step()
# ---------------------------- update actor ---------------------------- #
# Compute actor loss
actions_pred = self.actor_local(states)
actor_loss = -self.critic_local(states, actions_pred).mean()
# Minimize the loss
self.actor_optimizer.zero_grad()
actor_loss.backward()
self.actor_optimizer.step()
# ----------------------- update target networks ----------------------- #
self.soft_update(self.critic_local, self.critic_target, TAU)
self.soft_update(self.actor_local, self.actor_target, TAU)
# update priority
if self.use_per:
assert((idx_tree is not None) and (len(idx_tree) > 0))
errors = Q_expected - Q_targets
errors = errors.cpu().data.numpy().squeeze()
for i in range(self.memory.batch_size):
self.memory.update(idx_tree[i], errors[i])
|
client.rs | use crate::download::AsyncDownload;
use crate::download::DownloadClient;
use crate::traits::*;
use crate::uploadsession::UploadSessionClient;
use crate::url::GraphUrl;
use crate::{
GraphRequest, GraphResponse, HttpClient, Registry, RequestAttribute, RequestClient, RequestType,
};
use graph_core::resource::ResourceIdentity;
use graph_error::WithGraphErrorAsync;
use graph_error::{GraphFailure, GraphResult};
use handlebars::Handlebars;
use parking_lot::Mutex;
use reqwest::header::{HeaderMap, HeaderValue, IntoHeaderName, CONTENT_TYPE};
use reqwest::redirect::Policy;
use reqwest::Method;
use std::fmt::{Debug, Formatter};
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use url::Url;
pub(crate) type AsyncClient =
GraphRequest<reqwest::Client, reqwest::Body, reqwest::multipart::Form>;
impl AsyncClient {
pub fn new_async(url: GraphUrl) -> AsyncClient {
let mut headers = HeaderMap::default();
headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
AsyncClient {
token: Default::default(),
ident: Default::default(),
client: reqwest::Client::builder()
.redirect(Policy::limited(2))
.build()
.map_err(GraphFailure::from)
.unwrap(),
url,
method: Default::default(),
body: None,
headers,
upload_session_file: None,
download_dir: None,
form: None,
req_type: Default::default(),
registry: Handlebars::new(),
timeout: Duration::from_secs(30),
}
}
pub fn inner_client(&mut self) -> &mut reqwest::Client {
&mut self.client
}
pub fn download(&mut self) -> AsyncDownload {
let request = self.clone();
DownloadClient::new_async(request)
}
pub async fn upload_session(&mut self) -> GraphResult<UploadSessionClient<AsyncHttpClient>> {
let file = self
.upload_session_file
.take()
.ok_or_else(|| GraphFailure::invalid("file for upload session"))?;
let response = self.response().await?.with_graph_error().await?;
let upload_session: serde_json::Value = response.json().await?;
let mut session = UploadSessionClient::new_async(upload_session)?;
session.set_file(file).await?;
Ok(session)
}
pub fn build_upload_session(&mut self) -> (Option<PathBuf>, reqwest::RequestBuilder) {
let file = self.upload_session_file.take();
let builder = self.build();
(file, builder)
}
pub fn build(&mut self) -> reqwest::RequestBuilder {
let headers = self.headers.clone();
self.headers.clear();
self.headers
.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
let builder = self
.client
.request(self.method.clone(), self.url.as_str())
.timeout(self.timeout)
.headers(headers)
.bearer_auth(self.token.as_str());
match self.req_type {
RequestType::Basic | RequestType::Redirect => {
if self.body.is_some() {
builder.body(self.body.take().unwrap())
} else {
builder
}
}
RequestType::Multipart => builder.multipart(self.form.take().unwrap()),
}
}
/// Builds the request and sends it.
///
/// Requests that require a redirect are automatic so we don't need
/// to do anything special for these requests.
pub async fn response(&mut self) -> GraphResult<reqwest::Response> {
let builder = self.build();
let response = builder.send().await?;
Ok(response)
}
/// Builds the requests and sends it, converting to a GraphResponse and deserializing
/// the body.
pub async fn execute<T>(&mut self) -> GraphResult<GraphResponse<T>>
where
for<'de> T: serde::Deserialize<'de>,
{
let builder = self.build();
let response = builder.send().await?;
AsyncTryFrom::<reqwest::Response>::async_try_from(response).await
}
pub fn clone(&mut self) -> Self {
GraphRequest {
token: self.token.to_string(),
ident: self.ident,
client: reqwest::Client::builder()
.redirect(Policy::limited(2))
.build()
.map_err(GraphFailure::from)
.unwrap(),
url: self.url.clone(),
method: self.method.clone(),
body: self.body.take(),
headers: self.headers.clone(),
upload_session_file: self.upload_session_file.take(),
download_dir: self.download_dir.take(),
form: self.form.take(),
req_type: self.req_type,
registry: Handlebars::new(),
timeout: Duration::from_secs(30),
}
}
fn register_ident_helper(&mut self, resource_identity: ResourceIdentity) {
Registry::register_internal_helper(resource_identity, &mut self.registry);
}
}
impl Default for AsyncClient {
fn default() -> Self {
AsyncClient::new_async(GraphUrl::parse("https://graph.microsoft.com/v1.0").unwrap())
}
}
impl From<Url> for AsyncClient {
fn from(url: Url) -> Self {
AsyncClient::new_async(GraphUrl::from(url))
}
}
pub type AsyncHttpClient = HttpClient<Arc<Mutex<AsyncClient>>>;
impl AsyncHttpClient {
pub fn new(url: GraphUrl) -> AsyncHttpClient {
AsyncHttpClient {
client: Arc::new(Mutex::new(AsyncClient::new_async(url))),
}
}
pub fn clone_inner(&self) -> Arc<Mutex<AsyncClient>> {
Arc::clone(&self.client)
}
pub async fn download(&self) -> AsyncDownload {
self.client.lock().download()
}
pub async fn upload_session(&self) -> GraphResult<UploadSessionClient<AsyncHttpClient>> {
self.client.lock().upload_session().await
}
pub async fn build_upload_session(&self) -> (Option<PathBuf>, reqwest::RequestBuilder) {
self.client.lock().build_upload_session()
}
pub async fn build(&self) -> reqwest::RequestBuilder {
self.client.lock().build()
}
pub async fn response(&self) -> GraphResult<reqwest::Response> {
let mut client = self.client.lock();
let response = client.response();
response.await
}
pub async fn execute<T>(&self) -> GraphResult<GraphResponse<T>>
where
for<'de> T: serde::Deserialize<'de>,
{
self.client.lock().execute().await
}
}
impl RequestClient for AsyncHttpClient {
type Body = reqwest::Body;
type Form = reqwest::multipart::Form;
fn token(&self) -> String {
self.client.lock().token.clone()
}
fn set_token(&self, token: &str) {
self.client.lock().token = token.to_string();
}
fn ident(&self) -> ResourceIdentity {
self.client.lock().ident
}
fn set_ident(&self, ident: ResourceIdentity) {
self.client.lock().ident = ident;
}
fn url(&self) -> GraphUrl {
self.client.lock().url.clone()
}
fn | (&self) -> Url {
self.client.lock().url.to_url()
}
fn set_url(&self, url: GraphUrl) {
self.client.lock().url = url;
}
fn method(&self) -> Method {
self.client.lock().method.clone()
}
fn set_method(&self, method: Method) {
self.client.lock().method = method;
}
fn set_body<T: Into<reqwest::Body>>(&self, body: T) {
self.client.lock().body = Some(body.into());
}
fn set_body_with_file(&self, path: PathBuf) -> GraphResult<()> {
let mut file = File::open(path)?;
let mut buffer = String::new();
file.read_to_string(&mut buffer)?;
self.client.lock().body = Some(buffer.into());
Ok(())
}
fn header<T: IntoHeaderName>(&self, name: T, value: HeaderValue) {
self.client.lock().headers.insert(name, value);
}
fn set_header_map(&self, header_map: HeaderMap) {
self.client.lock().headers = header_map;
}
fn clear_headers(&self) {
self.client.lock().headers.clear();
}
fn set_download_dir(&self, dir: PathBuf) {
self.client.lock().download_dir = Some(dir);
}
fn set_upload_session(&self, file: PathBuf) {
self.client.lock().upload_session_file = Some(file);
}
fn set_form(&self, form: reqwest::multipart::Form) {
let mut client = self.client.lock();
client.form = Some(form);
client.req_type = RequestType::Multipart;
}
fn set_request_type(&self, req_type: RequestType) {
self.client.lock().req_type = req_type;
}
fn request_type(&self) -> RequestType {
self.client.lock().req_type
}
fn url_ref<F>(&self, f: F)
where
F: Fn(&GraphUrl) + Sync,
{
f(&self.client.lock().url)
}
fn url_mut<F>(&self, f: F)
where
F: Fn(&mut GraphUrl) + Sync,
{
f(&mut self.client.lock().url)
}
fn registry<F>(&self, f: F)
where
F: Fn(&mut Handlebars) + Sync,
{
f(&mut self.client.lock().registry)
}
fn render_template(&self, template: &str, json: &serde_json::Value) -> String {
self.client
.lock()
.registry
.render_template(template, json)
.unwrap()
}
fn register_ident_helper(&self, resource_identity: ResourceIdentity) {
self.client.lock().register_ident_helper(resource_identity);
}
fn extend_path(&self, path: &[&str]) {
self.client.lock().url.extend_path(path);
}
fn set_request(
&self,
req_att: Vec<RequestAttribute<reqwest::Body, reqwest::multipart::Form>>,
) -> GraphResult<()> {
for att in req_att {
let mut client = self.client.lock();
match att {
RequestAttribute::Token(token) => client.token = token,
RequestAttribute::Ident(ident) => client.ident = ident,
RequestAttribute::Url(url) => client.url = url,
RequestAttribute::Method(method) => client.method = method,
RequestAttribute::Body(body) => client.body = Some(body),
RequestAttribute::BodyFile(path) => {
let mut file = File::open(path)?;
let mut buffer = String::new();
file.read_to_string(&mut buffer)?;
client.body = Some(buffer.into());
}
RequestAttribute::Headers(headers) => client.headers = headers,
RequestAttribute::ClearHeaders => client.headers.clear(),
RequestAttribute::Download(path) => client.download_dir = Some(path),
RequestAttribute::Upload(path) => client.upload_session_file = Some(path),
RequestAttribute::Form(form) => client.form = Some(form),
RequestAttribute::RequestType(req_type) => client.req_type = req_type,
}
}
Ok(())
}
fn set_timeout(&self, duration: Duration) {
self.client.lock().timeout = duration;
}
}
impl Debug for AsyncHttpClient {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
self.client.lock().fmt(f)
}
}
impl From<AsyncClient> for AsyncHttpClient {
fn from(client: AsyncClient) -> Self {
AsyncHttpClient {
client: Arc::new(Mutex::new(client)),
}
}
}
| to_url |
parser_trait.rs | // Copyright (c) 2019, Facebook, Inc.
// All rights reserved.
//
// This source code is licensed under the MIT license found in the
// LICENSE file in the "hack" directory of this source tree.
use crate::lexer::{self, Lexer};
use crate::parser_env::ParserEnv;
use crate::smart_constructors::{NodeType, SmartConstructors, Token, Trivia};
use parser_core_types::{
lexable_token::LexableToken,
lexable_trivia::LexableTrivia,
syntax_error::{self as Errors, Error, SyntaxError},
token_factory::TokenFactory,
token_kind::TokenKind,
trivia_factory::TriviaFactory,
};
use stack_limit::StackLimit;
#[derive(PartialEq)]
pub enum SeparatedListKind {
NoTrailing,
TrailingAllowed,
ItemsOptional,
}
// This could be a set of token kinds, but it's part of parser envirnoment that is often cloned,
// so trying to keep it small.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ExpectedTokens {
Classish = 0b0001,
Semicolon = 0b0010,
RightParen = 0b0100,
Visibility = 0b1000,
}
const ET_COUNT: u32 = 4;
const ET_MASK: ETMask = (1 << ET_COUNT) - 1;
type ETMask = u16; // mask of bits in first ET_COUNT bits
impl ExpectedTokens {
pub fn contains(mask: ETMask, token: TokenKind) -> bool {
use ExpectedTokens::*;
let bit: ETMask = match token {
TokenKind::Class | TokenKind::Trait | TokenKind::Interface => Classish as ETMask,
TokenKind::Semicolon => Semicolon as ETMask,
TokenKind::RightParen => RightParen as ETMask,
TokenKind::Public | TokenKind::Protected | TokenKind::Private => Visibility as ETMask,
_ => 0_u16,
};
(bit & mask) != 0
}
fn from(bit: ETMask) -> ExpectedTokens {
// debug_assert!((bit & (!bit+1)) == bit, "unexpected multiple set bits in {:#b}");
use ExpectedTokens::*;
match bit {
0b0001 => Classish,
0b0010 => Semicolon,
0b0100 => RightParen,
_ => Visibility,
}
}
}
#[derive(Debug, Clone)]
pub struct ExpectedTokenVec(Vec<ETMask>);
impl ExpectedTokenVec {
fn push(&mut self, et: ExpectedTokens) {
let last_mask = *self.0.last().unwrap_or(&0) & ET_MASK;
let bit = et as ETMask;
self.0.push(bit | last_mask | (bit << ET_COUNT));
}
fn pop(&mut self) -> Option<ExpectedTokens> {
self.0.pop().map(|x| ExpectedTokens::from(x >> ET_COUNT))
}
fn last_mask(&self) -> ETMask {
self.0.last().map_or(0, |x| x >> ET_COUNT)
}
fn any_mask(&self) -> ETMask {
self.0.last().map_or(0, |x| x & ET_MASK)
}
}
#[derive(Debug, Clone)]
pub struct Context<'a, T> {
pub expected: ExpectedTokenVec,
pub skipped_tokens: Vec<T>,
stack_limit: Option<&'a StackLimit>,
}
impl<'a, T> Context<'a, T> {
pub fn empty(stack_limit: Option<&'a StackLimit>) -> Self {
Self {
expected: ExpectedTokenVec(vec![]),
skipped_tokens: vec![],
stack_limit,
}
}
fn expect_in_new_scope(&mut self, expected: ExpectedTokens) {
self.expected.push(expected);
}
fn pop_scope(&mut self, expected: ExpectedTokens) {
let scope = self.expected.pop().unwrap();
assert_eq!(expected, scope)
}
fn expects(&self, token_kind: TokenKind) -> bool {
ExpectedTokens::contains(self.expected.any_mask(), token_kind)
}
fn expects_here(&self, token_kind: TokenKind) -> bool {
ExpectedTokens::contains(self.expected.last_mask(), token_kind)
}
}
pub trait ParserTrait<'a, S>: Clone
where
S: SmartConstructors,
<S as SmartConstructors>::R: NodeType,
{
fn make(
_: Lexer<'a, S::TF>,
_: ParserEnv,
_: Context<'a, Token<S>>,
_: Vec<SyntaxError>,
_: S,
) -> Self;
fn add_error(&mut self, _: SyntaxError);
fn into_parts(self) -> (Lexer<'a, S::TF>, Context<'a, Token<S>>, Vec<SyntaxError>, S);
fn lexer(&self) -> &Lexer<'a, S::TF>;
fn lexer_mut(&mut self) -> &mut Lexer<'a, S::TF>;
fn continue_from<P: ParserTrait<'a, S>>(&mut self, _: P);
fn env(&self) -> &ParserEnv;
fn sc_mut(&mut self) -> &mut S;
fn skipped_tokens(&self) -> &[Token<S>];
fn drain_skipped_tokens(&mut self) -> std::vec::Drain<'_, Token<S>>;
fn context_mut(&mut self) -> &mut Context<'a, Token<S>>;
fn context(&self) -> &Context<'a, Token<S>>;
fn pos(&self) -> usize {
self.lexer().offset()
}
fn | (&mut self, token: Token<S>) {
self.context_mut().skipped_tokens.push(token)
}
fn expects(&self, kind: TokenKind) -> bool {
self.context().expects(kind)
}
fn expects_here(&self, kind: TokenKind) -> bool {
self.context().expects_here(kind)
}
fn expect_in_new_scope(&mut self, expected: ExpectedTokens) {
self.context_mut().expect_in_new_scope(expected)
}
fn pop_scope(&mut self, expected: ExpectedTokens) {
self.context_mut().pop_scope(expected)
}
// This function reports an error starting at the current location of the
// parser. Setting on_whole_token=false will report the error only on trivia,
// which is useful in cases such as when "a semicolon is expected here" before
// the current node. However, setting on_whole_token=true will report the error
// only on the non-trivia text of the next token parsed, which is useful
// in cases like "flagging an entire token as an extra".
fn with_error_impl(&mut self, on_whole_token: bool, message: Error) {
let (start_offset, end_offset) = self.error_offsets(on_whole_token);
let error = SyntaxError::make(start_offset, end_offset, message);
self.add_error(error)
}
fn with_error(&mut self, message: Error) {
self.with_error_impl(false, message)
}
fn with_error_on_whole_token(&mut self, message: Error) {
self.with_error_impl(true, message)
}
fn next_token_with_tokenizer<F>(&mut self, tokenizer: F) -> Token<S>
where
F: Fn(&mut Lexer<'a, S::TF>) -> Token<S>,
{
let token = tokenizer(self.lexer_mut());
if !self.skipped_tokens().is_empty() {
let start = self.lexer().start();
let mut leading = self
.sc_mut()
.token_factory_mut()
.trivia_factory_mut()
.make();
for t in self.drain_skipped_tokens() {
let (t_leading, t_width, t_trailing) = t.into_trivia_and_width();
leading.extend(t_leading);
leading.push(Trivia::<S>::make_extra_token_error(start, t_width));
leading.extend(t_trailing);
}
leading.extend(token.clone_leading());
self.sc_mut()
.token_factory_mut()
.with_leading(token, leading)
} else {
token
}
}
fn next_token(&mut self) -> Token<S> {
self.next_token_with_tokenizer(|x| x.next_token())
}
fn next_token_no_trailing(&mut self) -> Token<S> {
self.lexer_mut().next_token_no_trailing()
}
fn next_docstring_header(&mut self) -> (Token<S>, &'a [u8]) {
self.lexer_mut().next_docstring_header()
}
fn next_token_in_string(&mut self, literal_kind: &lexer::StringLiteralKind) -> Token<S> {
self.lexer_mut().next_token_in_string(literal_kind)
}
fn next_xhp_class_name_or_other(&mut self) -> S::R {
let token = self.next_xhp_class_name_or_other_token();
match token.kind() {
TokenKind::Namespace | TokenKind::Name => {
let name_token = S!(make_token, self, token);
self.scan_remaining_qualified_name(name_token)
}
TokenKind::Backslash => {
let missing = S!(make_missing, self, self.pos());
let backslash = S!(make_token, self, token);
self.scan_qualified_name(missing, backslash)
}
_ => S!(make_token, self, token),
}
}
fn next_xhp_children_name_or_other(&mut self) -> Token<S> {
if self.is_next_xhp_category_name() {
self.next_xhp_category_name()
} else if self.env().enable_xhp_class_modifier {
self.next_xhp_modifier_class_name_or_other_token()
} else {
self.next_xhp_class_name_or_other_token()
}
}
// Used in conjunction with the following function. If you call next_token
// when the parser is at the <<<, it will scan the entire file looking for an
// ending to the heredoc, which could quickly get bad if there are many such
// declarations in a file.
fn peek_next_partial_token_is_triple_left_angle(&self) -> bool {
let mut lexer = self.lexer().clone();
lexer.scan_leading_php_trivia();
let tparam_open = lexer.peek_char(0);
let attr1 = lexer.peek_char(1);
let attr2 = lexer.peek_char(2);
tparam_open == '<' && attr1 == '<' && attr2 == '<'
}
// Type parameter/argument lists begin with < and can have attributes immediately
// afterwards, so this peeks a token kind at the beginning of such a list. *)
fn peek_token_kind_with_possible_attributized_type_list(&self) -> TokenKind {
if self.peek_next_partial_token_is_triple_left_angle() {
TokenKind::LessThan
} else {
self.peek_token_kind()
}
}
// In the case of attributes on generics, one could write
// function f<<<__Attr>> reify T, ...> or Awaitable<<<__Soft>> int>
// The triple left angle is currently lexed as a HeredocStringLiteral,
// but we can get around this by manually advancing the lexer one token
// and returning a LeftAngle. Then, the next token will be a LeftAngleLeftAngle
fn assert_left_angle_in_type_list_with_possible_attribute(&mut self) -> S::R {
let parser1 = self.clone();
let lexer = self.lexer_mut();
lexer.scan_leading_php_trivia();
let tparam_open = lexer.peek_char(0);
let attr1 = lexer.peek_char(1);
let attr2 = lexer.peek_char(2);
if tparam_open == '<' && attr1 == '<' && attr2 == '<' {
lexer.advance(1);
let start = lexer.start();
let token_factory = self.sc_mut().token_factory_mut();
let leading = token_factory.trivia_factory_mut().make();
let trailing = token_factory.trivia_factory_mut().make();
let token = token_factory.make(TokenKind::LessThan, start, 1, leading, trailing);
S!(make_token, self, token)
} else {
self.continue_from(parser1);
self.assert_token(TokenKind::LessThan)
}
}
fn assert_xhp_body_token(&mut self, kind: TokenKind) -> S::R {
self.assert_token_with_tokenizer(kind, |x: &mut Lexer<'a, S::TF>| x.next_xhp_body_token())
}
fn peek_token_with_lookahead(&self, lookahead: usize) -> Token<S> {
let mut lexer = self.lexer().clone();
let mut i = 0;
loop {
if i == lookahead {
// call peek_next_token instead of next_token for the last one to leverage
// lexer caching
return lexer.peek_next_token();
}
let _ = lexer.next_token();
i += 1
}
}
fn peek_token(&self) -> Token<S> {
self.lexer().peek_next_token()
}
fn peek_token_kind(&self) -> TokenKind {
self.peek_token().kind()
}
fn peek_token_kind_with_lookahead(&self, lookahead: usize) -> TokenKind {
self.peek_token_with_lookahead(lookahead).kind()
}
fn fetch_token(&mut self) -> S::R {
let token = self.lexer_mut().next_token();
S!(make_token, self, token)
}
fn assert_token_with_tokenizer<F>(&mut self, kind: TokenKind, tokenizer: F) -> S::R
where
F: Fn(&mut Lexer<'a, S::TF>) -> Token<S>,
{
let token = self.next_token_with_tokenizer(tokenizer);
if token.kind() != kind {
panic!(
"Expected {:?}, but got {:?}. This indicates a bug in the parser, regardless of how broken the input code is.",
kind,
token.kind()
)
}
S!(make_token, self, token)
}
fn assert_token(&mut self, kind: TokenKind) -> S::R {
self.assert_token_with_tokenizer(kind, |x: &mut Lexer<'_, S::TF>| x.next_token())
}
fn token_text(&self, token: &Token<S>) -> &'a str {
match token.leading_start_offset() {
None => "", // unavailable for minimal tokens
Some(leading_start_offset) => unsafe {
std::str::from_utf8_unchecked(
self.lexer()
.source()
.sub(leading_start_offset + token.leading_width(), token.width()),
)
},
}
}
fn current_token_text(&self) -> &'a str {
self.token_text(&self.peek_token())
}
// If the next token is a name or keyword, scan it as a name.
fn next_token_as_name(&mut self) -> Token<S> {
// TODO: This isn't right. Pass flags to the lexer.
self.lexer_mut().next_token_as_name()
}
fn optional_token(&mut self, kind: TokenKind) -> S::R {
if self.peek_token_kind() == kind {
let token = self.next_token();
S!(make_token, self, token)
} else {
S!(make_missing, self, self.pos())
}
}
fn scan_qualified_name_worker(
&mut self,
mut name_opt: Option<S::R>,
mut parts: Vec<S::R>,
mut has_backslash: bool,
) -> (Vec<S::R>, Option<S::R>, bool) {
loop {
let mut parser1 = self.clone();
let token = if parser1.is_next_xhp_class_name() {
parser1.next_xhp_class_name()
} else {
parser1.next_token_as_name()
};
match (name_opt.is_some(), token.kind()) {
(true, TokenKind::Backslash) => {
// found backslash, create item and recurse
self.continue_from(parser1);
let token = S!(make_token, self, token);
let part = S!(make_list_item, self, name_opt.unwrap(), token);
parts.push(part);
has_backslash = true;
name_opt = None;
}
(false, TokenKind::Name) => {
// found a name, recurse to look for backslash
self.continue_from(parser1);
let token = S!(make_token, self, token);
name_opt = Some(token);
has_backslash = false;
}
(true, _) if parts.is_empty() => {
// have not found anything - return [] to indicate failure
return (parts, name_opt, false);
}
(true, _) => {
// next token is not part of qualified name but we've consume some
// part of the input - create part for name with missing backslash
// and return accumulated result
let missing = S!(make_missing, self, self.pos());
let part = S!(make_list_item, self, name_opt.unwrap(), missing);
// TODO(T25649779)
parts.push(part);
return (parts, None, false);
}
_ => {
// next token is not part of qualified name - return accumulated result
return (parts, name_opt, has_backslash);
}
}
}
}
fn scan_remaining_qualified_name_extended(&mut self, name_token: S::R) -> (S::R, bool) {
let (parts, name_token_opt, is_backslash) =
self.scan_qualified_name_worker(Some(name_token), vec![], false);
if parts.is_empty() {
(name_token_opt.unwrap(), is_backslash)
} else {
let list_node = S!(make_list, self, parts, self.pos());
let name = S!(make_qualified_name, self, list_node);
(name, is_backslash)
}
}
fn scan_qualified_name_extended(&mut self, missing: S::R, backslash: S::R) -> (S::R, bool) {
let head = S!(make_list_item, self, missing, backslash);
let parts = vec![head];
let (parts, _, is_backslash) = self.scan_qualified_name_worker(None, parts, false);
let list_node = S!(make_list, self, parts, self.pos());
let name = S!(make_qualified_name, self, list_node);
(name, is_backslash)
}
fn scan_qualified_name(&mut self, missing: S::R, backslash: S::R) -> S::R {
let (name, _) = self.scan_qualified_name_extended(missing, backslash);
name
}
// If the next token is a name or an non-reserved keyword, scan it as
// a name otherwise as a keyword.
//
// NB: A "reserved" keyword is in practice a keyword that cannot be used
// as a class name or function name, for example, control flow keywords or
// declaration keywords are reserved.
fn next_token_non_reserved_as_name(&mut self) -> Token<S> {
self.next_token_with_tokenizer(|l| l.next_token_non_reserved_as_name())
}
fn scan_header(&mut self) -> (Option<Token<S>>, Option<(Token<S>, Option<Token<S>>)>) {
self.lexer_mut().scan_header()
}
fn error_offsets(&mut self, on_whole_token: bool /* = false */) -> (usize, usize) {
if on_whole_token {
let token = self.peek_token();
let start_offset = self.lexer().offset() + token.leading_width();
let end_offset = start_offset + token.width();
(start_offset, end_offset)
} else {
let start_offset = self.lexer().start();
let end_offset = self.lexer().offset();
(start_offset, end_offset)
}
}
fn scan_name_or_qualified_name(&mut self) -> S::R {
let mut parser1 = self.clone();
let token = parser1.next_token_non_reserved_as_name();
match token.kind() {
TokenKind::Namespace | TokenKind::Name => {
self.continue_from(parser1);
let token = S!(make_token, self, token);
self.scan_remaining_qualified_name(token)
}
TokenKind::Backslash => {
self.continue_from(parser1);
let missing = S!(make_missing, self, self.pos());
let token = S!(make_token, self, token);
self.scan_qualified_name(missing, token)
}
_ => S!(make_missing, self, self.pos()),
}
}
fn parse_alternate_if_block<F>(&mut self, parse_item: F) -> S::R
where
F: Fn(&mut Self) -> S::R,
{
let mut parser1 = self.clone();
let block = parser1.parse_list_while(parse_item, |x: &Self| match x.peek_token_kind() {
TokenKind::Elseif | TokenKind::Else | TokenKind::Endif => false,
_ => true,
});
if block.is_missing() {
let empty1 = S!(make_missing, self, self.pos());
let empty2 = S!(make_missing, self, self.pos());
let es = S!(make_expression_statement, self, empty1, empty2);
S!(make_list, self, vec![es], self.pos())
} else {
self.continue_from(parser1);
block
}
}
fn parse_separated_list<F>(
&mut self,
separator_kind: TokenKind,
allow_trailing: SeparatedListKind,
close_kind: TokenKind,
error: Error,
parse_item: F,
) -> (S::R, bool)
where
F: Fn(&mut Self) -> S::R,
{
let (x, y, _) = self.parse_separated_list_predicate(
|x| x == separator_kind,
allow_trailing,
|x| x == close_kind,
error,
parse_item,
);
(x, y)
}
fn require_qualified_name(&mut self) -> S::R {
let mut parser1 = self.clone();
let name = if parser1.is_next_xhp_class_name() {
parser1.next_xhp_class_name()
} else {
parser1.next_token_non_reserved_as_name()
};
match name.kind() {
TokenKind::Namespace | TokenKind::Name | TokenKind::XHPClassName => {
self.continue_from(parser1);
let token = S!(make_token, self, name);
self.scan_remaining_qualified_name(token)
}
TokenKind::Backslash => {
self.continue_from(parser1);
let missing = S!(make_missing, self, self.pos());
let backslash = S!(make_token, self, name);
self.scan_qualified_name(missing, backslash)
}
_ => {
self.with_error(Errors::error1004);
S!(make_missing, self, self.pos())
}
}
}
fn require_name(&mut self) -> S::R {
self.require_token(TokenKind::Name, Errors::error1004)
}
fn require_xhp_class_name(&mut self) -> S::R {
let token = self.next_xhp_modifier_class_name();
S!(make_token, self, token)
}
fn require_xhp_class_name_or_name(&mut self) -> S::R {
if self.is_next_xhp_class_name() {
let token = self.next_xhp_class_name();
S!(make_token, self, token)
} else {
self.require_token(TokenKind::Name, Errors::error1004)
}
}
fn require_class_name(&mut self) -> S::R {
if self.is_next_xhp_class_name() {
let token = self.next_xhp_class_name();
S!(make_token, self, token)
} else {
self.require_name_allow_non_reserved()
}
}
fn require_function(&mut self) -> S::R {
self.require_token(TokenKind::Function, Errors::error1003)
}
fn require_variable(&mut self) -> S::R {
self.require_token(TokenKind::Variable, Errors::error1008)
}
fn require_colon(&mut self) -> S::R {
self.require_token(TokenKind::Colon, Errors::error1020)
}
fn require_left_brace(&mut self) -> S::R {
self.require_token(TokenKind::LeftBrace, Errors::error1034)
}
fn require_slashgt(&mut self) -> S::R {
self.require_token(TokenKind::SlashGreaterThan, Errors::error1029)
}
fn require_right_brace(&mut self) -> S::R {
self.require_token(TokenKind::RightBrace, Errors::error1006)
}
fn require_left_paren(&mut self) -> S::R {
self.require_token(TokenKind::LeftParen, Errors::error1019)
}
fn require_left_angle(&mut self) -> S::R {
self.require_token(TokenKind::LessThan, Errors::error1021)
}
fn require_right_angle(&mut self) -> S::R {
self.require_token(TokenKind::GreaterThan, Errors::error1013)
}
fn require_comma(&mut self) -> S::R {
self.require_token(TokenKind::Comma, Errors::error1054)
}
fn require_right_bracket(&mut self) -> S::R {
self.require_token(TokenKind::RightBracket, Errors::error1032)
}
fn require_equal(&mut self) -> S::R {
self.require_token(TokenKind::Equal, Errors::error1036)
}
fn require_arrow(&mut self) -> S::R {
self.require_token(TokenKind::EqualGreaterThan, Errors::error1028)
}
fn require_lambda_arrow(&mut self) -> S::R {
self.require_token(TokenKind::EqualEqualGreaterThan, Errors::error1046)
}
fn require_as(&mut self) -> S::R {
self.require_token(TokenKind::As, Errors::error1023)
}
fn require_while(&mut self) -> S::R {
self.require_token(TokenKind::While, Errors::error1018)
}
fn require_coloncolon(&mut self) -> S::R {
self.require_token(TokenKind::ColonColon, Errors::error1047)
}
fn require_name_or_variable_or_error(&mut self, error: Error) -> S::R {
let mut parser1 = self.clone();
let token = parser1.next_token_as_name();
match token.kind() {
TokenKind::Namespace | TokenKind::Name => {
self.continue_from(parser1);
let token = S!(make_token, self, token);
self.scan_remaining_qualified_name(token)
}
TokenKind::Variable => {
self.continue_from(parser1);
S!(make_token, self, token)
}
_ => {
// ERROR RECOVERY: Create a missing token for the expected token,
// and continue on from the current token. Don't skip it.
self.with_error(error);
S!(make_missing, self, self.pos())
}
}
}
fn require_name_or_variable(&mut self) -> S::R {
self.require_name_or_variable_or_error(Errors::error1050)
}
fn require_xhp_class_name_or_name_or_variable(&mut self) -> S::R {
if self.is_next_xhp_class_name() {
let token = self.next_xhp_class_name();
S!(make_token, self, token)
} else {
self.require_name_or_variable()
}
}
fn require_name_allow_non_reserved(&mut self) -> S::R {
let mut parser1 = self.clone();
let token = parser1.next_token_non_reserved_as_name();
if token.kind() == TokenKind::Name {
self.continue_from(parser1);
S!(make_token, self, token)
} else {
// ERROR RECOVERY: Create a missing token for the expected token,
// and continue on from the current token. Don't skip it.
self.with_error(Errors::error1004);
S!(make_missing, self, self.pos())
}
}
fn next_xhp_category_name(&mut self) -> Token<S> {
self.lexer_mut().next_xhp_category_name()
}
// We have a number of issues involving xhp class names, which begin with
// a colon and may contain internal colons and dashes. These are some
// helper methods to deal with them.
fn is_next_name(&mut self) -> bool {
self.lexer().is_next_name()
}
fn next_xhp_name(&mut self) -> Token<S> {
assert!(self.is_next_name());
self.lexer_mut().next_xhp_name()
}
fn next_xhp_class_name(&mut self) -> Token<S> {
assert!(self.is_next_xhp_class_name());
self.lexer_mut().next_xhp_class_name()
}
fn next_xhp_modifier_class_name(&mut self) -> Token<S> {
self.lexer_mut().next_xhp_modifier_class_name()
}
fn require_xhp_name(&mut self) -> S::R {
if self.is_next_name() {
let token = self.next_xhp_name();
S!(make_token, self, token)
} else {
// ERROR RECOVERY: Create a missing token for the expected token,
// and continue on from the current token. Don't skip it.
// TODO: Different error?
self.with_error(Errors::error1004);
S!(make_missing, self, self.pos())
}
}
fn is_next_xhp_category_name(&mut self) -> bool {
self.lexer().is_next_xhp_category_name()
}
fn parse_comma_list_allow_trailing<F>(
&mut self,
close_predicate: TokenKind,
error: Error,
parse_item: F,
) -> (S::R, bool)
where
F: Fn(&mut Self) -> S::R,
{
self.parse_separated_list(
TokenKind::Comma,
SeparatedListKind::TrailingAllowed,
close_predicate,
error,
parse_item,
)
}
fn parse_separated_list_predicate<P, SP, F>(
&mut self,
separator_predicate: SP,
list_kind: SeparatedListKind,
close_predicate: P,
error: Error,
parse_item: F,
) -> (S::R, bool, TokenKind)
where
P: Fn(TokenKind) -> bool,
SP: Fn(TokenKind) -> bool,
F: Fn(&mut Self) -> S::R,
{
let mut items = vec![];
// Set this when we first see a separator
let mut separator_kind = TokenKind::Empty;
loop {
// At this point we are expecting an item followed by a separator,
// a close, or, if trailing separators are allowed, both
let kind = self.peek_token_kind();
if close_predicate(kind) || kind == TokenKind::EndOfFile {
// ERROR RECOVERY: We expected an item but we found a close or
// the end of the file. Make the item and separator both
// "missing" and give an error.
//
// If items are optional and we found a close, the last item was
// omitted and there was no error.
if kind == TokenKind::EndOfFile || list_kind != SeparatedListKind::ItemsOptional {
self.with_error(error)
};
let missing1 = S!(make_missing, self, self.pos());
let missing2 = S!(make_missing, self, self.pos());
let list_item = S!(make_list_item, self, missing1, missing2);
// TODO(T25649779)
items.push(list_item);
break;
} else if separator_predicate(kind) {
if separator_kind == TokenKind::Empty {
separator_kind = kind;
} else if separator_kind != kind {
self.with_error(Errors::error1063);
}
// ERROR RECOVERY: We expected an item but we got a separator.
// Assume the item was missing, eat the separator, and move on.
//
// If items are optional, there was no error, so eat the separator and
// continue.
//
// TODO: This could be poor recovery. For example:
//
// function bar (Foo< , int blah)
//
// Plainly the type arg is missing, but the comma is not associated with
// the type argument list, it's associated with the formal
// parameter list.
let token = self.next_token();
if list_kind != SeparatedListKind::ItemsOptional {
self.with_error(error.clone())
}
let item = S!(make_missing, self, self.pos());
let separator = S!(make_token, self, token);
let list_item = S!(make_list_item, self, item, separator);
// TODO(T25649779)
items.push(list_item)
} else {
// We got neither a close nor a separator; hopefully we're going
// to parse an item followed by a close or separator.
let item = parse_item(self);
let kind = self.peek_token_kind();
if close_predicate(kind) {
let missing = S!(make_missing, self, self.pos());
let list_item = S!(make_list_item, self, item, missing);
// TODO(T25649779)
items.push(list_item);
break;
} else if separator_predicate(kind) {
if separator_kind == TokenKind::Empty {
separator_kind = kind;
} else if separator_kind != kind {
self.with_error(Errors::error1063);
}
let token = self.next_token();
let separator = S!(make_token, self, token);
let list_item = S!(make_list_item, self, item, separator);
// TODO(T25649779)
items.push(list_item);
let allow_trailing = list_kind != SeparatedListKind::NoTrailing;
// We got an item followed by a separator; what if the thing
// that comes next is a close?
if allow_trailing && close_predicate(self.peek_token_kind()) {
break;
}
} else {
// ERROR RECOVERY: We were expecting a close or separator, but
// got neither. Bail out. Caller will give an error.
let missing = S!(make_missing, self, self.pos());
let list_item = S!(make_list_item, self, item, missing);
// TODO(T25649779)
items.push(list_item);
break;
}
}
}
let no_arg_is_missing = items.iter().all(|x| !x.is_missing());
let item_list = S!(make_list, self, items, self.pos());
(item_list, no_arg_is_missing, separator_kind)
}
fn parse_list_until_none<F>(&mut self, parse_item: F) -> S::R
where
F: Fn(&mut Self) -> Option<S::R>,
{
let mut acc = vec![];
loop {
let maybe_item = parse_item(self);
match maybe_item {
None => break,
Some(item) => {
let is_missing = item.is_missing();
acc.push(item);
if self.peek_token_kind() == TokenKind::EndOfFile ||
// exit if parser did not make any progress
is_missing
{
break;
}
}
}
}
S!(make_list, self, acc, self.pos())
}
fn parse_separated_list_opt_predicate<P, F>(
&mut self,
separator_kind: TokenKind,
allow_trailing: SeparatedListKind,
close_predicate: P,
error: Error,
parse_item: F,
) -> S::R
where
P: Fn(TokenKind) -> bool,
F: Fn(&mut Self) -> S::R,
{
let kind = self.peek_token_kind();
if close_predicate(kind) {
S!(make_missing, self, self.pos())
} else {
let (items, _, _) = self.parse_separated_list_predicate(
|x| x == separator_kind,
allow_trailing,
close_predicate,
error,
parse_item,
);
items
}
}
fn is_next_xhp_class_name(&self) -> bool {
self.lexer().is_next_xhp_class_name()
}
fn next_xhp_modifier_class_name_or_other_token(&mut self) -> Token<S> {
if self.is_next_name() {
self.next_xhp_modifier_class_name()
} else {
self.next_token()
}
}
fn next_xhp_class_name_or_other_token(&mut self) -> Token<S> {
if self.is_next_xhp_class_name() {
self.next_xhp_class_name()
} else {
self.next_token()
}
}
fn parse_separated_list_opt<F>(
&mut self,
separator_kind: TokenKind,
allow_trailing: SeparatedListKind,
close_kind: TokenKind,
error: Error,
parse_item: F,
) -> S::R
where
F: Fn(&mut Self) -> S::R,
{
self.parse_separated_list_opt_predicate(
separator_kind,
allow_trailing,
|x| x == close_kind,
error,
parse_item,
)
}
fn parse_comma_list_opt_allow_trailing<F>(
&mut self,
close_kind: TokenKind,
error: Error,
parse_item: F,
) -> S::R
where
F: Fn(&mut Self) -> S::R,
{
self.parse_separated_list_opt(
TokenKind::Comma,
SeparatedListKind::TrailingAllowed,
close_kind,
error,
parse_item,
)
}
fn parse_comma_list_opt<F>(
&mut self,
close_kind: TokenKind,
error: Error,
parse_item: F,
) -> S::R
where
F: Fn(&mut Self) -> S::R,
{
self.parse_separated_list_opt(
TokenKind::Comma,
SeparatedListKind::NoTrailing,
close_kind,
error,
parse_item,
)
}
fn parse_comma_list_opt_items_opt<F>(
&mut self,
close_kind: TokenKind,
error: Error,
parse_item: F,
) -> S::R
where
F: Fn(&mut Self) -> S::R,
{
self.parse_separated_list_opt(
TokenKind::Comma,
SeparatedListKind::ItemsOptional,
close_kind,
error,
parse_item,
)
}
fn parse_comma_list_opt_allow_trailing_predicate<P, F>(
&mut self,
close_kind: P,
error: Error,
parse_item: F,
) -> S::R
where
P: Fn(TokenKind) -> bool,
F: Fn(&mut Self) -> S::R,
{
self.parse_separated_list_opt_predicate(
TokenKind::Comma,
SeparatedListKind::TrailingAllowed,
close_kind,
error,
parse_item,
)
}
fn parse_comma_list<F>(&mut self, close_kind: TokenKind, error: Error, parse_item: F) -> S::R
where
F: Fn(&mut Self) -> S::R,
{
let (items, _) = self.parse_separated_list(
TokenKind::Comma,
SeparatedListKind::NoTrailing,
close_kind,
error,
parse_item,
);
items
}
fn parse_delimited_list<P>(
&mut self,
left_kind: TokenKind,
left_error: Error,
right_kind: TokenKind,
right_error: Error,
parse_items: P,
) -> (S::R, S::R, S::R)
where
P: FnOnce(&mut Self) -> S::R,
{
let left = self.require_token(left_kind, left_error);
let items = parse_items(self);
let right = self.require_token(right_kind, right_error);
(left, items, right)
}
fn parse_braced_list<P>(&mut self, parse_items: P) -> (S::R, S::R, S::R)
where
P: FnOnce(&mut Self) -> S::R,
{
self.parse_delimited_list(
TokenKind::LeftBrace,
Errors::error1034,
TokenKind::RightBrace,
Errors::error1006,
parse_items,
)
}
fn parse_parenthesized_list<F>(&mut self, parse_items: F) -> (S::R, S::R, S::R)
where
F: FnOnce(&mut Self) -> S::R,
{
self.parse_delimited_list(
TokenKind::LeftParen,
Errors::error1019,
TokenKind::RightParen,
Errors::error1011,
parse_items,
)
}
fn parse_parenthesized_comma_list<F>(&mut self, parse_item: F) -> (S::R, S::R, S::R)
where
F: Fn(&mut Self) -> S::R,
{
let parse_items =
|x: &mut Self| x.parse_comma_list(TokenKind::RightParen, Errors::error1011, parse_item);
self.parse_parenthesized_list(parse_items)
}
fn parse_parenthesized_comma_list_opt_allow_trailing<F>(
&mut self,
parse_item: F,
) -> (S::R, S::R, S::R)
where
F: Fn(&mut Self) -> S::R,
{
let parse_items = |x: &mut Self| {
x.parse_comma_list_opt_allow_trailing(
TokenKind::RightParen,
Errors::error1011,
parse_item,
)
};
self.parse_parenthesized_list(parse_items)
}
fn parse_parenthesized_comma_list_opt_items_opt<F>(
&mut self,
parse_item: F,
) -> (S::R, S::R, S::R)
where
F: Fn(&mut Self) -> S::R,
{
let parse_items = |x: &mut Self| {
x.parse_comma_list_opt_items_opt(TokenKind::RightParen, Errors::error1011, parse_item)
};
self.parse_parenthesized_list(parse_items)
}
fn parse_braced_comma_list_opt_allow_trailing<F>(&mut self, parse_item: F) -> (S::R, S::R, S::R)
where
F: Fn(&mut Self) -> S::R,
{
let parse_items = |parser: &mut Self| {
parser.parse_comma_list_opt_allow_trailing(
TokenKind::RightBrace,
Errors::error1006,
parse_item,
)
};
self.parse_braced_list(parse_items)
}
fn parse_bracketted_list<F>(&mut self, parse_items: F) -> (S::R, S::R, S::R)
where
F: FnOnce(&mut Self) -> S::R,
{
self.parse_delimited_list(
TokenKind::LeftBracket,
Errors::error1026,
TokenKind::RightBracket,
Errors::error1031,
parse_items,
)
}
fn parse_bracketted_comma_list_opt_allow_trailing<F>(
&mut self,
parse_item: F,
) -> (S::R, S::R, S::R)
where
F: Fn(&mut Self) -> S::R,
{
let parse_items = |x: &mut Self| {
x.parse_comma_list_opt_allow_trailing(
TokenKind::RightBracket,
Errors::error1031,
parse_item,
)
};
self.parse_bracketted_list(parse_items)
}
fn parse_double_angled_list<F>(&mut self, parse_items: F) -> (S::R, S::R, S::R)
where
F: FnOnce(&mut Self) -> S::R,
{
self.parse_delimited_list(
TokenKind::LessThanLessThan,
Errors::error1029,
TokenKind::GreaterThanGreaterThan,
Errors::error1029,
parse_items,
)
}
fn parse_double_angled_comma_list_allow_trailing<F>(
&mut self,
parse_item: F,
) -> (S::R, S::R, S::R)
where
F: Fn(&mut Self) -> S::R,
{
let parse_items = |x: &mut Self| {
let (items, _) = x.parse_comma_list_allow_trailing(
TokenKind::GreaterThanGreaterThan,
Errors::error1029,
parse_item,
);
items
};
self.parse_double_angled_list(parse_items)
}
fn scan_remaining_qualified_name(&mut self, name_token: S::R) -> S::R {
let (name, _) = self.scan_remaining_qualified_name_extended(name_token);
name
}
// Parse with parse_item while a condition is met.
fn parse_list_while<F, P>(&mut self, parse_item: F, predicate: P) -> S::R
where
F: Fn(&mut Self) -> S::R,
P: Fn(&Self) -> bool,
{
let mut items = vec![];
loop {
if self.peek_token_kind() == TokenKind::EndOfFile || !predicate(self) {
break;
};
let lexer_before = self.lexer().clone();
let result = parse_item(self);
if result.is_missing() {
// ERROR RECOVERY: If the item is was parsed as 'missing', then it means
// the parser bailed out of that scope. So, pass on whatever's been
// accumulated so far, but with a 'Missing' SyntaxNode prepended.
items.push(result);
break;
}
if lexer_before.start() == self.lexer().start()
&& lexer_before.offset() == self.lexer().offset()
{
// INFINITE LOOP PREVENTION: If parse_item does not actually make
// progress, just bail
items.push(result);
break;
}
// Or if nothing's wrong, continue.
items.push(result)
}
S!(make_list, self, items, self.pos())
}
fn parse_terminated_list<F>(&mut self, parse_item: F, terminator: TokenKind) -> S::R
where
F: Fn(&mut Self) -> S::R,
{
let predicate = |x: &Self| x.peek_token_kind() != terminator;
self.parse_list_while(parse_item, predicate)
}
fn skip_and_log_unexpected_token(&mut self, generate_error: bool) {
if generate_error {
let extra_str = &self.current_token_text();
self.with_error_on_whole_token(Errors::error1057(extra_str))
};
let token = self.next_token();
self.add_skipped_token(token)
}
// Returns true if the strings underlying two tokens are of the same length
// but with one character different.
fn one_character_different<'b>(str1: &'b [u8], str2: &'b [u8]) -> bool {
if str1.len() != str2.len() {
false
} else {
// both strings have same length
let str_len = str1.len();
for i in 0..str_len {
if str1[i] != str2[i] {
// Allow only one mistake
return str1[i + 1..] == str2[i + 1..];
}
}
true
}
}
// Compare the text of the token we have in hand to the text of the
// anticipated kind. Note: this automatically returns false for any
// TokenKinds of length 1.
fn is_misspelled_kind(kind: TokenKind, token_str: &str) -> bool {
let tokenkind_str = kind.to_string().as_bytes();
let token_str = token_str.as_bytes();
if tokenkind_str.len() <= 1 {
false
} else {
Self::one_character_different(tokenkind_str, token_str)
}
}
fn is_misspelled_from<'b>(kind_list: &[TokenKind], token_str: &'b str) -> bool {
kind_list
.iter()
.any(|x| Self::is_misspelled_kind(*x, token_str))
}
// If token_str is a misspelling (by our narrow definition of misspelling)
// of a TokenKind from kind_list, return the TokenKind that token_str is a
// misspelling of. Otherwise, return None.
fn suggested_kind_from(kind_list: &[TokenKind], token_str: &str) -> Option<TokenKind> {
kind_list.iter().find_map(|x| {
if Self::is_misspelled_kind(*x, token_str) {
Some(*x)
} else {
None
}
})
}
fn skip_and_log_misspelled_token(&mut self, required_kind: TokenKind) {
let received_str = &self.current_token_text();
let required_str = required_kind.to_string();
self.with_error_on_whole_token(Errors::error1058(received_str, required_str));
self.skip_and_log_unexpected_token(/* generate_error:*/ false)
}
fn require_token_one_of(&mut self, kinds: &[TokenKind], error: Error) -> S::R {
let token_kind = self.peek_token_kind();
if kinds.iter().any(|x| *x == token_kind) {
let token = self.next_token();
S!(make_token, self, token)
} else {
// ERROR RECOVERY: Look at the next token after this. Is it the one we
// require? If so, process the current token as extra and return the next
// one. Otherwise, create a missing token for what we required,
// and continue on from the current token (don't skip it).
let next_kind = self.peek_token_kind_with_lookahead(1);
if kinds.iter().any(|x| *x == next_kind) {
self.skip_and_log_unexpected_token(true);
let token = self.next_token();
S!(make_token, self, token)
} else {
// ERROR RECOVERY: We know we didn't encounter an extra token.
// So, as a second line of defense, check if the current token
// is a misspelling, by our existing narrow definition of misspelling.
let is_misspelling =
|k: &&TokenKind| Self::is_misspelled_kind(**k, self.current_token_text());
let kind = kinds.iter().find(is_misspelling);
match kind {
Some(kind) => {
self.skip_and_log_misspelled_token(*kind);
S!(make_missing, self, self.pos())
}
None => {
self.with_error(error);
S!(make_missing, self, self.pos())
}
}
}
}
}
fn require_token(&mut self, kind: TokenKind, error: Error) -> S::R {
// Must behave as `require_token_one_of parser [kind] error`
if self.peek_token_kind() == kind {
let token = self.next_token();
S!(make_token, self, token)
} else {
// ERROR RECOVERY: Look at the next token after this. Is it the one we
// require? If so, process the current token as extra and return the next
// one. Otherwise, create a missing token for what we required,
// and continue on from the current token (don't skip it).
let next_kind = self.peek_token_kind_with_lookahead(1);
if next_kind == kind {
self.skip_and_log_unexpected_token(true);
let token = self.next_token();
S!(make_token, self, token)
} else {
// ERROR RECOVERY: We know we didn't encounter an extra token.
// So, as a second line of defense, check if the current token
// is a misspelling, by our existing narrow definition of misspelling.
if Self::is_misspelled_kind(kind, self.current_token_text()) {
self.skip_and_log_misspelled_token(kind);
S!(make_missing, self, self.pos())
} else {
self.with_error(error);
S!(make_missing, self, self.pos())
}
}
}
}
fn require_and_return_token(&mut self, kind: TokenKind, error: Error) -> Option<Token<S>> {
if self.peek_token_kind() == kind {
Some(self.next_token())
} else {
// ERROR RECOVERY: Look at the next token after this. Is it the one we
// require? If so, process the current token as extra and return the next
// one. Otherwise, create a missing token for what we required,
// and continue on from the current token (don't skip it).
let next_kind = self.peek_token_kind_with_lookahead(1);
if next_kind == kind {
self.skip_and_log_unexpected_token(true);
Some(self.next_token())
} else {
// ERROR RECOVERY: We know we didn't encounter an extra token.
// So, as a second line of defense, check if the current token
// is a misspelling, by our existing narrow definition of misspelling.
if Self::is_misspelled_kind(kind, self.current_token_text()) {
self.skip_and_log_misspelled_token(kind);
None
} else {
self.with_error(error);
None
}
}
}
}
fn require_name_allow_all_keywords(&mut self) -> S::R {
let mut parser1 = self.clone();
let token = parser1.next_token_as_name();
if token.kind() == TokenKind::Name {
self.continue_from(parser1);
S!(make_token, self, token)
} else {
// ERROR RECOVERY: Create a missing token for the expected token,
// and continue on from the current token. Don't skip it.
self.with_error(Errors::error1004);
S!(make_missing, self, self.pos())
}
}
fn require_right_paren(&mut self) -> S::R {
self.require_token(TokenKind::RightParen, Errors::error1011)
}
fn require_semicolon_token(&mut self, saw_type_name: bool) -> Option<Token<S>> {
match self.peek_token_kind() {
TokenKind::Variable if saw_type_name => self
.require_and_return_token(TokenKind::Semicolon, Errors::local_variable_with_type),
_ => self.require_and_return_token(TokenKind::Semicolon, Errors::error1010),
}
}
fn require_semicolon(&mut self) -> S::R {
self.require_token(TokenKind::Semicolon, Errors::error1010)
}
fn check_stack_limit(&self) {
if let Some(limit) = self.context().stack_limit.as_ref() {
limit.panic_if_exceeded()
}
}
}
| add_skipped_token |
args.ts | import * as yargs from 'yargs';
export const args: () => Arguments = function getArgs() {
const argv = yargs
.option('no-dependencies',
{
alias: 'no-dep',
describe: 'Don\'t show dependencies',
type: 'boolean'
}
)
.option('no-devDependencies',
{
alias: 'no-dev',
describe: 'Don\'t show devDependencies',
type: 'boolean'
}
)
.option('no-peerDependencies',
{
alias: 'no-peer',
describe: 'Don\'t show peerDependencies',
type: 'boolean'
}
)
.option('no-optionalDependencies',
{
alias: 'no-optional',
describe: 'Don\'t show optionalDependencies',
type: 'boolean'
}
)
.completion()
.recommendCommands()
.help()
.argv;
argv.packages = argv._; | export type Arguments = {
'no-dependencies'?: boolean,
'no-devDependencies'?: boolean,
'no-peerDependencies'?: boolean,
'no-optionalDependencies'?: boolean
noDependencies?: boolean,
noDevDependencies?: boolean,
noPeerDependencies?: boolean,
noOptionalDependencies?: boolean
packages: string[]
} |
return argv;
};
|
iid.go | package aws
import (
"context"
"crypto"
"crypto/rsa"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"fmt"
"math"
"os"
"regexp"
"sort"
"strings"
"sync"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/arn"
"github.com/aws/aws-sdk-go/aws/ec2metadata"
"github.com/aws/aws-sdk-go/service/ec2"
"github.com/aws/aws-sdk-go/service/iam"
"github.com/hashicorp/go-hclog"
"github.com/hashicorp/hcl"
"github.com/spiffe/go-spiffe/v2/spiffeid"
nodeattestorv1 "github.com/spiffe/spire-plugin-sdk/proto/spire/plugin/server/nodeattestor/v1"
configv1 "github.com/spiffe/spire-plugin-sdk/proto/spire/service/common/config/v1"
"github.com/spiffe/spire/pkg/common/agentpathtemplate"
"github.com/spiffe/spire/pkg/common/catalog"
caws "github.com/spiffe/spire/pkg/common/plugin/aws"
nodeattestorbase "github.com/spiffe/spire/pkg/server/plugin/nodeattestor/base"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
var (
awsTimeout = 5 * time.Second
instanceFilters = []*ec2.Filter{
{
Name: aws.String("instance-state-name"),
Values: []*string{
aws.String("pending"),
aws.String("running"),
},
},
}
)
const (
maxSecondsBetweenDeviceAttachments int64 = 60
// accessKeyIDVarName env var name for AWS access key ID
accessKeyIDVarName = "AWS_ACCESS_KEY_ID"
// secretAccessKeyVarName env car name for AWS secret access key
secretAccessKeyVarName = "AWS_SECRET_ACCESS_KEY" //nolint: gosec // false positive
)
// BuiltIn creates a new built-in plugin
func BuiltIn() catalog.BuiltIn {
return builtin(New())
}
func builtin(p *IIDAttestorPlugin) catalog.BuiltIn {
return catalog.MakeBuiltIn(caws.PluginName,
nodeattestorv1.NodeAttestorPluginServer(p),
configv1.ConfigServiceServer(p),
)
}
// IIDAttestorPlugin implements node attestation for agents running in aws.
type IIDAttestorPlugin struct {
nodeattestorbase.Base
nodeattestorv1.UnsafeNodeAttestorServer
configv1.UnsafeConfigServer
config *IIDAttestorConfig
mtx sync.RWMutex
clients *clientsCache
// test hooks
hooks struct {
getAWSCAPublicKey func() (*rsa.PublicKey, error)
getenv func(string) string
}
log hclog.Logger
}
// IIDAttestorConfig holds hcl configuration for IID attestor plugin
type IIDAttestorConfig struct {
SessionConfig `hcl:",squash"`
SkipBlockDevice bool `hcl:"skip_block_device"`
DisableInstanceProfileSelectors bool `hcl:"disable_instance_profile_selectors"`
LocalValidAcctIDs []string `hcl:"account_ids_for_local_validation"`
AgentPathTemplate string `hcl:"agent_path_template"`
AssumeRole string `hcl:"assume_role"`
pathTemplate *agentpathtemplate.Template
trustDomain spiffeid.TrustDomain
awsCAPublicKey *rsa.PublicKey
}
// New creates a new IIDAttestorPlugin.
func New() *IIDAttestorPlugin |
// Attest implements the server side logic for the aws iid node attestation plugin.
func (p *IIDAttestorPlugin) Attest(stream nodeattestorv1.NodeAttestor_AttestServer) error {
req, err := stream.Recv()
if err != nil {
return err
}
payload := req.GetPayload()
if payload == nil {
return status.Error(codes.InvalidArgument, "missing attestation payload")
}
c, err := p.getConfig()
if err != nil {
return err
}
attestationData, err := unmarshalAndValidateIdentityDocument(payload, c.awsCAPublicKey)
if err != nil {
return err
}
inTrustAcctList := false
for _, id := range c.LocalValidAcctIDs {
if attestationData.AccountID == id {
inTrustAcctList = true
break
}
}
awsClient, err := p.clients.getClient(attestationData.Region, attestationData.AccountID)
if err != nil {
return status.Errorf(codes.Internal, "failed to get client: %v", err)
}
ctx, cancel := context.WithTimeout(stream.Context(), awsTimeout)
defer cancel()
instancesDesc, err := awsClient.DescribeInstancesWithContext(ctx, &ec2.DescribeInstancesInput{
InstanceIds: []*string{aws.String(attestationData.InstanceID)},
Filters: instanceFilters,
})
if err != nil {
return status.Errorf(codes.Internal, "failed to describe instance: %v", err)
}
// Ideally we wouldn't do this work at all if the agent has already attested
// e.g. do it after the call to `p.IsAttested`, however, we may need
// the instance to construct tags used in the agent ID.
//
// This overhead will only effect agents attempting to re-attest which
// should be a very small portion of the overall server workload. This
// is a potential DoS vector.
shouldCheckBlockDevice := !inTrustAcctList && !c.SkipBlockDevice
var instance *ec2.Instance
var tags = make(instanceTags)
if strings.Contains(c.AgentPathTemplate, ".Tags") || shouldCheckBlockDevice {
var err error
instance, err = p.getEC2Instance(instancesDesc)
if err != nil {
return err
}
tags = tagsFromInstance(instance)
}
if shouldCheckBlockDevice {
if err = p.checkBlockDevice(instance); err != nil {
return status.Errorf(codes.Internal, "failed aws ec2 attestation: %v", err)
}
}
agentID, err := makeAgentID(c.trustDomain, c.pathTemplate, attestationData, tags)
if err != nil {
return status.Errorf(codes.Internal, "failed to create spiffe ID: %v", err)
}
attested, err := p.IsAttested(stream.Context(), agentID.String())
switch {
case err != nil:
return err
case attested:
return status.Error(codes.PermissionDenied, "IID has already been used to attest an agent")
}
selectorValues, err := p.resolveSelectors(stream.Context(), instancesDesc, awsClient)
if err != nil {
return err
}
return stream.Send(&nodeattestorv1.AttestResponse{
Response: &nodeattestorv1.AttestResponse_AgentAttributes{
AgentAttributes: &nodeattestorv1.AgentAttributes{
CanReattest: false,
SpiffeId: agentID.String(),
SelectorValues: selectorValues,
},
},
})
}
// Configure configures the IIDAttestorPlugin.
func (p *IIDAttestorPlugin) Configure(ctx context.Context, req *configv1.ConfigureRequest) (*configv1.ConfigureResponse, error) {
config := new(IIDAttestorConfig)
if err := hcl.Decode(config, req.HclConfiguration); err != nil {
return nil, status.Errorf(codes.InvalidArgument, "unable to decode configuration: %v", err)
}
// Get the AWS CA public key. We do this lazily on configure so deployments
// not using this plugin don't pay for parsing it on startup. This
// operation should not fail, but we check the return value just in case.
awsCAPublicKey, err := p.hooks.getAWSCAPublicKey()
if err != nil {
return nil, status.Errorf(codes.Internal, "failed to load the AWS CA public key: %v", err)
}
config.awsCAPublicKey = awsCAPublicKey
if err := config.Validate(p.hooks.getenv(accessKeyIDVarName), p.hooks.getenv(secretAccessKeyVarName)); err != nil {
return nil, err
}
if req.CoreConfiguration == nil {
return nil, status.Error(codes.InvalidArgument, "core configuration is required")
}
config.trustDomain, err = spiffeid.TrustDomainFromString(req.CoreConfiguration.TrustDomain)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "core configuration has invalid trust domain: %v", err)
}
config.pathTemplate = defaultAgentPathTemplate
if len(config.AgentPathTemplate) > 0 {
tmpl, err := agentpathtemplate.Parse(config.AgentPathTemplate)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "failed to parse agent svid template: %q", config.AgentPathTemplate)
}
config.pathTemplate = tmpl
}
p.mtx.Lock()
defer p.mtx.Unlock()
p.config = config
p.clients.configure(config.SessionConfig)
return &configv1.ConfigureResponse{}, nil
}
// SetLogger sets this plugin's logger
func (p *IIDAttestorPlugin) SetLogger(log hclog.Logger) {
p.log = log
}
func (p *IIDAttestorPlugin) checkBlockDevice(instance *ec2.Instance) error {
ifaceZeroDeviceIndex := *instance.NetworkInterfaces[0].Attachment.DeviceIndex
if ifaceZeroDeviceIndex != 0 {
return fmt.Errorf("the EC2 instance network interface attachment device index must be zero (has %d)", ifaceZeroDeviceIndex)
}
ifaceZeroAttachTime := instance.NetworkInterfaces[0].Attachment.AttachTime
// skip anti-tampering mechanism when RootDeviceType is instance-store
// specifically, if device type is persistent, and the device was attached past
// a threshold time after instance boot, fail attestation
if *instance.RootDeviceType != ec2.DeviceTypeInstanceStore {
rootDeviceIndex := -1
for i, bdm := range instance.BlockDeviceMappings {
if *bdm.DeviceName == *instance.RootDeviceName {
rootDeviceIndex = i
break
}
}
if rootDeviceIndex == -1 {
return fmt.Errorf("failed to locate the root device block mapping with name %q", *instance.RootDeviceName)
}
rootDeviceAttachTime := instance.BlockDeviceMappings[rootDeviceIndex].Ebs.AttachTime
attachTimeDisparitySeconds := int64(math.Abs(float64(ifaceZeroAttachTime.Unix() - rootDeviceAttachTime.Unix())))
if attachTimeDisparitySeconds > maxSecondsBetweenDeviceAttachments {
return fmt.Errorf("failed checking the disparity device attach times, root BlockDeviceMapping and NetworkInterface[0] attach times differ by %d seconds", attachTimeDisparitySeconds)
}
}
return nil
}
func (p *IIDAttestorPlugin) getConfig() (*IIDAttestorConfig, error) {
p.mtx.RLock()
defer p.mtx.RUnlock()
if p.config == nil {
return nil, status.Error(codes.FailedPrecondition, "not configured")
}
return p.config, nil
}
func (p *IIDAttestorPlugin) getEC2Instance(instancesDesc *ec2.DescribeInstancesOutput) (*ec2.Instance, error) {
if len(instancesDesc.Reservations) < 1 {
return nil, status.Error(codes.Internal, "failed to query AWS via describe-instances: returned no reservations")
}
if len(instancesDesc.Reservations[0].Instances) < 1 {
return nil, status.Error(codes.Internal, "failed to query AWS via describe-instances: returned no instances")
}
return instancesDesc.Reservations[0].Instances[0], nil
}
func tagsFromInstance(instance *ec2.Instance) instanceTags {
tags := make(instanceTags, len(instance.Tags))
for _, tag := range instance.Tags {
if tag != nil && tag.Key != nil && tag.Value != nil {
tags[*tag.Key] = *tag.Value
}
}
return tags
}
func unmarshalAndValidateIdentityDocument(data []byte, pubKey *rsa.PublicKey) (ec2metadata.EC2InstanceIdentityDocument, error) {
var attestationData caws.IIDAttestationData
if err := json.Unmarshal(data, &attestationData); err != nil {
return ec2metadata.EC2InstanceIdentityDocument{}, status.Errorf(codes.InvalidArgument, "failed to unmarshal the attestation data: %v", err)
}
var doc ec2metadata.EC2InstanceIdentityDocument
if err := json.Unmarshal([]byte(attestationData.Document), &doc); err != nil {
return ec2metadata.EC2InstanceIdentityDocument{}, status.Errorf(codes.InvalidArgument, "failed to unmarshal the IID: %v", err)
}
docHash := sha256.Sum256([]byte(attestationData.Document))
sigBytes, err := base64.StdEncoding.DecodeString(attestationData.Signature)
if err != nil {
return ec2metadata.EC2InstanceIdentityDocument{}, status.Errorf(codes.InvalidArgument, "failed to decode the IID signature: %v", err)
}
if err := rsa.VerifyPKCS1v15(pubKey, crypto.SHA256, docHash[:], sigBytes); err != nil {
return ec2metadata.EC2InstanceIdentityDocument{}, status.Errorf(codes.InvalidArgument, "failed to verify the cryptographic signature: %v", err)
}
return doc, nil
}
func (p *IIDAttestorPlugin) resolveSelectors(parent context.Context, instancesDesc *ec2.DescribeInstancesOutput, client Client) ([]string, error) {
selectorSet := map[string]bool{}
addSelectors := func(values []string) {
for _, value := range values {
selectorSet[value] = true
}
}
c, err := p.getConfig()
if err != nil {
return nil, err
}
for _, reservation := range instancesDesc.Reservations {
for _, instance := range reservation.Instances {
addSelectors(resolveTags(instance.Tags))
addSelectors(resolveSecurityGroups(instance.SecurityGroups))
if !c.DisableInstanceProfileSelectors && instance.IamInstanceProfile != nil && instance.IamInstanceProfile.Arn != nil {
instanceProfileName, err := instanceProfileNameFromArn(*instance.IamInstanceProfile.Arn)
if err != nil {
return nil, err
}
ctx, cancel := context.WithTimeout(parent, awsTimeout)
defer cancel()
output, err := client.GetInstanceProfileWithContext(ctx, &iam.GetInstanceProfileInput{
InstanceProfileName: aws.String(instanceProfileName),
})
if err != nil {
return nil, status.Errorf(codes.Internal, "failed to get intance profile: %v", err)
}
addSelectors(resolveInstanceProfile(output.InstanceProfile))
}
}
}
// build and sort selectors
selectors := []string{}
for value := range selectorSet {
selectors = append(selectors, value)
}
sort.Strings(selectors)
return selectors, nil
}
func resolveTags(tags []*ec2.Tag) []string {
values := make([]string, 0, len(tags))
for _, tag := range tags {
if tag != nil {
values = append(values, fmt.Sprintf("tag:%s:%s", aws.StringValue(tag.Key), aws.StringValue(tag.Value)))
}
}
return values
}
func resolveSecurityGroups(sgs []*ec2.GroupIdentifier) []string {
values := make([]string, 0, len(sgs)*2)
for _, sg := range sgs {
if sg != nil {
values = append(values,
fmt.Sprintf("sg:id:%s", aws.StringValue(sg.GroupId)),
fmt.Sprintf("sg:name:%s", aws.StringValue(sg.GroupName)),
)
}
}
return values
}
func resolveInstanceProfile(instanceProfile *iam.InstanceProfile) []string {
if instanceProfile == nil {
return nil
}
values := make([]string, 0, len(instanceProfile.Roles))
for _, role := range instanceProfile.Roles {
if role != nil && role.Arn != nil {
values = append(values, fmt.Sprintf("iamrole:%s", aws.StringValue(role.Arn)))
}
}
return values
}
var reInstanceProfileARNResource = regexp.MustCompile(`instance-profile[/:](.+)`)
func instanceProfileNameFromArn(profileArn string) (string, error) {
a, err := arn.Parse(profileArn)
if err != nil {
return "", status.Errorf(codes.Internal, "failed to parse %v", err)
}
m := reInstanceProfileARNResource.FindStringSubmatch(a.Resource)
if m == nil {
return "", status.Errorf(codes.Internal, "arn is not for an instance profile")
}
name := strings.Split(m[1], "/")
// only the last element is the profile name
return name[len(name)-1], nil
}
| {
p := &IIDAttestorPlugin{}
p.clients = newClientsCache(defaultNewClientCallback)
p.hooks.getAWSCAPublicKey = getAWSCAPublicKey
p.hooks.getenv = os.Getenv
return p
} |
cairo_back.rs | // allows e.g. raw_data[dst_off + x * 4 + 2] = buf[src_off + x * 4 + 0];
#![allow(clippy::identity_op)]
//! Support for piet Cairo back-end.
use cairo::{Context, Format, ImageSurface};
#[cfg(feature = "png")]
use png::{ColorType, Encoder};
#[cfg(feature = "png")]
use std::fs::File;
#[cfg(feature = "png")]
use std::io::BufWriter;
use std::marker::PhantomData;
use std::path::Path;
use piet::ImageFormat;
#[doc(hidden)]
pub use piet_cairo::*;
/// The `RenderContext` for the Cairo backend, which is selected.
pub type Piet<'a> = CairoRenderContext<'a>;
/// The associated brush type for this backend.
///
/// This type matches `RenderContext::Brush`
pub type Brush = piet_cairo::Brush;
/// The associated text factory for this backend.
///
/// This type matches `RenderContext::Text`
pub type PietText = CairoText;
/// The associated font type for this backend.
///
/// This type matches `RenderContext::Text::Font`
pub type PietFont = CairoFont;
/// The associated font builder for this backend.
///
/// This type matches `RenderContext::Text::FontBuilder`
pub type PietFontBuilder = CairoFontBuilder;
/// The associated text layout type for this backend.
///
/// This type matches `RenderContext::Text::TextLayout`
pub type PietTextLayout = CairoTextLayout;
/// The associated text layout builder for this backend.
///
/// This type matches `RenderContext::Text::TextLayoutBuilder`
pub type PietTextLayoutBuilder = CairoTextLayoutBuilder;
/// The associated image type for this backend.
///
/// This type matches `RenderContext::Image`
pub type Image = ImageSurface;
/// A struct that can be used to create bitmap render contexts.
///
/// In the case of Cairo, being a software renderer, no state is needed.
pub struct Device {
// Since not all backends can support `Device: Sync`, make it non-Sync here to, for fewer
// portability surprises.
marker: std::marker::PhantomData<*const ()>,
}
unsafe impl Send for Device {}
/// A struct provides a `RenderContext` and then can have its bitmap extracted.
pub struct BitmapTarget<'a> {
surface: ImageSurface,
cr: Context,
phantom: PhantomData<&'a ()>,
}
impl Device {
/// Create a new device.
pub fn new() -> Result<Device, piet::Error> |
/// Create a new bitmap target.
pub fn bitmap_target(
&mut self,
width: usize,
height: usize,
pix_scale: f64,
) -> Result<BitmapTarget, piet::Error> {
let surface = ImageSurface::create(Format::ARgb32, width as i32, height as i32).unwrap();
let cr = Context::new(&surface);
cr.scale(pix_scale, pix_scale);
let phantom = Default::default();
Ok(BitmapTarget {
surface,
cr,
phantom,
})
}
}
impl<'a> BitmapTarget<'a> {
/// Get a piet `RenderContext` for the bitmap.
///
/// Note: caller is responsible for calling `finish` on the render
/// context at the end of rendering.
pub fn render_context(&mut self) -> CairoRenderContext {
CairoRenderContext::new(&self.cr)
}
/// Get raw RGBA pixels from the bitmap by copying them into `buf`. If all the pixels were
/// copied, returns the number of bytes written. If `buf` wasn't big enough, returns an error
/// and doesn't write anything.
pub fn copy_raw_pixels(
&mut self,
fmt: ImageFormat,
buf: &mut [u8],
) -> Result<usize, piet::Error> {
// TODO: convert other formats.
if fmt != ImageFormat::RgbaPremul {
return Err(piet::Error::NotSupported);
}
self.surface.flush();
let stride = self.surface.get_stride() as usize;
let width = self.surface.get_width() as usize;
let height = self.surface.get_height() as usize;
let size = width * height * 4;
if buf.len() < size {
return Err(piet::Error::InvalidInput);
}
unsafe {
// Cairo's rust wrapper has extra safety checks that we want to avoid: it won't let us
// get the data from an ImageSurface that's still referenced by a context. The C docs
// don't seem to think that's a problem, as long as we call flush (which we already
// did), and promise not to mutate anything.
// https://www.cairographics.org/manual/cairo-Image-Surfaces.html#cairo-image-surface-get-data
//
// TODO: we can simplify this once cairo makes a release containing
// https://github.com/gtk-rs/cairo/pull/330
let data_len = height.saturating_sub(1) * stride + width * 4;
let data = {
let data_ptr = cairo_sys::cairo_image_surface_get_data(self.surface.to_raw_none());
if data_ptr.is_null() {
let err = cairo::BorrowError::from(cairo::Status::SurfaceFinished);
return Err((Box::new(err) as Box<dyn std::error::Error>).into());
}
std::slice::from_raw_parts(data_ptr, data_len)
};
// A sanity check for all the unsafe indexing that follows.
assert!(data.get(data_len - 1).is_some());
assert!(buf.get(size - 1).is_some());
for y in 0..height {
let src_off = y * stride;
let dst_off = y * width * 4;
for x in 0..width {
// These unchecked indexes allow the autovectorizer to shine.
// Note that dst_off maxes out at (height - 1) * width * 4, and so
// dst_off + x * 4 + 3 maxes out at height * width * 4 - 1, which is size - 1.
// Also, src_off maxes out at (height - 1) * stride, and so
// src_off + x * 4 + 3 maxes out at (height - 1) * stride + width * 4 - 1,
// which is data_len - 1.
*buf.get_unchecked_mut(dst_off + x * 4 + 0) =
*data.get_unchecked(src_off + x * 4 + 2);
*buf.get_unchecked_mut(dst_off + x * 4 + 1) =
*data.get_unchecked(src_off + x * 4 + 1);
*buf.get_unchecked_mut(dst_off + x * 4 + 2) =
*data.get_unchecked(src_off + x * 4 + 0);
*buf.get_unchecked_mut(dst_off + x * 4 + 3) =
*data.get_unchecked(src_off + x * 4 + 3);
}
}
}
Ok(size)
}
/// Get raw RGBA pixels from the bitmap.
pub fn raw_pixels(&mut self, fmt: ImageFormat) -> Result<Vec<u8>, piet::Error> {
let width = self.surface.get_width() as usize;
let height = self.surface.get_height() as usize;
let mut buf = vec![0; width * height * 4];
self.copy_raw_pixels(fmt, &mut buf)?;
Ok(buf)
}
/// Get raw RGBA pixels from the bitmap.
#[deprecated(since = "0.2.0", note = "use raw_pixels")]
pub fn into_raw_pixels(mut self, fmt: ImageFormat) -> Result<Vec<u8>, piet::Error> {
self.raw_pixels(fmt)
}
/// Save bitmap to RGBA PNG file
#[cfg(feature = "png")]
pub fn save_to_file<P: AsRef<Path>>(mut self, path: P) -> Result<(), piet::Error> {
let height = self.surface.get_height();
let width = self.surface.get_width();
let image = self.raw_pixels(ImageFormat::RgbaPremul)?;
let file = BufWriter::new(File::create(path).map_err(Into::<Box<_>>::into)?);
let mut encoder = Encoder::new(file, width as u32, height as u32);
encoder.set_color(ColorType::RGBA);
encoder
.write_header()
.map_err(Into::<Box<_>>::into)?
.write_image_data(&image)
.map_err(Into::<Box<_>>::into)?;
Ok(())
}
/// Stub for feature is missing
#[cfg(not(feature = "png"))]
pub fn save_to_file<P: AsRef<Path>>(self, _path: P) -> Result<(), piet::Error> {
Err(piet::Error::MissingFeature)
}
}
| {
Ok(Device {
marker: std::marker::PhantomData,
})
} |
traceDetailsViewCommands.js | import { newLogger } from '@dbux/common/src/log/logger';
import { registerCommand } from './commandUtil';
import { showInformationMessage } from '../codeUtil/codeModals';
import { nextMode } from '../traceDetailsView/nodes/ExecutionsTDNodes';
import { NavigationMethods } from '../traceDetailsView/nodes/NavigationNode';
import { translate } from '../lang';
// eslint-disable-next-line no-unused-vars
const { log, debug, warn, error: logError } = newLogger('Commands');
export function initTraceDetailsViewCommands(context, traceDetailsViewController) {
registerCommand(context,
'dbuxTraceDetailsView.nextGroupingMode',
(/* node */) => {
nextMode();
traceDetailsViewController.refresh();
}
);
registerCommand(context,
'dbuxTraceDetailsView.expandNode',
async (node) => {
await node.treeNodeProvider.treeView.reveal(node, { select: false, expand: 2 });
}
);
registerCommand(context,
'dbuxTraceDetailsView.selectObject',
(node) => {
node.selectObject();
}
);
registerCommand(context,
'dbuxTraceDetailsView.valueRender',
(node) => {
node.valueRender();
}
);
for (let methodName of NavigationMethods) {
registerCommand(context,
`dbuxTraceDetailsView.navigation.${methodName}`,
(navigationNode) => {
navigationNode?.select(methodName);
}
);
}
registerCommand(context,
'dbuxTraceDetailsView.selectTraceAtCursor',
traceDetailsViewController.selectTraceAtCursor
);
registerCommand(context,
'dbuxTraceDetailsView.selectTraceAtCursor.empty',
() => showInformationMessage(translate('noTrace'))
);
registerCommand(context,
'dbuxTraceDetailsView.node.selectWriteTrace',
(node) => {
node.selectWriteTrace(); |
registerCommand(context,
'dbuxTraceDetailsView.node.selectValueCreation',
(node) => {
node.selectValueCreationTrace();
}
);
registerCommand(context,
'dbuxTraceDetailsView.node.selectForkParent',
(node) => {
node.selectForkParent();
}
);
registerCommand(context,
'dbuxTraceDetailsView.node.selectScheduler',
(node) => {
node.selectScheduler();
}
);
registerCommand(context,
'dbuxTraceDetailsView.context.showError',
() => traceDetailsViewController.showError()
);
registerCommand(context,
'dbuxTraceDetailsView.context.showError.disabled',
() => showInformationMessage('No error occurred.')
);
} | }
); |
gen_models.py | # flake8: noqa
import csv
def model_name(table_name):
if table_name in ["vtm", "vpi", "vmp", "vmpp", "amp", "ampp", "gtin"]:
return table_name.upper()
else:
return "".join(tok.title() for tok in table_name.split("_"))
def quote(s):
|
with open("schema.csv") as f:
lines = list(csv.DictReader(f))
print("from django.db import models")
table = None
for line in lines:
if line["table"] == "ccontent":
continue
if line["table"] != table:
table = line["table"]
print()
print()
print(f"class {model_name(table)}(models.Model):")
print("# class Meta:")
print('# verbose_name = "TODO"')
print()
if line["type"] == "retired":
continue
options = []
if line["primary_key"] == "True":
options.append(("primary_key", "True"))
if line["db_column"]:
options.append(("db_column", quote(line["db_column"])))
if line["type"] in ["ForeignKey", "OneToOneField"]:
options.append(("to", quote(model_name(line["to"]))))
options.append(("on_delete", "models.CASCADE"))
if "prevcd" in line["db_column"] or "uomcd" in line["db_column"]:
options.append(("related_name", quote("+")))
elif line["type"] == "CharField":
options.append(("max_length", line["max_length"]))
elif line["type"] == "DecimalField":
options.append(("max_digits", line["max_digits"]))
options.append(("decimal_places", line["decimal_places"]))
if line["optional"] == "Y":
if line["type"] != "BooleanField" and line["primary_key"] != "True":
options.append(("null", "True"))
options.append(("help_text", quote(line["descr"])))
print(f' {line["field"]} = models.{line["type"]}(')
for k, v in options:
print(f" {k}={v},")
print(" )")
| assert '"' not in s
return '"' + s + '"' |
idp_interface.py | import json
import logging
import random
import requests
from hashlib import sha1 as sha_constructor
from django.conf import settings
from gluu_ecommerce.connectors.uma_access import obtain_authorized_rpt_token
logger = logging.getLogger('idp')
SCIM_CREATE_USER_ENDPOINT = 'https://idp.gluu.org/identity/seam/resource/restv1/scim/v2/Users/'
SCIM_UPDATE_USER_ENDPOINT = 'https://idp.gluu.org/identity/seam/resource/restv1/scim/v2/Users/{}/'
def create_user(user, password, active=False):
headers = {'Content-Type': 'application/json'}
params = {}
payload = {
'schemas': ['urn:ietf:params:scim:schemas:core:2.0:User'],
'userName': sha_constructor(str(random.random())).hexdigest()[:12],
'name': {'givenName': user.first_name, 'familyName': user.last_name},
'displayName': u'{}{}'.format(user.first_name, user.last_name),
'password': password,
'emails': [
{'value': user.email, 'primary': True, 'type': 'Work'}
],
'phoneNumbers': [
{'value': user.phone_number, 'primary': True, 'type': 'Work'}
],
}
if active:
payload['active'] = True
url = SCIM_CREATE_USER_ENDPOINT
if settings.SCIM_TEST_MODE:
params['access_token'] = settings.SCIM_TEST_MODE_ACCESS_TOKEN
else:
rpt = obtain_authorized_rpt_token(resource_uri=url)
headers['Authorization'] = 'Bearer {}'.format(rpt)
response = requests.post(
url,
data=json.dumps(payload),
verify=settings.VERIFY_SSL,
headers=headers,
params=params
)
if response.status_code != 201:
message = 'Error writing to idp: {} {}'.format(response.status_code, response.text)
logger.error(message)
raise Exception(message)
else:
response = response.json()
return response['id']
| headers = {'Content-Type': 'application/json'}
params = {}
url = SCIM_UPDATE_USER_ENDPOINT.format(user.idp_uuid)
if settings.SCIM_TEST_MODE:
params['access_token'] = settings.SCIM_TEST_MODE_ACCESS_TOKEN
else:
rpt = obtain_authorized_rpt_token(resource_uri=url)
headers['Authorization'] = 'Bearer {}'.format(rpt)
payload = {'active': True}
response = requests.put(
url,
data=json.dumps(payload),
verify=settings.VERIFY_SSL,
headers=headers,
params=params
)
if response.status_code != 200:
message = 'Error writing to idp: {} {}'.format(response.status_code, response.text)
logger.error(message)
raise Exception(message)
def update_user(user):
headers = {'Content-Type': 'application/json'}
params = {}
if not user.idp_uuid:
logger.error('Error writing to idp, missing uid: {}'.format(user.email))
return
url = SCIM_UPDATE_USER_ENDPOINT.format(user.idp_uuid)
if settings.SCIM_TEST_MODE:
params['access_token'] = settings.SCIM_TEST_MODE_ACCESS_TOKEN
else:
rpt = obtain_authorized_rpt_token(resource_uri=url)
headers['Authorization'] = 'Bearer {}'.format(rpt)
payload = {
'name': {'givenName': user.first_name, 'familyName': user.last_name},
'displayName': u'{}{}'.format(user.first_name, user.last_name),
'phoneNumbers': [
{'value': user.mobile_number, 'primary': True, 'type': 'Work'}
],
'timezone': user.timezone,
'title': user.job_title
}
response = requests.put(
url,
data=json.dumps(payload),
verify=settings.VERIFY_SSL,
headers=headers,
params=params
)
if response.status_code != 200:
message = 'Error writing to idp: {} {}'.format(response.status_code, response.text)
logger.error(message)
raise Exception(message)
else:
logger.info('Successfully updated {}'.format(user.email))
def get_user(user):
if not user.idp_uuid:
logger.error('Error writing to idp, missing uid: {}'.format(user.email))
return
headers = {'Content-Type': 'application/json'}
params = {}
url = SCIM_UPDATE_USER_ENDPOINT.format(user.idp_uuid)
if settings.SCIM_TEST_MODE:
params['access_token'] = settings.SCIM_TEST_MODE_ACCESS_TOKEN
else:
rpt = obtain_authorized_rpt_token(resource_uri=url)
headers['Authorization'] = 'Bearer {}'.format(rpt)
response = requests.get(url, verify=settings.VERIFY_SSL, headers=headers)
if response.status_code != 200:
message = 'Error retrieving idp: {} {}'.format(response.status_code, response.text)
logger.error(message)
raise Exception(message)
else:
return response.json()
def email_exists(email):
headers = {'Content-Type': 'application/json'}
url = SCIM_CREATE_USER_ENDPOINT
params = {'filter': 'emails.value eq "{}"'.format(email)}
if settings.SCIM_TEST_MODE:
params['access_token'] = settings.SCIM_TEST_MODE_ACCESS_TOKEN
else:
rpt = obtain_authorized_rpt_token(resource_uri=url)
headers['Authorization'] = 'Bearer {}'.format(rpt)
response = requests.get(url, verify=settings.VERIFY_SSL, headers=headers, params=params)
if response.status_code != 200:
message = 'Error retrieving from idp: {} {}'.format(response.status_code, response.text)
logger.error(message)
raise Exception(message)
else:
no_records = int(response.json()['totalResults'])
if no_records not in [0, 1]:
message = 'Unexpected number of records found for {}'.email
logger.error(message)
raise Exception(message)
return no_records == 1 |
def activate_user(user):
|
models.py | import base64
from django.db import models
from django.contrib.auth.models import User
from django.utils.text import slugify
import string
import random
| DEFAULT_ENVIRONMENT_ID = 1
class Flavor(models.Model):
name = models.CharField(max_length=512)
slug = models.CharField(max_length=512)
cpu = models.TextField(blank=True, null=True)
mem = models.TextField(blank=True, null=True)
gpu = models.TextField(blank=True, null=True)
updated_at = models.DateTimeField(auto_now=True)
created_at = models.DateTimeField(auto_now_add=True)
def __str__(self):
return str(self.name)
class Environment(models.Model):
name = models.CharField(max_length=512)
slug = models.CharField(max_length=512, blank=True, null=True)
image = models.CharField(max_length=512)
dockerfile = models.TextField(default='FROM jupyter/base-notebook')
startup = models.TextField(null=True, blank=True)
teardown = models.TextField(null=True, blank=True)
updated_at = models.DateTimeField(auto_now=True)
created_at = models.DateTimeField(auto_now_add=True)
def __str__(self):
return str(self.name)
class ProjectManager(models.Manager):
def generate_passkey(self, length=20):
import secrets
import string
alphabet = string.ascii_letters + string.digits
password = ''.join(secrets.choice(alphabet) for _ in range(length))
# Encrypt the key
password = password.encode('ascii')
base64_bytes = base64.b64encode(password)
password = base64_bytes.decode('ascii')
return password
def create_project(self, name, owner, description, repository):
letters = string.ascii_lowercase
slug = name.replace(" ","-").replace("_","-")
from .helpers import urlify
slug = urlify(slug)
slug_extension = ''.join(random.choice(letters) for i in range(3))
slug = '{}-{}'.format(slugify(slug), slug_extension)
key = self.generate_passkey()
secret = self.generate_passkey(40)
project = self.create(name=name, owner=owner, slug=slug, project_key=key, project_secret=secret,
description=description, repository=repository,
repository_imported=False)
return project
class Project(models.Model):
objects = ProjectManager()
name = models.CharField(max_length=512, unique=True)
description = models.TextField(null=True, blank=True)
slug = models.CharField(max_length=512, unique=True)
owner = models.ForeignKey(User, on_delete=models.DO_NOTHING, related_name='owner')
authorized = models.ManyToManyField(User, blank=True)
image = models.CharField(max_length=2048, blank=True, null=True)
project_key = models.CharField(max_length=512)
project_secret = models.CharField(max_length=512)
updated_at = models.DateTimeField(auto_now=True)
created_at = models.DateTimeField(auto_now_add=True)
repository = models.CharField(max_length=512, null=True, blank=True)
repository_imported = models.BooleanField(default=False)
def __str__(self):
return "Name: {} Description: {}".format(self.name, self.description)
environment = models.ForeignKey('projects.Environment', on_delete=models.DO_NOTHING, default=DEFAULT_ENVIRONMENT_ID)
clone_url = models.CharField(max_length=512, null=True, blank=True) | |
ptr.rs | // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Conveniences for working with unsafe pointers, the `*T`, and `*mut T` types.
//!
//! Working with unsafe pointers in Rust is fairly uncommon,
//! and often limited to some narrow use cases: holding
//! an unsafe pointer when safe pointers are unsuitable;
//! checking for null; and converting back to safe pointers.
//! As a result, there is not yet an abundance of library code
//! for working with unsafe pointers, and in particular,
//! since pointer math is fairly uncommon in Rust, it is not
//! all that convenient.
//!
//! Use the [`null` function](fn.null.html) to create null pointers,
//! the [`is_null`](trait.RawPtr.html#tymethod.is_null)
//! and [`is_not_null`](trait.RawPtr.html#method.is_not_null)
//! methods of the [`RawPtr` trait](trait.RawPtr.html) to check for null.
//! The `RawPtr` trait is imported by the prelude, so `is_null` etc.
//! work everywhere.
//!
//! # Common ways to create unsafe pointers
//!
//! ## 1. Coerce a reference (`&T`) or mutable reference (`&mut T`).
//!
//! ```
//! let my_num: int = 10;
//! let my_num_ptr: *int = &my_num;
//! let mut my_speed: int = 88;
//! let my_speed_ptr: *mut int = &mut my_speed;
//! ```
//!
//! This does not take ownership of the original allocation
//! and requires no resource management later,
//! but you must not use the pointer after its lifetime.
//!
//! ## 2. Transmute an owned box (`~T`).
//!
//! The `transmute` function takes, by value, whatever it's given
//! and returns it as whatever type is requested, as long as the
//! types are the same size. Because `~T` and `*T` have the same
//! representation they can be trivially,
//! though unsafely, transformed from one type to the other.
//!
//! ```
//! use std::cast;
//!
//! unsafe {
//! let my_num: ~int = ~10;
//! let my_num: *int = cast::transmute(my_num);
//! let my_speed: ~int = ~88;
//! let my_speed: *mut int = cast::transmute(my_speed);
//!
//! // By taking ownership of the original `~T` though
//! // we are obligated to transmute it back later to be destroyed.
//! drop(cast::transmute::<_, ~int>(my_speed));
//! drop(cast::transmute::<_, ~int>(my_num));
//! }
//! ```
//!
//! Note that here the call to `drop` is for clarity - it indicates
//! that we are done with the given value and it should be destroyed.
//!
//! ## 3. Get it from C.
//!
//! ```
//! extern crate libc;
//!
//! use std::mem;
//!
//! fn main() {
//! unsafe {
//! let my_num: *mut int = libc::malloc(mem::size_of::<int>() as libc::size_t) as *mut int;
//! if my_num.is_null() {
//! fail!("failed to allocate memory");
//! }
//! libc::free(my_num as *mut libc::c_void);
//! }
//! }
//! ```
//!
//! Usually you wouldn't literally use `malloc` and `free` from Rust,
//! but C APIs hand out a lot of pointers generally, so are a common source
//! of unsafe pointers in Rust.
use cast;
use clone::Clone;
#[cfg(not(test))]
use cmp::Equiv;
use iter::{range, Iterator};
use mem;
use option::{Option, Some, None};
use intrinsics;
#[cfg(not(test))] use cmp::{Eq, TotalEq, Ord};
/// Return the offset of the first null pointer in `buf`.
#[inline]
pub unsafe fn buf_len<T>(buf: **T) -> uint {
position(buf, |i| *i == null())
}
impl<T> Clone for *T {
#[inline]
fn clone(&self) -> *T {
*self
}
}
impl<T> Clone for *mut T {
#[inline]
fn clone(&self) -> *mut T {
*self
}
}
/// Return the first offset `i` such that `f(buf[i]) == true`.
#[inline]
pub unsafe fn position<T>(buf: *T, f: |&T| -> bool) -> uint {
let mut i = 0;
loop {
if f(&(*buf.offset(i as int))) { return i; }
else { i += 1; }
}
}
/// Create an null pointer.
///
/// # Example
///
/// ```
/// use std::ptr;
///
/// let p: *int = ptr::null();
/// assert!(p.is_null());
/// ```
#[inline]
pub fn null<T>() -> *T { 0 as *T }
/// Create an unsafe mutable null pointer.
///
/// # Example
///
/// ```
/// use std::ptr;
///
/// let p: *mut int = ptr::mut_null();
/// assert!(p.is_null());
/// ```
#[inline]
pub fn mut_null<T>() -> *mut T { 0 as *mut T }
/// Copies data from one location to another.
///
/// Copies `count` elements (not bytes) from `src` to `dst`. The source
/// and destination may overlap.
///
/// `copy_memory` is semantically equivalent to C's `memmove`.
///
/// # Example
///
/// Efficiently create a Rust vector from an unsafe buffer:
///
/// ```
/// use std::ptr;
///
/// unsafe fn from_buf_raw<T>(ptr: *T, elts: uint) -> Vec<T> {
/// let mut dst = Vec::with_capacity(elts);
/// dst.set_len(elts);
/// ptr::copy_memory(dst.as_mut_ptr(), ptr, elts);
/// dst
/// }
/// ```
///
#[inline]
pub unsafe fn copy_memory<T>(dst: *mut T, src: *T, count: uint) {
intrinsics::copy_memory(dst, src, count)
}
/// Copies data from one location to another.
///
/// Copies `count` elements (not bytes) from `src` to `dst`. The source
/// and destination may *not* overlap.
///
/// `copy_nonoverlapping_memory` is semantically equivalent to C's `memcpy`.
///
/// # Example
///
/// A safe swap function:
///
/// ```
/// use std::cast;
/// use std::mem;
/// use std::ptr;
///
/// fn swap<T>(x: &mut T, y: &mut T) {
/// unsafe {
/// // Give ourselves some scratch space to work with
/// let mut t: T = mem::uninit();
///
/// // Perform the swap, `&mut` pointers never alias
/// ptr::copy_nonoverlapping_memory(&mut t, &*x, 1);
/// ptr::copy_nonoverlapping_memory(x, &*y, 1);
/// ptr::copy_nonoverlapping_memory(y, &t, 1);
///
/// // y and t now point to the same thing, but we need to completely forget `tmp`
/// // because it's no longer relevant.
/// cast::forget(t);
/// }
/// }
/// ```
///
/// # Safety Note
///
/// If the source and destination overlap then the behavior of this
/// function is undefined.
#[inline]
pub unsafe fn copy_nonoverlapping_memory<T>(dst: *mut T,
src: *T,
count: uint) {
intrinsics::copy_nonoverlapping_memory(dst, src, count)
}
/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
/// bytes of memory starting at `dst` to `c`.
#[inline]
pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
intrinsics::set_memory(dst, c, count)
}
/// Zeroes out `count * size_of::<T>` bytes of memory at `dst`
#[inline]
pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
set_memory(dst, 0, count);
}
/// Swap the values at two mutable locations of the same type, without
/// deinitialising either. They may overlap.
#[inline]
pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
// Give ourselves some scratch space to work with
let mut tmp: T = mem::uninit();
let t: *mut T = &mut tmp;
// Perform the swap
copy_nonoverlapping_memory(t, &*x, 1);
copy_memory(x, &*y, 1); // `x` and `y` may overlap
copy_nonoverlapping_memory(y, &*t, 1);
// y and t now point to the same thing, but we need to completely forget `tmp`
// because it's no longer relevant.
cast::forget(tmp);
}
/// Replace the value at a mutable location with a new one, returning the old
/// value, without deinitialising either.
#[inline]
pub unsafe fn replace<T>(dest: *mut T, mut src: T) -> T {
mem::swap(cast::transmute(dest), &mut src); // cannot overlap
src
}
/// Reads the value from `*src` and returns it.
#[inline(always)]
pub unsafe fn read<T>(src: *T) -> T {
let mut tmp: T = mem::uninit();
copy_nonoverlapping_memory(&mut tmp, src, 1);
tmp
}
/// Reads the value from `*src` and nulls it out.
/// This currently prevents destructors from executing.
#[inline(always)]
pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
// Copy the data out from `dest`:
let tmp = read(&*dest);
// Now zero out `dest`:
zero_memory(dest, 1);
tmp
}
/// Given a **T (pointer to an array of pointers),
/// iterate through each *T, up to the provided `len`,
/// passing to the provided callback function
pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: |*T|) {
if arr.is_null() {
fail!("ptr::array_each_with_len failure: arr input is null pointer");
}
//let start_ptr = *arr;
for e in range(0, len) {
let n = arr.offset(e as int);
cb(*n);
}
}
/// Given a null-pointer-terminated **T (pointer to
/// an array of pointers), iterate through each *T,
/// passing to the provided callback function
///
/// # Safety Note
///
/// This will only work with a null-terminated
/// pointer array.
pub unsafe fn array_each<T>(arr: **T, cb: |*T|) {
if arr.is_null() {
fail!("ptr::array_each_with_len failure: arr input is null pointer");
}
let len = buf_len(arr);
array_each_with_len(arr, len, cb);
}
/// Extension methods for raw pointers.
pub trait RawPtr<T> {
/// Returns the null pointer.
fn null() -> Self;
/// Returns true if the pointer is equal to the null pointer.
fn is_null(&self) -> bool;
/// Returns true if the pointer is not equal to the null pointer.
fn is_not_null(&self) -> bool { !self.is_null() }
/// Returns the value of this pointer (ie, the address it points to)
fn to_uint(&self) -> uint;
/// Returns `None` if the pointer is null, or else returns the value wrapped
/// in `Some`.
///
/// # Safety Notes
///
/// While this method is useful for null-safety, it is important to note
/// that this is still an unsafe operation because the returned value could
/// be pointing to invalid memory.
unsafe fn to_option(&self) -> Option<&T>;
/// Calculates the offset from a pointer. The offset *must* be in-bounds of
/// the object, or one-byte-past-the-end. `count` is in units of T; e.g. a
/// `count` of 3 represents a pointer offset of `3 * sizeof::<T>()` bytes.
unsafe fn offset(self, count: int) -> Self;
}
impl<T> RawPtr<T> for *T {
#[inline]
fn null() -> *T { null() }
#[inline]
fn is_null(&self) -> bool { *self == RawPtr::null() }
#[inline]
fn to_uint(&self) -> uint { *self as uint }
#[inline]
unsafe fn offset(self, count: int) -> *T { intrinsics::offset(self, count) }
#[inline]
unsafe fn to_option(&self) -> Option<&T> {
if self.is_null() {
None
} else {
Some(cast::transmute(*self))
}
}
}
impl<T> RawPtr<T> for *mut T {
#[inline]
fn null() -> *mut T { mut_null() }
#[inline]
fn is_null(&self) -> bool { *self == RawPtr::null() }
#[inline]
fn to_uint(&self) -> uint { *self as uint }
#[inline]
unsafe fn offset(self, count: int) -> *mut T { intrinsics::offset(self as *T, count) as *mut T }
#[inline]
unsafe fn to_option(&self) -> Option<&T> {
if self.is_null() {
None
} else {
Some(cast::transmute(*self))
}
}
}
// Equality for pointers
#[cfg(not(test))]
impl<T> Eq for *T {
#[inline]
fn eq(&self, other: &*T) -> bool {
*self == *other
}
#[inline]
fn ne(&self, other: &*T) -> bool { !self.eq(other) }
}
#[cfg(not(test))]
impl<T> TotalEq for *T {}
#[cfg(not(test))]
impl<T> Eq for *mut T {
#[inline]
fn eq(&self, other: &*mut T) -> bool {
*self == *other
}
#[inline]
fn ne(&self, other: &*mut T) -> bool { !self.eq(other) }
}
#[cfg(not(test))]
impl<T> TotalEq for *mut T {}
// Equivalence for pointers
#[cfg(not(test))]
impl<T> Equiv<*mut T> for *T {
fn equiv(&self, other: &*mut T) -> bool {
self.to_uint() == other.to_uint()
}
}
#[cfg(not(test))]
impl<T> Equiv<*T> for *mut T {
fn equiv(&self, other: &*T) -> bool {
self.to_uint() == other.to_uint()
}
}
// Equality for extern "C" fn pointers
#[cfg(not(test))]
mod externfnpointers {
use cast;
use cmp::Eq;
impl<_R> Eq for extern "C" fn() -> _R {
#[inline]
fn eq(&self, other: &extern "C" fn() -> _R) -> bool {
let self_: *() = unsafe { cast::transmute(*self) };
let other_: *() = unsafe { cast::transmute(*other) };
self_ == other_
}
#[inline]
fn ne(&self, other: &extern "C" fn() -> _R) -> bool {
!self.eq(other)
}
}
macro_rules! fnptreq(
($($p:ident),*) => {
impl<_R,$($p),*> Eq for extern "C" fn($($p),*) -> _R {
#[inline]
fn eq(&self, other: &extern "C" fn($($p),*) -> _R) -> bool {
let self_: *() = unsafe { cast::transmute(*self) };
let other_: *() = unsafe { cast::transmute(*other) };
self_ == other_
}
#[inline]
fn ne(&self, other: &extern "C" fn($($p),*) -> _R) -> bool {
!self.eq(other)
}
}
}
)
fnptreq!(A)
fnptreq!(A,B)
fnptreq!(A,B,C)
fnptreq!(A,B,C,D)
fnptreq!(A,B,C,D,E)
}
// Comparison for pointers
#[cfg(not(test))]
impl<T> Ord for *T {
#[inline]
fn lt(&self, other: &*T) -> bool {
*self < *other
}
#[inline]
fn le(&self, other: &*T) -> bool {
*self <= *other
}
#[inline]
fn ge(&self, other: &*T) -> bool {
*self >= *other
}
#[inline]
fn gt(&self, other: &*T) -> bool {
*self > *other
}
}
#[cfg(not(test))]
impl<T> Ord for *mut T {
#[inline]
fn lt(&self, other: &*mut T) -> bool {
*self < *other
}
#[inline]
fn le(&self, other: &*mut T) -> bool {
*self <= *other
}
#[inline]
fn ge(&self, other: &*mut T) -> bool {
*self >= *other
}
#[inline]
fn gt(&self, other: &*mut T) -> bool {
*self > *other
}
}
#[cfg(test)]
pub mod ptr_tests {
use super::*;
use prelude::*;
use c_str::ToCStr;
use cast;
use libc;
use str;
use slice::{ImmutableVector, MutableVector};
#[test]
fn | () {
unsafe {
struct Pair {
fst: int,
snd: int
};
let mut p = Pair {fst: 10, snd: 20};
let pptr: *mut Pair = &mut p;
let iptr: *mut int = cast::transmute(pptr);
assert_eq!(*iptr, 10);
*iptr = 30;
assert_eq!(*iptr, 30);
assert_eq!(p.fst, 30);
*pptr = Pair {fst: 50, snd: 60};
assert_eq!(*iptr, 50);
assert_eq!(p.fst, 50);
assert_eq!(p.snd, 60);
let v0 = ~[32000u16, 32001u16, 32002u16];
let mut v1 = ~[0u16, 0u16, 0u16];
copy_memory(v1.as_mut_ptr().offset(1),
v0.as_ptr().offset(1), 1);
assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
copy_memory(v1.as_mut_ptr(),
v0.as_ptr().offset(2), 1);
assert!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
v1[2] == 0u16));
copy_memory(v1.as_mut_ptr().offset(2),
v0.as_ptr(), 1u);
assert!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
v1[2] == 32000u16));
}
}
#[test]
fn test_position() {
use libc::c_char;
"hello".with_c_str(|p| {
unsafe {
assert!(2u == position(p, |c| *c == 'l' as c_char));
assert!(4u == position(p, |c| *c == 'o' as c_char));
assert!(5u == position(p, |c| *c == 0 as c_char));
}
})
}
#[test]
fn test_buf_len() {
"hello".with_c_str(|p0| {
"there".with_c_str(|p1| {
"thing".with_c_str(|p2| {
let v = ~[p0, p1, p2, null()];
unsafe {
assert_eq!(buf_len(v.as_ptr()), 3u);
}
})
})
})
}
#[test]
fn test_is_null() {
let p: *int = null();
assert!(p.is_null());
assert!(!p.is_not_null());
let q = unsafe { p.offset(1) };
assert!(!q.is_null());
assert!(q.is_not_null());
let mp: *mut int = mut_null();
assert!(mp.is_null());
assert!(!mp.is_not_null());
let mq = unsafe { mp.offset(1) };
assert!(!mq.is_null());
assert!(mq.is_not_null());
}
#[test]
fn test_to_option() {
unsafe {
let p: *int = null();
assert_eq!(p.to_option(), None);
let q: *int = &2;
assert_eq!(q.to_option().unwrap(), &2);
let p: *mut int = mut_null();
assert_eq!(p.to_option(), None);
let q: *mut int = &mut 2;
assert_eq!(q.to_option().unwrap(), &2);
}
}
#[test]
fn test_ptr_addition() {
unsafe {
let xs = ~[5, ..16];
let mut ptr = xs.as_ptr();
let end = ptr.offset(16);
while ptr < end {
assert_eq!(*ptr, 5);
ptr = ptr.offset(1);
}
let mut xs_mut = xs.clone();
let mut m_ptr = xs_mut.as_mut_ptr();
let m_end = m_ptr.offset(16);
while m_ptr < m_end {
*m_ptr += 5;
m_ptr = m_ptr.offset(1);
}
assert_eq!(xs_mut, ~[10, ..16]);
}
}
#[test]
fn test_ptr_subtraction() {
unsafe {
let xs = ~[0,1,2,3,4,5,6,7,8,9];
let mut idx = 9i8;
let ptr = xs.as_ptr();
while idx >= 0i8 {
assert_eq!(*(ptr.offset(idx as int)), idx as int);
idx = idx - 1i8;
}
let mut xs_mut = xs.clone();
let m_start = xs_mut.as_mut_ptr();
let mut m_ptr = m_start.offset(9);
while m_ptr >= m_start {
*m_ptr += *m_ptr;
m_ptr = m_ptr.offset(-1);
}
assert_eq!(xs_mut, ~[0,2,4,6,8,10,12,14,16,18]);
}
}
#[test]
fn test_ptr_array_each_with_len() {
unsafe {
let one = "oneOne".to_c_str();
let two = "twoTwo".to_c_str();
let three = "threeThree".to_c_str();
let arr = ~[
one.with_ref(|buf| buf),
two.with_ref(|buf| buf),
three.with_ref(|buf| buf),
];
let expected_arr = [
one, two, three
];
let mut ctr = 0;
let mut iteration_count = 0;
array_each_with_len(arr.as_ptr(), arr.len(), |e| {
let actual = str::raw::from_c_str(e);
let expected = expected_arr[ctr].with_ref(|buf| {
str::raw::from_c_str(buf)
});
debug!(
"test_ptr_array_each_with_len e: {}, a: {}",
expected, actual);
assert_eq!(actual, expected);
ctr += 1;
iteration_count += 1;
});
assert_eq!(iteration_count, 3u);
}
}
#[test]
fn test_ptr_array_each() {
unsafe {
let one = "oneOne".to_c_str();
let two = "twoTwo".to_c_str();
let three = "threeThree".to_c_str();
let arr = ~[
one.with_ref(|buf| buf),
two.with_ref(|buf| buf),
three.with_ref(|buf| buf),
// fake a null terminator
null(),
];
let expected_arr = [
one, two, three
];
let arr_ptr = arr.as_ptr();
let mut ctr = 0;
let mut iteration_count = 0;
array_each(arr_ptr, |e| {
let actual = str::raw::from_c_str(e);
let expected = expected_arr[ctr].with_ref(|buf| {
str::raw::from_c_str(buf)
});
debug!(
"test_ptr_array_each e: {}, a: {}",
expected, actual);
assert_eq!(actual, expected);
ctr += 1;
iteration_count += 1;
});
assert_eq!(iteration_count, 3);
}
}
#[test]
#[should_fail]
fn test_ptr_array_each_with_len_null_ptr() {
unsafe {
array_each_with_len(0 as **libc::c_char, 1, |e| {
str::raw::from_c_str(e);
});
}
}
#[test]
#[should_fail]
fn test_ptr_array_each_null_ptr() {
unsafe {
array_each(0 as **libc::c_char, |e| {
str::raw::from_c_str(e);
});
}
}
#[test]
fn test_set_memory() {
let mut xs = [0u8, ..20];
let ptr = xs.as_mut_ptr();
unsafe { set_memory(ptr, 5u8, xs.len()); }
assert!(xs == [5u8, ..20]);
}
}
| test |
game.rs | #![allow(dead_code)]
#![allow(unused_variables)]
#![allow(unused_assignments)]
use std::alloc::{alloc, Layout};
use std::mem::{align_of, size_of};
extern "C" {
fn mylog(v: isize);
}
pub struct Game {
wid: isize,
hei: isize,
income_reader: IOHelper,
outgo_writer: IOHelper,
}
impl Game {
pub const fn new(wid: isize, hei: isize, io_buf_cap: usize) -> Self {
let income_reader = IOHelper::new(income_buf_ptr, income_cursor_w_ptr, io_buf_cap);
let outgo_writer = IOHelper::new(outgo_buf_ptr, outgo_cursor_w_ptr, io_buf_cap);
Self {
wid,
hei,
income_reader,
outgo_writer,
}
}
pub fn get_args_usize_ptr(&self) -> usize |
fn get_canvas_buf_ptr(&self) -> usize {
self.args_usize[0]
}
fn get_income_buf_ptr(&self) -> usize {
self.args_usize[1]
}
fn get_outgo_buf_ptr(&self) -> usize {
self.args_usize[2]
}
fn set_pixel_color(&self, x: isize, y: isize, r: u8, g: u8, b: u8, a: u8) {
let offset = ((x + y * self.wid) * 4) as usize;
let canvas_buf_ptr: usize = self.get_canvas_buf_ptr();
unsafe {
*((canvas_buf_ptr + offset + 0) as *mut u8) = r;
*((canvas_buf_ptr + offset + 1) as *mut u8) = g;
*((canvas_buf_ptr + offset + 2) as *mut u8) = b;
*((canvas_buf_ptr + offset + 3) as *mut u8) = a;
}
}
pub fn boot(&self) -> usize {
self.set_pixel_color(self.x, self.y, 255, 0, 0, 255);
0
}
pub fn ever(&mut self) -> usize {
self.income_reader.read();
self.recv();
// logic
self.send();
self.render();
0
}
pub fn halt(&self) -> usize {
0
}
pub fn send(&self) {}
pub fn recv(&self) {}
pub fn render(&mut self) {
// let bytes = include_bytes!("../art/fire.rgba");
// for x in 0..96_usize {
// for y in 0..128_usize {
// self.set_pixel_color(
// x as isize,
// y as isize,
// bytes[(x + y * 96) * 4 + 0],
// bytes[(x + y * 96) * 4 + 1],
// bytes[(x + y * 96) * 4 + 2],
// bytes[(x + y * 96) * 4 + 3],
// );
// }
// }
}
}
| {
&(self.args_usize) as *const [usize; PTR_ARGS_COUNT] as *const u8 as usize
} |
test_invoices.py | import csv
import decimal
from datetime import date, datetime
from decimal import Decimal
import random
import json
from django.http import QueryDict
from pytest import mark
from django.core.urlresolvers import reverse
from django.conf import settings
from django.utils import timezone
from django_factory_boy import auth as auth_factories
from freezegun import freeze_time
import responses
from assopy.models import Invoice, Order, Vat
from tests.factories import AssopyUserFactory, FareFactory, OrderFactory
from conference.models import AttendeeProfile, Fare, Conference
from conference.invoicing import (
ACPYSS_16,
PYTHON_ITALIA_17,
EPS_18,
CSV_2018_REPORT_COLUMNS,
)
from conference.currencies import (
DAILY_ECB_URL,
EXAMPLE_ECB_DAILY_XML,
EXAMPLE_ECB_DATE,
fetch_and_store_latest_ecb_exrates,
)
from conference.fares import (
pre_create_typical_fares_for_conference,
)
from email_template.models import Email
from tests.common_tools import template_used, make_user
def _prepare_invoice_for_basic_test(order_code, invoice_code):
# default password is 'password123' per django_factory_boy
user = make_user()
# FYI(artcz): Order.objects.create is overloaded method on
# OrderManager, that sets up a lot of unused stuff, going with manual
# .save().
order = Order(user=user.assopy_user, code=order_code)
order.save()
# create some random Vat instance to the invoice creation works
vat_10 = Vat.objects.create(value=10)
return Invoice.objects.create(
code=invoice_code,
order=order,
emit_date=date.today(),
price=Decimal(1337),
vat=vat_10,
html="<html>Here goes full html</html>",
exchange_rate_date=date.today(),
)
@mark.django_db
def test_invoice_html(client):
# invoice_code must be validated via ASSOPY_IS_REAL_INVOICE
invoice_code, order_code = "I123", "asdf"
_prepare_invoice_for_basic_test(order_code, invoice_code)
client.login(email="[email protected]", password="password123")
invoice_url = reverse(
"assopy-invoice-html",
kwargs={"order_code": order_code, "code": invoice_code},
)
response = client.get(invoice_url)
assert (
response.content.decode("utf-8") == "<html>Here goes full html</html>"
)
@mark.django_db
def test_invoice_pdf(client):
# invoice_code must be validated via ASSOPY_IS_REAL_INVOICE
invoice_code, order_code = "I123", "asdf"
_prepare_invoice_for_basic_test(order_code, invoice_code)
client.login(email="[email protected]", password="password123")
invoice_url = reverse(
"assopy-invoice-pdf",
kwargs={"order_code": order_code, "code": invoice_code},
)
response = client.get(invoice_url)
assert response.status_code == 200
assert response["Content-type"] == "application/pdf"
def create_order_and_invoice(assopy_user, fare):
order = OrderFactory(user=assopy_user, items=[(fare, {"qty": 1})])
with responses.RequestsMock() as rsps:
# mocking responses for the invoice VAT exchange rate feature
rsps.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
fetch_and_store_latest_ecb_exrates()
order.confirm_order(timezone.now())
# confirm_order by default creates placeholders, but for most of the tests
# we can upgrade them to proper invoices anyway.
invoice = Invoice.objects.get(order=order)
return invoice
@mark.django_db
def test_if_invoice_stores_information_about_the_seller(client):
"""
Testing #591
https://github.com/EuroPython/epcon/issues/591
"""
Conference.objects.create(
code=settings.CONFERENCE_CONFERENCE, name=settings.CONFERENCE_NAME
)
# need this email to generate invoices/orders
Email.objects.create(code="purchase-complete")
fare = FareFactory()
user = make_user()
def invoice_url(invoice):
return reverse(
"assopy-invoice-html",
kwargs={"code": invoice.code, "order_code": invoice.order.code},
)
with freeze_time("2016-01-01"):
# We need to log in again after every time travel, just in case.
client.login(email="[email protected]", password="password123")
invoice = create_order_and_invoice(user.assopy_user, fare)
assert invoice.code == "I/16.0001"
assert invoice.emit_date == date(2016, 1, 1)
assert invoice.issuer == ACPYSS_16
assert invoice.html.startswith("<!DOCTYPE")
response = client.get(invoice_url(invoice))
assert ACPYSS_16 in response.content.decode("utf-8")
with freeze_time("2017-01-01"):
# We need to log in again after every time travel, just in case.
client.login(email="[email protected]", password="password123")
invoice = create_order_and_invoice(user.assopy_user, fare)
assert invoice.code == "I/17.0001"
assert invoice.emit_date == date(2017, 1, 1)
assert invoice.issuer == PYTHON_ITALIA_17
assert invoice.html.startswith("<!DOCTYPE")
response = client.get(invoice_url(invoice))
assert PYTHON_ITALIA_17 in response.content.decode("utf-8")
with freeze_time("2018-01-01"):
# We need to log in again after every time travel, just in case.
client.login(email="[email protected]", password="password123")
invoice = create_order_and_invoice(user.assopy_user, fare)
assert invoice.code == "I/18.0001"
assert invoice.emit_date == date(2018, 1, 1)
assert invoice.issuer == EPS_18
assert invoice.html.startswith("<!DOCTYPE")
response = client.get(invoice_url(invoice))
assert EPS_18 in response.content.decode("utf-8")
@mark.django_db
@responses.activate
def test_vat_in_GBP_for_2018(client):
"""
https://github.com/EuroPython/epcon/issues/617
"""
responses.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
Conference.objects.create(
code=settings.CONFERENCE_CONFERENCE, name=settings.CONFERENCE_NAME
)
Email.objects.create(code="purchase-complete")
fare = FareFactory()
user = make_user()
with freeze_time("2018-05-05"):
client.login(email="[email protected]", password="password123")
invoice = create_order_and_invoice(user.assopy_user, fare)
assert invoice.html.startswith("<!DOCTYPE")
assert invoice.vat_value() == Decimal("1.67")
assert invoice.vat_in_local_currency == Decimal("1.49")
assert invoice.local_currency == "GBP"
assert invoice.exchange_rate == Decimal("0.89165")
assert invoice.exchange_rate_date == EXAMPLE_ECB_DATE
response = client.get(invoice.get_html_url())
content = response.content.decode("utf-8")
# The wording used to be different, so we had both checks in one line,
# but beacuse of template change we had to separate them
assert 'local-currency="GBP"' in content
assert 'total-vat-in-local-currency="1.49"' in content
# we're going to use whatever the date was received/cached from ECB XML
# doesnt matter what emit date is
assert (
"ECB rate used for VAT is 0.89165 GBP/EUR from 2018-03-06"
in content
)
response = client.get(invoice.get_absolute_url())
assert response["Content-Type"] == "application/pdf"
with freeze_time("2017-05-05"):
client.login(email="[email protected]", password="password123")
invoice = create_order_and_invoice(user.assopy_user, fare)
assert invoice.html.startswith("<!DOCTYPE")
assert invoice.vat_value() == Decimal("1.67")
assert invoice.vat_in_local_currency == Decimal("1.67")
assert invoice.local_currency == "EUR"
assert invoice.exchange_rate == Decimal("1.0")
assert invoice.exchange_rate_date == date(2017, 5, 5)
response = client.get(invoice.get_html_url())
content = response.content.decode("utf-8")
# not showing any VAT conversion because in 2017 we had just EUR
assert "EUR" in content
assert "Total VAT is" not in content
assert "ECB rate" not in content
response = client.get(invoice.get_absolute_url())
assert response["Content-Type"] == "application/pdf"
@mark.django_db
@responses.activate
@freeze_time("2018-05-05")
def test_create_invoice_with_many_items(client):
"""
This test is meant to be used to test invoice template design.
It creates a lot of different items on the invoice, and after that we can
use serve(content) to easily check in the browser how the Invoice looks
like.
Freezing it at 2018 so we can easily check EP2018 invoices.
"""
responses.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
Email.objects.create(code="purchase-complete")
user = make_user()
vat_rate_20, _ = Vat.objects.get_or_create(value=20)
CONFERENCE = settings.CONFERENCE_CONFERENCE
pre_create_typical_fares_for_conference(CONFERENCE, vat_rate_20)
# Don't need to set dates for this test.
# set_early_bird_fare_dates(CONFERENCE, yesterday, tomorrow)
# set_regular_fare_dates(CONFERENCE, yesterday, tomorrow)
random_fares = random.sample(list(Fare.objects.all()), 3)
order = OrderFactory(
user=user.assopy_user,
items=[(fare, {"qty": i}) for i, fare in enumerate(random_fares, 1)],
)
with responses.RequestsMock() as rsps:
# mocking responses for the invoice VAT exchange rate feature
rsps.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
fetch_and_store_latest_ecb_exrates()
order.confirm_order(timezone.now())
@mark.django_db
@responses.activate
def test_export_invoice_csv(client):
Conference.objects.create(
code=settings.CONFERENCE_CONFERENCE, name=settings.CONFERENCE_NAME
)
responses.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
Email.objects.create(code="purchase-complete")
fare = FareFactory()
user = make_user(is_staff=True)
client.login(email=user.email, password="password123")
with freeze_time("2018-05-05"):
invoice1 = create_order_and_invoice(user.assopy_user, fare)
query_dict = QueryDict(mutable=True)
query_dict["start_date"] = date(2018, 1, 1)
query_dict["end_date"] = date.today()
query_string = query_dict.urlencode()
response = client.get(
reverse("debug_panel_invoice_export_for_tax_report_csv")
+ "?"
+ query_string
)
assert response.status_code == 200
assert response["content-type"] == "text/csv"
invoice_reader = csv.reader(response.content.decode("utf-8").splitlines())
next(invoice_reader) # skip header
invoice = next(invoice_reader)
iter_column = iter(invoice)
assert next(iter_column) == invoice1.code
assert next(iter_column) == "2018-05-05"
assert next(iter_column) == invoice1.order.user.user.get_full_name()
assert next(iter_column) == invoice1.order.card_name
next(iter_column) # ignore the address
assert next(iter_column) == invoice1.order.country.name
assert next(iter_column) == invoice1.order.vat_number
next(iter_column) # ignore the currency
assert (
decimal.Decimal(next(iter_column))
== invoice1.net_price_in_local_currency
)
assert decimal.Decimal(next(iter_column)) == invoice1.vat_in_local_currency
assert (
decimal.Decimal(next(iter_column)) == invoice1.price_in_local_currency
)
@mark.django_db
@responses.activate
def test_export_invoice_csv_before_period(client):
Conference.objects.create(
code=settings.CONFERENCE_CONFERENCE, name=settings.CONFERENCE_NAME
)
responses.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
Email.objects.create(code="purchase-complete")
fare = FareFactory()
user = make_user(is_staff=True)
client.login(email=user.email, password="password123")
with freeze_time("2018-04-05"):
create_order_and_invoice(user.assopy_user, fare)
query_dict = QueryDict(mutable=True)
query_dict["start_date"] = date(2018, 5, 1)
query_dict["end_date"] = date.today()
query_string = query_dict.urlencode()
response = client.get(
reverse("debug_panel_invoice_export_for_tax_report_csv")
+ "?"
+ query_string
)
assert response.status_code == 200
assert response["content-type"] == "text/csv"
invoice_reader = csv.reader(response.content.decode("utf-8").splitlines())
header = next(invoice_reader)
assert header == CSV_2018_REPORT_COLUMNS
assert next(invoice_reader, None) is None
@mark.django_db
@responses.activate
def test_export_invoice(client):
Conference.objects.create(
code=settings.CONFERENCE_CONFERENCE, name=settings.CONFERENCE_NAME
)
responses.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
Email.objects.create(code="purchase-complete")
fare = FareFactory()
user = make_user(is_staff=True)
client.login(email=user.email, password="password123")
with freeze_time("2018-05-05"):
invoice1 = create_order_and_invoice(user.assopy_user, fare)
query_dict = QueryDict(mutable=True)
query_dict["start_date"] = date(2018, 1, 1)
query_dict["end_date"] = date.today()
query_string = query_dict.urlencode()
response = client.get(
reverse("debug_panel_invoice_export_for_tax_report")
+ "?"
+ query_string
)
assert response.status_code == 200
assert response["content-type"].startswith("text/html")
assert '<tr id="invoice_{0}">'.format(
invoice1.id
) in response.content.decode("utf-8")
@mark.django_db
@responses.activate
def test_export_invoice_accounting_json(client):
Conference.objects.create(
code=settings.CONFERENCE_CONFERENCE, name=settings.CONFERENCE_NAME
)
responses.add(responses.GET, DAILY_ECB_URL, body=EXAMPLE_ECB_DAILY_XML)
Email.objects.create(code="purchase-complete")
fare = FareFactory()
user = make_user(is_staff=True)
client.login(email=user.email, password="password123")
with freeze_time("2018-05-05"):
invoice1 = create_order_and_invoice(user.assopy_user, fare)
query_dict = QueryDict(mutable=True)
query_dict["start_date"] = date(2018, 1, 1)
query_dict["end_date"] = date.today()
query_string = query_dict.urlencode()
response = client.get(
reverse("debug_panel_invoice_export_for_payment_reconciliation_json")
+ "?"
+ query_string
)
assert response.status_code == 200
assert response["content-type"].startswith("application/json")
data = json.loads(response.content)["invoices"]
assert len(data) == 1
assert data[0]["ID"] == invoice1.code
assert decimal.Decimal(data[0]["net"]) == invoice1.net_price()
assert decimal.Decimal(data[0]["vat"]) == invoice1.vat_value()
assert decimal.Decimal(data[0]["gross"]) == invoice1.price
assert data[0]["order"] == invoice1.order.code
assert data[0]["stripe"] == invoice1.order.stripe_charge_id
def test_reissue_invoice(admin_client):
| Conference.objects.create(
code=settings.CONFERENCE_CONFERENCE, name=settings.CONFERENCE_NAME
)
invoice_code, order_code = "I123", "asdf"
invoice = _prepare_invoice_for_basic_test(order_code, invoice_code)
NEW_CUSTOMER = "NEW CUSTOMER"
assert Invoice.objects.all().count() == 1
assert NEW_CUSTOMER not in Invoice.objects.latest("id").html
url = reverse("debug_panel_reissue_invoice", args=[invoice.id])
response = admin_client.get(url)
assert response.status_code == 200
response = admin_client.post(
url, {"emit_date": "2018-01-01", "customer": NEW_CUSTOMER}
)
assert response.status_code == 302
assert Invoice.objects.all().count() == 2
assert NEW_CUSTOMER in Invoice.objects.latest("id").html |
|
FlorenceExceptions.py | class JacobianError(ArithmeticError):
def __init__(self,value=None):
self.value = value
def __str__(self):
if self.value is None:
self.value = 'Jacobian of mapping is close to zero'
return repr(self.value)
class IllConditionedError(ArithmeticError):
def __init__(self,value=None):
self.value = value
def __str__(self):
if self.value is None: | self.value = 'Matrix is ill conditioned'
return repr(self.value) | |
lib.rs | // Copyright 2020-2021, The Tremor Team
//
//
// 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.
//! Influx line protocol decoder to `simd_json::Value`
//!
//! The translate is done to the following schema:
//!
//! ```json
//! {
//! "measurement": "<name>",
//! "tags": {
//! "tag1": "<value>"
//! },
//! "fields": {
//! "field1": 123
//! },
//! "timestamp": 456
//! }
//! ```
#![deny(missing_docs)]
#![recursion_limit = "1024"]
#![deny(
clippy::all,
clippy::unwrap_used,
clippy::unnecessary_unwrap,
clippy::pedantic
)]
mod decoder;
mod encoder;
/// Errors
pub mod errors;
pub use decoder::decode;
pub use encoder::encode;
pub use errors::*;
#[cfg(test)]
mod tests {
use super::*;
use pretty_assertions::assert_eq;
use simd_json::{json, BorrowedValue};
#[test]
fn unparse_test() {
let s = "weather,location=us-midwest temperature=82 1465839830100400200";
let d = decode(s, 0)
.expect("failed to parse")
.expect("failed to parse");
// This is a bit ugly but to make a sensible comparison we got to convert the data
// from an object to json to an object
let j: BorrowedValue = d;
let e: BorrowedValue = json!({
"measurement": "weather",
"tags": {"location": "us-midwest"},
"fields": {"temperature": 82.0},
"timestamp": 1_465_839_830_100_400_200_i64
})
.into();
assert_eq!(e, j)
}
#[test]
fn unparse_empty() {
let s = "";
let d: Option<BorrowedValue> = decode(s, 0).expect("failed to parse");
assert!(d.is_none());
let s = " ";
let d: Option<BorrowedValue> = decode(s, 0).expect("failed to parse");
assert!(d.is_none());
let s = " \n";
let d: Option<BorrowedValue> = decode(s, 0).expect("failed to parse");
assert!(d.is_none());
let s = " \t \n";
let d: Option<BorrowedValue> = decode(s, 0).expect("failed to parse");
assert!(d.is_none());
}
#[test]
fn unparse_comment() {
let s = "# bla";
let d: Option<BorrowedValue> = decode(s, 0).expect("failed to parse");
assert!(d.is_none());
let s = " # bla";
let d: Option<BorrowedValue> = decode(s, 0).expect("failed to parse");
assert!(d.is_none());
let s = " \t \n# bla";
let d: Option<BorrowedValue> = decode(s, 0).expect("failed to parse");
assert!(d.is_none());
}
#[test]
fn parse_simple() {
let s = "weather,location=us-midwest temperature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_simple2() {
let s = "weather,location=us-midwest,season=summer temperature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest",
"season": "summer"
},
"fields": {
"temperature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_example() {
let mut s = br#"{"measurement":"swap","tags":{"host":"56a6f1b85709","window":"10secs"},"fields":{"count_free":2,"min_free":2139095040,"max_free":2147483647,"mean_free":2143289344.0,"stdev_free":0.0,"var_free":0.0,"p50_free":2147483647,"p90_free":2147483647,"p99_free":2147483647,"p99.9_free":2147483647},"timestamp":1465839830100400200}"#.to_vec();
let v = simd_json::borrowed::to_value(s.as_mut_slice()).unwrap();
encode(&v).unwrap();
}
#[test]
fn parse_simple3() {
let s =
"weather,location=us-midwest temperature=82,bug_concentration=98 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature": 82.0,
"bug_concentration": 98.0,
},
"timestamp": 1_465_839_830_100_400_200u64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_no_timestamp() {
let s = "weather temperature=82i";
let parsed = decode(s, 1_465_839_830_100_400_200u64).expect("failed to parse");
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {},
"fields": {
"temperature": 82
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Some(r), parsed);
}
#[test]
fn parse_float_value() {
let s = "weather temperature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {},
"fields": {
"temperature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_int_value() {
let s = "weather temperature=82i 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {},
"fields": {
"temperature": 82
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_str_value() {
let s = "weather,location=us-midwest temperature=\"too warm\" 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature": "too warm"
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_true_value() {
let sarr = &[
"weather,location=us-midwest too_hot=true 1465839830100400200",
"weather,location=us-midwest too_hot=True 1465839830100400200",
"weather,location=us-midwest too_hot=TRUE 1465839830100400200",
"weather,location=us-midwest too_hot=t 1465839830100400200",
"weather,location=us-midwest too_hot=T 1465839830100400200",
];
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"too_hot": true
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
for s in sarr {
assert_eq!(Ok(Some(r.clone())), decode(s, 0));
}
}
#[test]
fn parse_false_value() {
let sarr = &[
"weather,location=us-midwest too_hot=false 1465839830100400200",
"weather,location=us-midwest too_hot=False 1465839830100400200",
"weather,location=us-midwest too_hot=FALSE 1465839830100400200",
"weather,location=us-midwest too_hot=f 1465839830100400200",
"weather,location=us-midwest too_hot=F 1465839830100400200",
];
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"too_hot": false
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
for s in sarr {
assert_eq!(Ok(Some(r.clone())), decode(s, 0));
}
}
#[test]
fn parse_escape01() {
let s = "weather,location=us\\,midwest temperature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us,midwest"
},
"fields": {
"temperature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape02() {
let s = "weather,location=us-midwest temp\\=rature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temp=rature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape03() {
let s = "weather,location\\ place=us-midwest temperature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location place": "us-midwest"
},
"fields": {
"temperature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape04() {
let s = "wea\\,ther,location=us-midwest temperature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "wea,ther",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape05() {
let s = "wea\\ ther,location=us-midwest temperature=82 1465839830100400200";
let r: BorrowedValue = json!({
"measurement": "wea ther",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature": 82.0
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape06() {
let s = r#"weather,location=us-midwest temperature="too\"hot\"" 1465839830100400200"#;
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature": r#"too"hot""#
},
"timestamp": 1_465_839_830_100_400_200i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn | () {
let s = "weather,location=us-midwest temperature_str=\"too hot/cold\" 1465839830100400201";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature_str": "too hot/cold"
},
"timestamp": 1_465_839_830_100_400_201i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0));
}
#[test]
fn parse_escape08() {
let s = "weather,location=us-midwest temperature_str=\"too hot\\cold\" 1465839830100400202";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature_str": "too hot\\cold"
},
"timestamp": 1_465_839_830_100_400_202i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape09() {
let s =
"weather,location=us-midwest temperature_str=\"too hot\\\\cold\" 1465839830100400203";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature_str": "too hot\\cold"
},
"timestamp": 1_465_839_830_100_400_203i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape10() {
let s =
"weather,location=us-midwest temperature_str=\"too hot\\\\\\cold\" 1465839830100400204";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature_str": "too hot\\\\cold"
},
"timestamp": 1_465_839_830_100_400_204i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape11() {
let s = "weather,location=us-midwest temperature_str=\"too hot\\\\\\\\cold\" 1465839830100400205";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature_str": "too hot\\\\cold"
},
"timestamp": 1_465_839_830_100_400_205i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
#[test]
fn parse_escape12() {
let s = "weather,location=us-midwest temperature_str=\"too hot\\\\\\\\\\cold\" 1465839830100400206";
let r: BorrowedValue = json!({
"measurement": "weather",
"tags": {
"location": "us-midwest"
},
"fields": {
"temperature_str": "too hot\\\\\\cold"
},
"timestamp": 1_465_839_830_100_400_206i64,
})
.into();
assert_eq!(Ok(Some(r)), decode(s, 0))
}
}
| parse_escape07 |
encoder.py | from generative_playground.models.encoder.basic_cnn import SimpleCNNEncoder
from generative_playground.models.encoder.basic_rnn import SimpleRNN
from generative_playground.models.heads.attention_aggregating_head import AttentionAggregatingHead
from generative_playground.models.transformer.Models import TransformerEncoder
from generative_playground.utils.gpu_utils import to_gpu
def get_encoder(feature_len=12,
max_seq_length=15,
cnn_encoder_params={'kernel_sizes': (2, 3, 4),
'filters': (2, 3, 4),
'dense_size': 100},
drop_rate=0.0,
encoder_type='cnn',
rnn_encoder_hidden_n=200):
if encoder_type == 'rnn':
rnn_model = SimpleRNN(hidden_n=rnn_encoder_hidden_n, |
elif encoder_type == 'cnn':
encoder = to_gpu(SimpleCNNEncoder(params=cnn_encoder_params,
max_seq_length=max_seq_length,
feature_len=feature_len,
drop_rate=drop_rate))
elif encoder_type == 'attention':
encoder = to_gpu(AttentionAggregatingHead(TransformerEncoder(feature_len,
max_seq_length,
dropout=drop_rate,
padding_idx=feature_len - 1),
drop_rate=drop_rate))
else:
raise NotImplementedError()
return encoder | feature_len=feature_len,
drop_rate=drop_rate)
encoder = to_gpu(AttentionAggregatingHead(rnn_model, drop_rate=drop_rate)) |
server.py |
# Restfull api using falcon framework
from wsgiref import simple_server
import falcon
import json
#Resource endpoints import
from cartsResource import *
from productsResource import *
# Check that client has application/json in Accept header
# and Content-Type, if request has body
class RequireJSON(object):
def process_request(self, req, resp):
if not req.client_accepts_json:
raise falcon.HTTPNotAcceptable(
'This API only supports responses encoded as JSON.',
href='http://docs.examples.com/api/json')
if req.method in ('POST', 'PUT'):
|
#JSON builder func for both incoming and outgoing messages
class JSONBuilder(object):
def process_request(self, req, resp):
if req.content_length in (None, 0):
# Nothing to do
return
body = req.stream.read()
if not body:
raise falcon.HTTPBadRequest('Empty request body',
'A valid JSON document is required.')
try:
req.context['doc'] = json.loads(body.decode('utf-8'))
except (ValueError, UnicodeDecodeError):
raise falcon.HTTPError(falcon.HTTP_753,
'Malformed JSON',
'Could not decode the request body. The '
'JSON was incorrect or not encoded as '
'UTF-8.')
def process_response(self, req, resp, resource):
if 'result' not in req.context:
return
resp.body = json.dumps(req.context['result'])
api = falcon.API(middleware=[
RequireJSON(),
JSONBuilder()
])
#Add api endpoints
products = ProductsResource()
api.add_route('/api/products', products)
product = ProductResource()
api.add_route('/api/products/{productId}', product)
shopcart = ShopCartResource()
api.add_route('/api/shopcarts/{userId}', shopcart)
shopcartProducts = ShopCartProductsResource()
api.add_route('/api/shopcarts/{userId}/products', shopcartProducts)
#Start the server
if __name__ == '__main__':
print("Staring server in 127.0.0.1:8000")
httpd = simple_server.make_server('127.0.0.1', 8000, api)
httpd.serve_forever()
| if 'application/json' not in req.content_type:
raise falcon.HTTPUnsupportedMediaType(
'This API only supports requests encoded as JSON.',
href='http://docs.examples.com/api/json') |
job-overview-drawer-flamegraph.component.ts | /*
* 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.
*/
import { Component, OnInit, ChangeDetectionStrategy, OnDestroy, ChangeDetectorRef } from '@angular/core';
import { Subject } from 'rxjs';
import { flatMap, takeUntil, tap } from 'rxjs/operators';
import { JobFlameGraphInterface, NodesItemCorrectInterface } from 'interfaces';
import { JobService } from 'services';
@Component({
selector: 'flink-job-overview-drawer-flamegraph',
templateUrl: './job-overview-drawer-flamegraph.component.html',
changeDetection: ChangeDetectionStrategy.OnPush,
styleUrls: ['./job-overview-drawer-flamegraph.component.less']
})
export class | implements OnInit, OnDestroy {
destroy$ = new Subject();
isLoading = true;
now = Date.now();
selectedVertex: NodesItemCorrectInterface | null;
flameGraph = {} as JobFlameGraphInterface;
graphType = 'on_cpu';
constructor(private jobService: JobService, private cdr: ChangeDetectorRef) {}
ngOnInit() {
this.requestFlameGraph();
}
private requestFlameGraph() {
this.jobService.jobWithVertex$
.pipe(
takeUntil(this.destroy$),
tap(data => (this.selectedVertex = data.vertex)),
flatMap(data => this.jobService.loadOperatorFlameGraph(data.job.jid, data.vertex!.id, this.graphType))
)
.subscribe(
data => {
this.now = Date.now();
if (this.flameGraph.endTimestamp !== data['endTimestamp']) {
this.isLoading = false;
this.flameGraph = data;
this.flameGraph.graphType = this.graphType;
}
this.cdr.markForCheck();
},
() => {
this.isLoading = false;
this.cdr.markForCheck();
}
);
}
selectFrameGraphType() {
this.destroy$.next();
this.destroy$.complete();
this.destroy$ = new Subject();
this.flameGraph = {} as JobFlameGraphInterface;
this.requestFlameGraph();
}
ngOnDestroy() {
this.destroy$.next();
this.destroy$.complete();
}
}
| JobOverviewDrawerFlameGraphComponent |
proc_macro_harness.rs | use std::mem;
use rustc_ast::attr;
use rustc_ast::ptr::P;
use rustc_ast::visit::{self, Visitor};
use rustc_ast::{self as ast, NodeId};
use rustc_ast_pretty::pprust;
use rustc_expand::base::{parse_macro_name_and_helper_attrs, ExtCtxt, ResolverExpand};
use rustc_expand::expand::{AstFragment, ExpansionConfig};
use rustc_session::Session;
use rustc_span::hygiene::AstPass;
use rustc_span::source_map::SourceMap;
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};
use smallvec::smallvec;
use std::cell::RefCell;
struct ProcMacroDerive {
id: NodeId,
trait_name: Symbol,
function_name: Ident,
span: Span,
attrs: Vec<Symbol>,
}
enum ProcMacroDefType {
Attr,
Bang,
}
struct ProcMacroDef {
id: NodeId,
function_name: Ident,
span: Span,
def_type: ProcMacroDefType,
}
enum ProcMacro {
Derive(ProcMacroDerive),
Def(ProcMacroDef),
}
struct CollectProcMacros<'a> {
sess: &'a Session,
macros: Vec<ProcMacro>,
in_root: bool,
handler: &'a rustc_errors::Handler,
source_map: &'a SourceMap,
is_proc_macro_crate: bool,
is_test_crate: bool,
}
pub fn inject(
sess: &Session,
resolver: &mut dyn ResolverExpand,
mut krate: ast::Crate,
is_proc_macro_crate: bool,
has_proc_macro_decls: bool,
is_test_crate: bool,
num_crate_types: usize,
handler: &rustc_errors::Handler,
) -> ast::Crate {
let ecfg = ExpansionConfig::default("proc_macro".to_string());
let mut cx = ExtCtxt::new(sess, ecfg, resolver, None);
let mut collect = CollectProcMacros {
sess,
macros: Vec::new(),
in_root: true,
handler,
source_map: sess.source_map(),
is_proc_macro_crate,
is_test_crate,
};
if has_proc_macro_decls || is_proc_macro_crate {
visit::walk_crate(&mut collect, &krate);
}
let macros = collect.macros;
if !is_proc_macro_crate {
return krate;
}
if num_crate_types > 1 {
handler.err("cannot mix `proc-macro` crate type with others");
}
if is_test_crate {
return krate;
}
let decls = mk_decls(&mut krate, &mut cx, ¯os);
krate.items.push(decls);
krate
}
impl<'a> CollectProcMacros<'a> {
fn check_not_pub_in_root(&self, vis: &ast::Visibility, sp: Span) {
if self.is_proc_macro_crate && self.in_root && vis.kind.is_pub() {
self.handler.span_err(
sp,
"`proc-macro` crate types currently cannot export any items other \
than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, \
or `#[proc_macro_attribute]`",
);
}
}
fn collect_custom_derive(&mut self, item: &'a ast::Item, attr: &'a ast::Attribute) {
let (trait_name, proc_attrs) =
match parse_macro_name_and_helper_attrs(self.handler, attr, "derive") {
Some(name_and_attrs) => name_and_attrs,
None => return,
};
if self.in_root && item.vis.kind.is_pub() {
self.macros.push(ProcMacro::Derive(ProcMacroDerive {
id: item.id,
span: item.span,
trait_name,
function_name: item.ident,
attrs: proc_attrs,
}));
} else {
let msg = if !self.in_root {
"functions tagged with `#[proc_macro_derive]` must \
currently reside in the root of the crate"
} else {
"functions tagged with `#[proc_macro_derive]` must be `pub`"
};
self.handler.span_err(self.source_map.guess_head_span(item.span), msg);
}
}
fn collect_attr_proc_macro(&mut self, item: &'a ast::Item) {
if self.in_root && item.vis.kind.is_pub() {
self.macros.push(ProcMacro::Def(ProcMacroDef {
id: item.id,
span: item.span,
function_name: item.ident,
def_type: ProcMacroDefType::Attr,
}));
} else {
let msg = if !self.in_root {
"functions tagged with `#[proc_macro_attribute]` must \
currently reside in the root of the crate"
} else {
"functions tagged with `#[proc_macro_attribute]` must be `pub`"
};
self.handler.span_err(self.source_map.guess_head_span(item.span), msg);
}
}
fn collect_bang_proc_macro(&mut self, item: &'a ast::Item) {
if self.in_root && item.vis.kind.is_pub() {
self.macros.push(ProcMacro::Def(ProcMacroDef {
id: item.id,
span: item.span,
function_name: item.ident,
def_type: ProcMacroDefType::Bang,
}));
} else {
let msg = if !self.in_root {
"functions tagged with `#[proc_macro]` must \
currently reside in the root of the crate"
} else {
"functions tagged with `#[proc_macro]` must be `pub`"
};
self.handler.span_err(self.source_map.guess_head_span(item.span), msg);
}
}
}
impl<'a> Visitor<'a> for CollectProcMacros<'a> {
fn visit_item(&mut self, item: &'a ast::Item) {
if let ast::ItemKind::MacroDef(..) = item.kind {
if self.is_proc_macro_crate && self.sess.contains_name(&item.attrs, sym::macro_export) {
let msg =
"cannot export macro_rules! macros from a `proc-macro` crate type currently";
self.handler.span_err(self.source_map.guess_head_span(item.span), msg);
}
}
// First up, make sure we're checking a bare function. If we're not then
// we're just not interested in this item.
//
// If we find one, try to locate a `#[proc_macro_derive]` attribute on it.
let is_fn = matches!(item.kind, ast::ItemKind::Fn(..));
let mut found_attr: Option<&'a ast::Attribute> = None;
for attr in &item.attrs {
if self.sess.is_proc_macro_attr(&attr) {
if let Some(prev_attr) = found_attr {
let prev_item = prev_attr.get_normal_item();
let item = attr.get_normal_item();
let path_str = pprust::path_to_string(&item.path);
let msg = if item.path.segments[0].ident.name
== prev_item.path.segments[0].ident.name
{
format!(
"only one `#[{}]` attribute is allowed on any given function",
path_str,
)
} else {
format!(
"`#[{}]` and `#[{}]` attributes cannot both be applied
to the same function",
path_str,
pprust::path_to_string(&prev_item.path),
)
};
self.handler
.struct_span_err(attr.span, &msg)
.span_label(prev_attr.span, "previous attribute here")
.emit();
return;
}
found_attr = Some(attr);
}
}
let attr = match found_attr {
None => {
self.check_not_pub_in_root(&item.vis, self.source_map.guess_head_span(item.span));
let prev_in_root = mem::replace(&mut self.in_root, false);
visit::walk_item(self, item);
self.in_root = prev_in_root;
return;
}
Some(attr) => attr,
};
if !is_fn {
let msg = format!(
"the `#[{}]` attribute may only be used on bare functions",
pprust::path_to_string(&attr.get_normal_item().path),
);
self.handler.span_err(attr.span, &msg);
return;
}
if self.is_test_crate {
return;
}
if !self.is_proc_macro_crate {
let msg = format!(
"the `#[{}]` attribute is only usable with crates of the `proc-macro` crate type",
pprust::path_to_string(&attr.get_normal_item().path),
);
self.handler.span_err(attr.span, &msg);
return;
}
if attr.has_name(sym::proc_macro_derive) {
self.collect_custom_derive(item, attr);
} else if attr.has_name(sym::proc_macro_attribute) {
self.collect_attr_proc_macro(item);
} else if attr.has_name(sym::proc_macro) {
self.collect_bang_proc_macro(item);
};
let prev_in_root = mem::replace(&mut self.in_root, false); | }
}
// Creates a new module which looks like:
//
// const _: () = {
// extern crate proc_macro;
//
// use proc_macro::bridge::client::ProcMacro;
//
// #[rustc_proc_macro_decls]
// #[allow(deprecated)]
// static DECLS: &[ProcMacro] = &[
// ProcMacro::custom_derive($name_trait1, &[], ::$name1);
// ProcMacro::custom_derive($name_trait2, &["attribute_name"], ::$name2);
// // ...
// ];
// }
fn mk_decls(
ast_krate: &mut ast::Crate,
cx: &mut ExtCtxt<'_>,
macros: &[ProcMacro],
) -> P<ast::Item> {
// We're the ones filling in this Vec,
// so it should be empty to start with
assert!(ast_krate.proc_macros.is_empty());
let expn_id = cx.resolver.expansion_for_ast_pass(
DUMMY_SP,
AstPass::ProcMacroHarness,
&[sym::rustc_attrs, sym::proc_macro_internals],
None,
);
let span = DUMMY_SP.with_def_site_ctxt(expn_id.to_expn_id());
let proc_macro = Ident::new(sym::proc_macro, span);
let krate = cx.item(span, proc_macro, Vec::new(), ast::ItemKind::ExternCrate(None));
let bridge = Ident::new(sym::bridge, span);
let client = Ident::new(sym::client, span);
let proc_macro_ty = Ident::new(sym::ProcMacro, span);
let custom_derive = Ident::new(sym::custom_derive, span);
let attr = Ident::new(sym::attr, span);
let bang = Ident::new(sym::bang, span);
let krate_ref = RefCell::new(ast_krate);
// We add NodeIds to 'krate.proc_macros' in the order
// that we generate expressions. The position of each NodeId
// in the 'proc_macros' Vec corresponds to its position
// in the static array that will be generated
let decls = {
let local_path =
|sp: Span, name| cx.expr_path(cx.path(sp.with_ctxt(span.ctxt()), vec![name]));
let proc_macro_ty_method_path = |method| {
cx.expr_path(cx.path(span, vec![proc_macro, bridge, client, proc_macro_ty, method]))
};
macros
.iter()
.map(|m| match m {
ProcMacro::Derive(cd) => {
krate_ref.borrow_mut().proc_macros.push(cd.id);
cx.expr_call(
span,
proc_macro_ty_method_path(custom_derive),
vec![
cx.expr_str(cd.span, cd.trait_name),
cx.expr_vec_slice(
span,
cd.attrs
.iter()
.map(|&s| cx.expr_str(cd.span, s))
.collect::<Vec<_>>(),
),
local_path(cd.span, cd.function_name),
],
)
}
ProcMacro::Def(ca) => {
krate_ref.borrow_mut().proc_macros.push(ca.id);
let ident = match ca.def_type {
ProcMacroDefType::Attr => attr,
ProcMacroDefType::Bang => bang,
};
cx.expr_call(
span,
proc_macro_ty_method_path(ident),
vec![
cx.expr_str(ca.span, ca.function_name.name),
local_path(ca.span, ca.function_name),
],
)
}
})
.collect()
};
let decls_static = cx
.item_static(
span,
Ident::new(sym::_DECLS, span),
cx.ty_rptr(
span,
cx.ty(
span,
ast::TyKind::Slice(
cx.ty_path(cx.path(span, vec![proc_macro, bridge, client, proc_macro_ty])),
),
),
None,
ast::Mutability::Not,
),
ast::Mutability::Not,
cx.expr_vec_slice(span, decls),
)
.map(|mut i| {
let attr = cx.meta_word(span, sym::rustc_proc_macro_decls);
i.attrs.push(cx.attribute(attr));
let deprecated_attr = attr::mk_nested_word_item(Ident::new(sym::deprecated, span));
let allow_deprecated_attr =
attr::mk_list_item(Ident::new(sym::allow, span), vec![deprecated_attr]);
i.attrs.push(cx.attribute(allow_deprecated_attr));
i
});
let block = cx.expr_block(
cx.block(span, vec![cx.stmt_item(span, krate), cx.stmt_item(span, decls_static)]),
);
let anon_constant = cx.item_const(
span,
Ident::new(kw::Underscore, span),
cx.ty(span, ast::TyKind::Tup(Vec::new())),
block,
);
// Integrate the new item into existing module structures.
let items = AstFragment::Items(smallvec![anon_constant]);
cx.monotonic_expander().fully_expand_fragment(items).make_items().pop().unwrap()
} | visit::walk_item(self, item);
self.in_root = prev_in_root; |
__init__.py |
from torch.utils.ffi import _wrap_function
from ._rod_align import lib as _lib, ffi as _ffi
__all__ = []
def | (locals):
for symbol in dir(_lib):
fn = getattr(_lib, symbol)
if callable(fn):
locals[symbol] = _wrap_function(fn, _ffi)
else:
locals[symbol] = fn
__all__.append(symbol)
_import_symbols(locals())
| _import_symbols |
tests.rs | use super::lexer::{Lexer, MultiStringToken, NormalToken, StringToken, Token};
use crate::error::ParseError;
use crate::identifier::Ident;
use crate::parser::error::ParseError as InternalParseError;
use crate::term::make as mk_term;
use crate::term::Term::*;
use crate::term::{BinaryOp, RichTerm, StrChunk, UnaryOp};
use crate::{mk_app, mk_switch};
use assert_matches::assert_matches;
use codespan::Files;
fn parse(s: &str) -> Result<RichTerm, ParseError> {
let id = Files::new().add("<test>", String::from(s));
super::grammar::TermParser::new()
.parse_term(id, Lexer::new(&s))
.map_err(|errs| errs.errors.first().unwrap().clone())
}
fn parse_without_pos(s: &str) -> RichTerm {
parse(s).unwrap().without_pos()
}
fn lex(s: &str) -> Result<Vec<(usize, Token, usize)>, InternalParseError> {
Lexer::new(s).collect()
}
fn lex_without_pos(s: &str) -> Result<Vec<Token>, InternalParseError> {
lex(s).map(|v| v.into_iter().map(|(_, tok, _)| tok).collect())
}
/// Wrap a single string literal in a `StrChunks`.
fn mk_single_chunk(s: &str) -> RichTerm {
StrChunks(vec![StrChunk::Literal(String::from(s))]).into()
}
#[test]
fn numbers() {
assert_eq!(parse_without_pos("22"), Num(22.0).into());
assert_eq!(parse_without_pos("22.0"), Num(22.0).into());
assert_eq!(parse_without_pos("22.22"), Num(22.22).into());
assert_eq!(parse_without_pos("(22)"), Num(22.0).into());
assert_eq!(parse_without_pos("((22))"), Num(22.0).into());
}
#[test]
fn strings() {
assert_eq!(
parse_without_pos("\"hello world\""),
mk_single_chunk("hello world"),
);
assert_eq!(
parse_without_pos("\"hello \nworld\""),
mk_single_chunk("hello \nworld")
);
assert_eq!(
parse_without_pos("\"hello Dimension C-132!\""),
mk_single_chunk("hello Dimension C-132!")
);
assert_eq!(
parse_without_pos("\"hello\" ++ \"World\" ++ \"!!\" "),
Op2(
BinaryOp::StrConcat(),
Op2(
BinaryOp::StrConcat(),
mk_single_chunk("hello"),
mk_single_chunk("World"),
)
.into(),
mk_single_chunk("!!"),
)
.into()
)
}
#[test]
fn | () {
assert_eq!(
parse_without_pos("3 + 4"),
Op2(BinaryOp::Plus(), Num(3.0).into(), Num(4.).into()).into()
);
assert_eq!(
parse_without_pos("(true + false) + 4"),
Op2(
BinaryOp::Plus(),
Op2(BinaryOp::Plus(), Bool(true).into(), Bool(false).into()).into(),
Num(4.).into(),
)
.into()
);
}
#[test]
fn booleans() {
assert_eq!(parse_without_pos("true"), Bool(true).into());
assert_eq!(parse_without_pos("false"), Bool(false).into());
}
#[test]
fn ite() {
assert_eq!(
parse_without_pos("if true then 3 else 4"),
mk_app!(mk_term::op1(UnaryOp::Ite(), Bool(true)), Num(3.0), Num(4.0))
);
}
#[test]
fn applications() {
assert_eq!(
parse_without_pos("1 true 2"),
mk_app!(Num(1.0), Bool(true), Num(2.0))
);
assert_eq!(
parse_without_pos("1 (2 3) 4"),
mk_app!(Num(1.0), mk_app!(Num(2.0), Num(3.0)), Num(4.0))
);
}
#[test]
fn variables() {
assert!(parse("x1_x_").is_ok());
}
#[test]
fn functions() {
assert_eq!(
crate::transform::desugar_destructuring::desugar_fun(parse_without_pos("fun x => x")),
mk_term::id()
);
}
#[test]
fn lets() {
assert_matches!(parse("let x1 = x2 in x3"), Ok(..));
assert_matches!(parse("x (let x1 = x2 in x3) y"), Ok(..));
}
#[test]
fn unary_op() {
assert_eq!(
parse_without_pos("%is_num% x"),
mk_term::op1(UnaryOp::IsNum(), mk_term::var("x"))
);
assert_eq!(
parse_without_pos("%is_num% x y"),
mk_app!(
mk_term::op1(UnaryOp::IsNum(), mk_term::var("x")),
mk_term::var("y")
),
);
}
#[test]
fn enum_terms() {
assert_eq!(parse_without_pos("`foo"), Enum(Ident::from("foo")).into(),);
assert_eq!(
parse_without_pos("`\"foo:bar\""),
Enum(Ident::from("foo:bar")).into(),
);
assert_eq!(
parse_without_pos("switch { `foo => true, `bar => false, _ => 456, } 123"),
mk_switch!(Num(123.), ("foo", Bool(true)), ("bar", Bool(false)) ; Num(456.))
)
}
#[test]
fn record_terms() {
assert_eq!(
parse_without_pos("{ a = 1, b = 2, c = 3}"),
RecRecord(
vec![
(Ident::from("a"), Num(1.).into()),
(Ident::from("b"), Num(2.).into()),
(Ident::from("c"), Num(3.).into()),
]
.into_iter()
.collect(),
Vec::new(),
Default::default()
)
.into()
);
assert_eq!(
parse_without_pos("{ a = 1, \"#{123}\" = (if 4 then 5 else 6), d = 42}"),
RecRecord(
vec![
(Ident::from("a"), Num(1.).into()),
(Ident::from("d"), Num(42.).into()),
]
.into_iter()
.collect(),
vec![(
StrChunks(vec![StrChunk::expr(RichTerm::from(Num(123.)))]).into(),
mk_app!(mk_term::op1(UnaryOp::Ite(), Num(4.)), Num(5.), Num(6.))
)],
Default::default(),
)
.into()
);
assert_eq!(
parse_without_pos("{ a = 1, \"\\\"#}#\" = 2}"),
RecRecord(
vec![
(Ident::from("a"), Num(1.).into()),
(Ident::from("\"#}#"), Num(2.).into()),
]
.into_iter()
.collect(),
Vec::new(),
Default::default(),
)
.into()
);
}
#[test]
fn string_lexing() {
assert_eq!(
lex_without_pos("\"Good\" \"strings\""),
Ok(vec![
Token::Normal(NormalToken::DoubleQuote),
Token::Str(StringToken::Literal("Good")),
Token::Normal(NormalToken::DoubleQuote),
Token::Normal(NormalToken::DoubleQuote),
Token::Str(StringToken::Literal("strings")),
Token::Normal(NormalToken::DoubleQuote),
])
);
assert_eq!(
lex_without_pos("\"Good\\nEscape\\t\\\"\""),
Ok(vec![
Token::Normal(NormalToken::DoubleQuote),
Token::Str(StringToken::Literal("Good")),
Token::Str(StringToken::EscapedChar('\n')),
Token::Str(StringToken::Literal("Escape")),
Token::Str(StringToken::EscapedChar('\t')),
Token::Str(StringToken::EscapedChar('\"')),
Token::Normal(NormalToken::DoubleQuote),
])
);
assert_eq!(
lex_without_pos("\"1 + #{ 1 } + 2\""),
Ok(vec![
Token::Normal(NormalToken::DoubleQuote),
Token::Str(StringToken::Literal("1 + ")),
Token::Str(StringToken::HashBrace),
Token::Normal(NormalToken::NumLiteral(1.0)),
Token::Normal(NormalToken::RBrace),
Token::Str(StringToken::Literal(" + 2")),
Token::Normal(NormalToken::DoubleQuote),
])
);
assert_eq!(
lex_without_pos("\"1 + #{ \"#{ 1 }\" } + 2\""),
Ok(vec![
Token::Normal(NormalToken::DoubleQuote),
Token::Str(StringToken::Literal("1 + ")),
Token::Str(StringToken::HashBrace),
Token::Normal(NormalToken::DoubleQuote),
Token::Str(StringToken::HashBrace),
Token::Normal(NormalToken::NumLiteral(1.0)),
Token::Normal(NormalToken::RBrace),
Token::Normal(NormalToken::DoubleQuote),
Token::Normal(NormalToken::RBrace),
Token::Str(StringToken::Literal(" + 2")),
Token::Normal(NormalToken::DoubleQuote),
])
);
assert_eq!(
lex_without_pos(r##"m#""#"#m"##),
Ok(vec![
Token::Normal(NormalToken::MultiStringStart(3)),
Token::MultiStr(MultiStringToken::Literal("\"")),
Token::MultiStr(MultiStringToken::Literal("#")),
Token::MultiStr(MultiStringToken::End),
])
);
}
#[test]
fn str_escape() {
assert_matches!(
parse("\"bad escape \\g\""),
Err(ParseError::InvalidEscapeSequence(..))
);
assert_eq!(
parse_without_pos(r#""str\twith\nescapes""#),
mk_single_chunk("str\twith\nescapes"),
);
assert_eq!(
parse_without_pos("\"\\#\\#{ }\\#\""),
mk_single_chunk("##{ }#"),
);
assert_eq!(
parse_without_pos("\"#a#b#c\\#{d#\""),
mk_single_chunk("#a#b#c#{d#"),
);
}
#[test]
fn ascii_escape() {
assert_matches!(
parse("\"\\x[f\""),
Err(ParseError::InvalidEscapeSequence(..))
);
assert_matches!(
parse("\"\\x0\""),
Err(ParseError::InvalidEscapeSequence(..))
);
assert_matches!(
parse("\"\\x0z\""),
Err(ParseError::InvalidEscapeSequence(..))
);
assert_matches!(
parse("\"\\x80\""),
Err(ParseError::InvalidAsciiEscapeCode(..))
);
assert_matches!(
parse("\"\\xab\""),
Err(ParseError::InvalidAsciiEscapeCode(..))
);
assert_matches!(
parse("\"\\xFF\""),
Err(ParseError::InvalidAsciiEscapeCode(..))
);
assert_eq!(parse_without_pos("\"\\x00\""), mk_single_chunk("\x00"));
assert_eq!(parse_without_pos("\"\\x08\""), mk_single_chunk("\x08"));
assert_eq!(parse_without_pos("\"\\x7F\""), mk_single_chunk("\x7F"));
assert_eq!(parse_without_pos("m#\"\\x[f\"#m"), mk_single_chunk("\\x[f"));
assert_eq!(parse_without_pos("m#\"\\x0\"#m"), mk_single_chunk("\\x0"));
assert_eq!(parse_without_pos("m#\"\\x0z\"#m"), mk_single_chunk("\\x0z"));
assert_eq!(parse_without_pos("m#\"\\x00\"#m"), mk_single_chunk("\\x00"));
assert_eq!(parse_without_pos("m#\"\\x08\"#m"), mk_single_chunk("\\x08"));
assert_eq!(parse_without_pos("m#\"\\x7F\"#m"), mk_single_chunk("\\x7F"));
}
/// Regression test for [#230](https://github.com/tweag/nickel/issues/230).
#[test]
fn multiline_str_escape() {
assert_eq!(
parse_without_pos(r##"m#"#Hel##lo###"#m"##),
mk_single_chunk("#Hel##lo###"),
);
assert_eq!(
parse_without_pos(r##"m#"#Hel##{lo###{"#m"##),
mk_single_chunk("#Hel##{lo###{"),
);
}
#[test]
fn line_comments() {
assert_eq!(
parse_without_pos("// 1 +\n1 + 1// + 3\n//+ 2"),
parse_without_pos("1 + 1")
);
assert_eq!(
parse_without_pos(
"{ // Some comment
field = foo, // Some description
} // Some other"
),
parse_without_pos("{field = foo}")
);
}
#[test]
fn unbound_type_variables() {
// should fail, "a" is unbound
assert_matches!(
parse("1 | a"),
Err(ParseError::UnboundTypeVariables(unbound_vars, _)) if (unbound_vars.contains(&Ident::from("a")) && unbound_vars.len() == 1)
);
// should fail, "d" is unbound
assert_matches!(
parse("null: forall a b c. a -> (b -> List c) -> {foo : List {_ : d}, bar: b | Dyn}"),
Err(ParseError::UnboundTypeVariables(unbound_vars, _)) if (unbound_vars.contains(&Ident::from("d")) && unbound_vars.len() == 1)
);
// should fail, "e" is unbound
assert_matches!(
parse("null: forall a b c. a -> (b -> List c) -> {foo : List {_ : a}, bar: b | e}"),
Err(ParseError::UnboundTypeVariables(unbound_vars, _)) if (unbound_vars.contains(&Ident::from("e")) && unbound_vars.len() == 1)
);
// should fail, "a" is unbound
assert_matches!(
parse("null: a -> (forall a. a -> a)"),
Err(ParseError::UnboundTypeVariables(unbound_vars, _)) if (unbound_vars.contains(&Ident::from("a")) && unbound_vars.len() == 1)
);
}
| plus |
scaled_font.rs | use ffi;
#[cfg(feature = "use_glib")]
use glib::translate::*;
use std::ffi::CString;
use std::ptr;
use enums::FontType;
use ffi::{FontExtents, Glyph, TextCluster, TextExtents};
use matrices::Matrix;
use utils::status_to_result;
use super::{FontFace, FontOptions};
#[cfg(feature = "use_glib")]
glib_wrapper! {
#[derive(Debug)]
pub struct ScaledFont(Shared<ffi::cairo_scaled_font_t>);
match fn {
ref => |ptr| ffi::cairo_scaled_font_reference(ptr),
unref => |ptr| ffi::cairo_scaled_font_destroy(ptr),
get_type => || ffi::gobject::cairo_gobject_scaled_font_get_type(),
}
}
#[cfg(not(feature = "use_glib"))]
#[derive(Debug)]
pub struct ScaledFont(ptr::NonNull<ffi::cairo_scaled_font_t>);
impl ScaledFont {
pub fn new(
font_face: &FontFace,
font_matrix: &Matrix,
ctm: &Matrix,
options: &FontOptions,
) -> ScaledFont {
let scaled_font: ScaledFont = unsafe {
ScaledFont::from_raw_full(ffi::cairo_scaled_font_create(
font_face.to_raw_none(),
font_matrix.ptr(),
ctm.ptr(),
options.to_raw_none(),
))
};
let status = unsafe { ffi::cairo_scaled_font_status(scaled_font.to_raw_none()) };
status_to_result(status).expect("Failed to create a scaled font");
scaled_font
}
#[cfg(feature = "use_glib")]
pub fn to_raw_none(&self) -> *mut ffi::cairo_scaled_font_t {
self.to_glib_none().0
}
#[cfg(not(feature = "use_glib"))]
pub fn to_raw_none(&self) -> *mut ffi::cairo_scaled_font_t {
self.0.as_ptr()
}
#[cfg(not(feature = "use_glib"))]
pub unsafe fn from_raw_full(ptr: *mut ffi::cairo_scaled_font_t) -> ScaledFont {
assert!(!ptr.is_null());
ScaledFont(ptr::NonNull::new_unchecked(ptr))
}
#[cfg(feature = "use_glib")]
pub unsafe fn from_raw_full(ptr: *mut ffi::cairo_scaled_font_t) -> ScaledFont {
from_glib_full(ptr)
}
#[cfg(feature = "use_glib")]
pub unsafe fn from_raw_none(ptr: *mut ffi::cairo_scaled_font_t) -> ScaledFont {
from_glib_none(ptr)
}
#[cfg(not(feature = "use_glib"))]
pub unsafe fn from_raw_none(ptr: *mut ffi::cairo_scaled_font_t) -> ScaledFont {
assert!(!ptr.is_null());
ffi::cairo_scaled_font_reference(ptr);
ScaledFont(ptr::NonNull::new_unchecked(ptr))
}
pub fn get_type(&self) -> FontType {
unsafe { FontType::from(ffi::cairo_scaled_font_get_type(self.to_raw_none())) }
}
pub fn get_reference_count(&self) -> usize {
unsafe { ffi::cairo_scaled_font_get_reference_count(self.to_raw_none()) as usize }
}
pub fn extents(&self) -> FontExtents {
let mut extents = FontExtents {
ascent: 0.0,
descent: 0.0,
height: 0.0,
max_x_advance: 0.0,
max_y_advance: 0.0,
};
unsafe { ffi::cairo_scaled_font_extents(self.to_raw_none(), &mut extents) }
extents
}
pub fn text_extents(&self, text: &str) -> TextExtents {
let mut extents = TextExtents {
x_bearing: 0.0,
y_bearing: 0.0,
width: 0.0,
height: 0.0,
x_advance: 0.0,
y_advance: 0.0,
};
let text = CString::new(text).unwrap();
unsafe {
ffi::cairo_scaled_font_text_extents(self.to_raw_none(), text.as_ptr(), &mut extents)
}
extents
}
pub fn glyph_extents(&self, glyphs: &[Glyph]) -> TextExtents {
let mut extents = TextExtents {
x_bearing: 0.0,
y_bearing: 0.0,
width: 0.0,
height: 0.0,
x_advance: 0.0,
y_advance: 0.0,
};
unsafe {
ffi::cairo_scaled_font_glyph_extents(
self.to_raw_none(), | glyphs.len() as i32,
&mut extents,
)
}
extents
}
pub fn text_to_glyphs(&self, x: f64, y: f64, text: &str) -> (Vec<Glyph>, Vec<TextCluster>) {
// This large unsafe block is due to the FFI function returning two specially allocated
// (cairo_{glyph,text_cluster}_allocate) pointers that need to be copied into Vec<T>
// types before they're of any use to Rust code.
unsafe {
let mut glyphs_ptr: *mut Glyph = ptr::null_mut();
let mut glyph_count = 0i32;
let mut clusters_ptr: *mut TextCluster = ptr::null_mut();
let mut cluster_count = 0i32;
let mut cluster_flags = 0i32;
let text_length = text.len() as i32;
let text = CString::new(text).unwrap();
let status = ffi::cairo_scaled_font_text_to_glyphs(
self.to_raw_none(),
x,
y,
text.as_ptr(),
text_length,
&mut glyphs_ptr,
&mut glyph_count,
&mut clusters_ptr,
&mut cluster_count,
&mut cluster_flags,
);
status_to_result(status).expect("Failed to convert text to glyphs");
let glyph_count = glyph_count as usize;
let glyphs: Vec<Glyph> = {
let mut glyphs: Vec<Glyph> = Vec::with_capacity(glyph_count);
glyphs.set_len(glyph_count);
ptr::copy(glyphs_ptr, glyphs.as_mut_ptr(), glyph_count);
glyphs
};
let cluster_count = cluster_count as usize;
let clusters: Vec<TextCluster> = {
let mut clusters = Vec::with_capacity(cluster_count);
clusters.set_len(cluster_count);
ptr::copy(clusters_ptr, clusters.as_mut_ptr(), cluster_count);
clusters
};
ffi::cairo_glyph_free(glyphs_ptr);
ffi::cairo_text_cluster_free(clusters_ptr);
(glyphs, clusters)
}
}
pub fn get_font_face(&self) -> FontFace {
unsafe { FontFace::from_raw_none(ffi::cairo_scaled_font_get_font_face(self.to_raw_none())) }
}
pub fn get_font_options(&self) -> FontOptions {
let options = FontOptions::new();
unsafe {
ffi::cairo_scaled_font_get_font_options(self.to_raw_none(), options.to_raw_none())
}
options
}
pub fn get_font_matrix(&self) -> Matrix {
let mut matrix = Matrix::null();
unsafe { ffi::cairo_scaled_font_get_font_matrix(self.to_raw_none(), matrix.mut_ptr()) }
matrix
}
pub fn get_ctm(&self) -> Matrix {
let mut matrix = Matrix::null();
unsafe { ffi::cairo_scaled_font_get_ctm(self.to_raw_none(), matrix.mut_ptr()) }
matrix
}
pub fn get_scale_matrix(&self) -> Matrix {
let mut matrix = Matrix::null();
unsafe { ffi::cairo_scaled_font_get_scale_matrix(self.to_raw_none(), matrix.mut_ptr()) }
matrix
}
user_data_methods! {
ffi::cairo_scaled_font_get_user_data,
ffi::cairo_scaled_font_set_user_data,
}
}
#[cfg(not(feature = "use_glib"))]
impl Drop for ScaledFont {
fn drop(&mut self) {
unsafe {
ffi::cairo_scaled_font_destroy(self.to_raw_none());
}
}
}
#[cfg(not(feature = "use_glib"))]
impl Clone for ScaledFont {
fn clone(&self) -> ScaledFont {
unsafe { ScaledFont::from_raw_none(self.to_raw_none()) }
}
} | glyphs.as_ptr(), |
views.py | from django.shortcuts import render, redirect
from django.utils import translation, timezone
from django.http import HttpResponseRedirect
from django.urls import reverse
from product.models import Product, Product_type
from .forms import ProductForm
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
# Create your views here.
# This is main site 'index.html' view
def main(request):
userLanguage = 'en'
products = Product.objects.all().order_by('product_detail_type__product_type')
print("**********")
print(products)
site="main"
if translation.LANGUAGE_SESSION_KEY in request.session:
userLanguage = request.session[translation.LANGUAGE_SESSION_KEY]
context = {'site':site, 'products':products}
translation.activate(userLanguage)
return render(request, 'index.html', context)
def transEn(request):
if translation.LANGUAGE_SESSION_KEY in request.session:
del request.session[translation.LANGUAGE_SESSION_KEY]
userLanguage = 'en'
request.session[translation.LANGUAGE_SESSION_KEY] = userLanguage
return redirect(reverse('home'))
def transKo(request):
|
# file upload for Product
def model_form_upload(request):
if request.method == 'POST':
form = ProductForm(request.POST, request.FILES)
if form.is_valid():
form.save()
else:
form = ProductForm()
products = Product.objects.all()
context = {'form': form, 'products': products}
print("**********")
print(products)
return render(request, 'mainsite/product_upload.html', context)
| if translation.LANGUAGE_SESSION_KEY in request.session:
del request.session[translation.LANGUAGE_SESSION_KEY]
userLanguage = 'ko'
request.session[translation.LANGUAGE_SESSION_KEY] = userLanguage
return redirect(reverse('home')) |
reset.password.component.ts | import { Component, ChangeDetectorRef, OnInit, Inject } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';
import { NbAuthService, NB_AUTH_OPTIONS, NbResetPasswordComponent } from '@nebular/auth';
@Component({
selector: 'ngx-reset',
templateUrl: 'reset-password.component.html',
})
export class ResetPasswordComponent extends NbResetPasswordComponent implements OnInit {
token = '';
constructor(
@Inject(NB_AUTH_OPTIONS) protected options: {},
protected service: NbAuthService,
protected cd: ChangeDetectorRef,
protected router: Router,
private route: ActivatedRoute,
) {
super(service, options, cd, router);
}
ngOnInit() {
this.route.queryParams.subscribe(
params => {
this.user.token = params['token']; | } | },
);
} |
options.go | package gorocksdb
// #include "rocksdb/c.h"
// #include "gorocksdb.h"
import "C"
import "unsafe"
// CompressionType specifies the block compression.
// DB contents are stored in a set of blocks, each of which holds a
// sequence of key,value pairs. Each block may be compressed before
// being stored in a file. The following enum describes which
// compression method (if any) is used to compress a block.
type CompressionType uint
// Compression types.
const (
NoCompression = CompressionType(C.rocksdb_no_compression)
SnappyCompression = CompressionType(C.rocksdb_snappy_compression)
ZLibCompression = CompressionType(C.rocksdb_zlib_compression)
Bz2Compression = CompressionType(C.rocksdb_bz2_compression)
LZ4Compression = CompressionType(C.rocksdb_lz4_compression)
LZ4HCCompression = CompressionType(C.rocksdb_lz4hc_compression)
XpressCompression = CompressionType(C.rocksdb_xpress_compression)
ZSTDCompression = CompressionType(C.rocksdb_zstd_compression)
)
// CompactionStyle specifies the compaction style.
type CompactionStyle uint
// Compaction styles.
const (
LevelCompactionStyle = CompactionStyle(C.rocksdb_level_compaction)
UniversalCompactionStyle = CompactionStyle(C.rocksdb_universal_compaction)
FIFOCompactionStyle = CompactionStyle(C.rocksdb_fifo_compaction)
)
// CompactionAccessPattern specifies the access patern in compaction.
type CompactionAccessPattern uint
// Access patterns for compaction.
const (
NoneCompactionAccessPattern = CompactionAccessPattern(0)
NormalCompactionAccessPattern = CompactionAccessPattern(1)
SequentialCompactionAccessPattern = CompactionAccessPattern(2)
WillneedCompactionAccessPattern = CompactionAccessPattern(3)
)
// InfoLogLevel describes the log level.
type InfoLogLevel uint
// Log leves.
const (
DebugInfoLogLevel = InfoLogLevel(0)
InfoInfoLogLevel = InfoLogLevel(1)
WarnInfoLogLevel = InfoLogLevel(2)
ErrorInfoLogLevel = InfoLogLevel(3)
FatalInfoLogLevel = InfoLogLevel(4)
)
// Options represent all of the available options when opening a database with Open.
type Options struct {
c *C.rocksdb_options_t
// Hold references for GC.
env *Env
bbto *BlockBasedTableOptions
// We keep these so we can free their memory in Destroy.
ccmp *C.rocksdb_comparator_t
cmo *C.rocksdb_mergeoperator_t
cst *C.rocksdb_slicetransform_t
ccf *C.rocksdb_compactionfilter_t
}
// NewDefaultOptions creates the default Options.
func NewDefaultOptions() *Options |
// NewNativeOptions creates a Options object.
func NewNativeOptions(c *C.rocksdb_options_t) *Options {
return &Options{c: c}
}
// -------------------
// Parameters that affect behavior
// SetCompactionFilter sets the specified compaction filter
// which will be applied on compactions.
// Default: nil
func (opts *Options) SetCompactionFilter(value CompactionFilter) {
if nc, ok := value.(nativeCompactionFilter); ok {
opts.ccf = nc.c
} else {
idx := registerCompactionFilter(value)
opts.ccf = C.gorocksdb_compactionfilter_create(C.uintptr_t(idx))
}
C.rocksdb_options_set_compaction_filter(opts.c, opts.ccf)
}
// SetComparator sets the comparator which define the order of keys in the table.
// Default: a comparator that uses lexicographic byte-wise ordering
func (opts *Options) SetComparator(value Comparator) {
if nc, ok := value.(nativeComparator); ok {
opts.ccmp = nc.c
} else {
idx := registerComperator(value)
opts.ccmp = C.gorocksdb_comparator_create(C.uintptr_t(idx))
}
C.rocksdb_options_set_comparator(opts.c, opts.ccmp)
}
// SetMergeOperator sets the merge operator which will be called
// if a merge operations are used.
// Default: nil
func (opts *Options) SetMergeOperator(value MergeOperator) {
if nmo, ok := value.(nativeMergeOperator); ok {
opts.cmo = nmo.c
} else {
idx := registerMergeOperator(value)
opts.cmo = C.gorocksdb_mergeoperator_create(C.uintptr_t(idx))
}
C.rocksdb_options_set_merge_operator(opts.c, opts.cmo)
}
// A single CompactionFilter instance to call into during compaction.
// Allows an application to modify/delete a key-value during background
// compaction.
//
// If the client requires a new compaction filter to be used for different
// compaction runs, it can specify compaction_filter_factory instead of this
// option. The client should specify only one of the two.
// compaction_filter takes precedence over compaction_filter_factory if
// client specifies both.
//
// If multithreaded compaction is being used, the supplied CompactionFilter
// instance may be used from different threads concurrently and so should be
// thread-safe.
//
// Default: nil
// TODO: implement in C
//func (opts *Options) SetCompactionFilter(value *CompactionFilter) {
// C.rocksdb_options_set_compaction_filter(opts.c, value.filter)
//}
// This is a factory that provides compaction filter objects which allow
// an application to modify/delete a key-value during background compaction.
//
// A new filter will be created on each compaction run. If multithreaded
// compaction is being used, each created CompactionFilter will only be used
// from a single thread and so does not need to be thread-safe.
//
// Default: a factory that doesn't provide any object
// std::shared_ptr<CompactionFilterFactory> compaction_filter_factory;
// TODO: implement in C and Go
// Version TWO of the compaction_filter_factory
// It supports rolling compaction
//
// Default: a factory that doesn't provide any object
// std::shared_ptr<CompactionFilterFactoryV2> compaction_filter_factory_v2;
// TODO: implement in C and Go
// SetCreateIfMissing specifies whether the database
// should be created if it is missing.
// Default: false
func (opts *Options) SetCreateIfMissing(value bool) {
C.rocksdb_options_set_create_if_missing(opts.c, boolToChar(value))
}
// SetErrorIfExists specifies whether an error should be raised
// if the database already exists.
// Default: false
func (opts *Options) SetErrorIfExists(value bool) {
C.rocksdb_options_set_error_if_exists(opts.c, boolToChar(value))
}
// SetParanoidChecks enable/disable paranoid checks.
//
// If true, the implementation will do aggressive checking of the
// data it is processing and will stop early if it detects any
// errors. This may have unforeseen ramifications: for example, a
// corruption of one DB entry may cause a large number of entries to
// become unreadable or for the entire DB to become unopenable.
// If any of the writes to the database fails (Put, Delete, Merge, Write),
// the database will switch to read-only mode and fail all other
// Write operations.
// Default: false
func (opts *Options) SetParanoidChecks(value bool) {
C.rocksdb_options_set_paranoid_checks(opts.c, boolToChar(value))
}
// SetDBPaths sets the DBPaths of the options.
//
// A list of paths where SST files can be put into, with its target size.
// Newer data is placed into paths specified earlier in the vector while
// older data gradually moves to paths specified later in the vector.
//
// For example, you have a flash device with 10GB allocated for the DB,
// as well as a hard drive of 2TB, you should config it to be:
// [{"/flash_path", 10GB}, {"/hard_drive", 2TB}]
//
// The system will try to guarantee data under each path is close to but
// not larger than the target size. But current and future file sizes used
// by determining where to place a file are based on best-effort estimation,
// which means there is a chance that the actual size under the directory
// is slightly more than target size under some workloads. User should give
// some buffer room for those cases.
//
// If none of the paths has sufficient room to place a file, the file will
// be placed to the last path anyway, despite to the target size.
//
// Placing newer data to earlier paths is also best-efforts. User should
// expect user files to be placed in higher levels in some extreme cases.
//
// If left empty, only one path will be used, which is db_name passed when
// opening the DB.
// Default: empty
func (opts *Options) SetDBPaths(dbpaths []*DBPath) {
l := len(dbpaths)
cDbpaths := make([]*C.rocksdb_dbpath_t, l)
for i, v := range dbpaths {
cDbpaths[i] = v.c
}
C.rocksdb_options_set_db_paths(opts.c, &cDbpaths[0], C.size_t(l))
}
// SetEnv sets the specified object to interact with the environment,
// e.g. to read/write files, schedule background work, etc.
// Default: DefaultEnv
func (opts *Options) SetEnv(value *Env) {
opts.env = value
C.rocksdb_options_set_env(opts.c, value.c)
}
// SetInfoLogLevel sets the info log level.
// Default: InfoInfoLogLevel
func (opts *Options) SetInfoLogLevel(value InfoLogLevel) {
C.rocksdb_options_set_info_log_level(opts.c, C.int(value))
}
// IncreaseParallelism sets the parallelism.
//
// By default, RocksDB uses only one background thread for flush and
// compaction. Calling this function will set it up such that total of
// `total_threads` is used. Good value for `total_threads` is the number of
// cores. You almost definitely want to call this function if your system is
// bottlenecked by RocksDB.
func (opts *Options) IncreaseParallelism(total_threads int) {
C.rocksdb_options_increase_parallelism(opts.c, C.int(total_threads))
}
// OptimizeForPointLookup optimize the DB for point lookups.
//
// Use this if you don't need to keep the data sorted, i.e. you'll never use
// an iterator, only Put() and Get() API calls
//
// If you use this with rocksdb >= 5.0.2, you must call `SetAllowConcurrentMemtableWrites(false)`
// to avoid an assertion error immediately on opening the db.
func (opts *Options) OptimizeForPointLookup(block_cache_size_mb uint64) {
C.rocksdb_options_optimize_for_point_lookup(opts.c, C.uint64_t(block_cache_size_mb))
}
// Set whether to allow concurrent memtable writes. Conccurent writes are
// not supported by all memtable factories (currently only SkipList memtables).
// As of rocksdb 5.0.2 you must call `SetAllowConcurrentMemtableWrites(false)`
// if you use `OptimizeForPointLookup`.
func (opts *Options) SetAllowConcurrentMemtableWrites(allow bool) {
C.rocksdb_options_set_allow_concurrent_memtable_write(opts.c, boolToChar(allow))
}
// OptimizeLevelStyleCompaction optimize the DB for leveld compaction.
//
// Default values for some parameters in ColumnFamilyOptions are not
// optimized for heavy workloads and big datasets, which means you might
// observe write stalls under some conditions. As a starting point for tuning
// RocksDB options, use the following two functions:
// * OptimizeLevelStyleCompaction -- optimizes level style compaction
// * OptimizeUniversalStyleCompaction -- optimizes universal style compaction
// Universal style compaction is focused on reducing Write Amplification
// Factor for big data sets, but increases Space Amplification. You can learn
// more about the different styles here:
// https://github.com/facebook/rocksdb/wiki/Rocksdb-Architecture-Guide
// Make sure to also call IncreaseParallelism(), which will provide the
// biggest performance gains.
// Note: we might use more memory than memtable_memory_budget during high
// write rate period
func (opts *Options) OptimizeLevelStyleCompaction(memtable_memory_budget uint64) {
C.rocksdb_options_optimize_level_style_compaction(opts.c, C.uint64_t(memtable_memory_budget))
}
// OptimizeUniversalStyleCompaction optimize the DB for universal compaction.
// See note on OptimizeLevelStyleCompaction.
func (opts *Options) OptimizeUniversalStyleCompaction(memtable_memory_budget uint64) {
C.rocksdb_options_optimize_universal_style_compaction(opts.c, C.uint64_t(memtable_memory_budget))
}
// SetWriteBufferSize sets the amount of data to build up in memory
// (backed by an unsorted log on disk) before converting to a sorted on-disk file.
//
// Larger values increase performance, especially during bulk loads.
// Up to max_write_buffer_number write buffers may be held in memory
// at the same time,
// so you may wish to adjust this parameter to control memory usage.
// Also, a larger write buffer will result in a longer recovery time
// the next time the database is opened.
// Default: 4MB
func (opts *Options) SetWriteBufferSize(value int) {
C.rocksdb_options_set_write_buffer_size(opts.c, C.size_t(value))
}
// SetMaxWriteBufferNumber sets the maximum number of write buffers
// that are built up in memory.
//
// The default is 2, so that when 1 write buffer is being flushed to
// storage, new writes can continue to the other write buffer.
// Default: 2
func (opts *Options) SetMaxWriteBufferNumber(value int) {
C.rocksdb_options_set_max_write_buffer_number(opts.c, C.int(value))
}
// SetMinWriteBufferNumberToMerge sets the minimum number of write buffers
// that will be merged together before writing to storage.
//
// If set to 1, then all write buffers are flushed to L0 as individual files
// and this increases read amplification because a get request has to check
// in all of these files. Also, an in-memory merge may result in writing lesser
// data to storage if there are duplicate records in each of these
// individual write buffers.
// Default: 1
func (opts *Options) SetMinWriteBufferNumberToMerge(value int) {
C.rocksdb_options_set_min_write_buffer_number_to_merge(opts.c, C.int(value))
}
// SetMaxOpenFiles sets the number of open files that can be used by the DB.
//
// You may need to increase this if your database has a large working set
// (budget one open file per 2MB of working set).
// Default: 1000
func (opts *Options) SetMaxOpenFiles(value int) {
C.rocksdb_options_set_max_open_files(opts.c, C.int(value))
}
// SetMaxFileOpeningThreads sets the maximum number of file opening threads.
// If max_open_files is -1, DB will open all files on DB::Open(). You can
// use this option to increase the number of threads used to open the files.
// Default: 16
func (opts *Options) SetMaxFileOpeningThreads(value int) {
C.rocksdb_options_set_max_file_opening_threads(opts.c, C.int(value))
}
// SetMaxTotalWalSize sets the maximum total wal size in bytes.
// Once write-ahead logs exceed this size, we will start forcing the flush of
// column families whose memtables are backed by the oldest live WAL file
// (i.e. the ones that are causing all the space amplification). If set to 0
// (default), we will dynamically choose the WAL size limit to be
// [sum of all write_buffer_size * max_write_buffer_number] * 4
// Default: 0
func (opts *Options) SetMaxTotalWalSize(value uint64) {
C.rocksdb_options_set_max_total_wal_size(opts.c, C.uint64_t(value))
}
// SetCompression sets the compression algorithm.
// Default: SnappyCompression, which gives lightweight but fast
// compression.
func (opts *Options) SetCompression(value CompressionType) {
C.rocksdb_options_set_compression(opts.c, C.int(value))
}
// SetCompressionPerLevel sets different compression algorithm per level.
//
// Different levels can have different compression policies. There
// are cases where most lower levels would like to quick compression
// algorithm while the higher levels (which have more data) use
// compression algorithms that have better compression but could
// be slower. This array should have an entry for
// each level of the database. This array overrides the
// value specified in the previous field 'compression'.
func (opts *Options) SetCompressionPerLevel(value []CompressionType) {
cLevels := make([]C.int, len(value))
for i, v := range value {
cLevels[i] = C.int(v)
}
C.rocksdb_options_set_compression_per_level(opts.c, &cLevels[0], C.size_t(len(value)))
}
// SetMinLevelToCompress sets the start level to use compression.
func (opts *Options) SetMinLevelToCompress(value int) {
C.rocksdb_options_set_min_level_to_compress(opts.c, C.int(value))
}
// SetCompressionOptions sets different options for compression algorithms.
// Default: nil
func (opts *Options) SetCompressionOptions(value *CompressionOptions) {
C.rocksdb_options_set_compression_options(opts.c, C.int(value.WindowBits), C.int(value.Level), C.int(value.Strategy), C.int(value.MaxDictBytes))
}
// SetPrefixExtractor sets the prefic extractor.
//
// If set, use the specified function to determine the
// prefixes for keys. These prefixes will be placed in the filter.
// Depending on the workload, this can reduce the number of read-IOP
// cost for scans when a prefix is passed via ReadOptions to
// db.NewIterator().
// Default: nil
func (opts *Options) SetPrefixExtractor(value SliceTransform) {
if nst, ok := value.(nativeSliceTransform); ok {
opts.cst = nst.c
} else {
idx := registerSliceTransform(value)
opts.cst = C.gorocksdb_slicetransform_create(C.uintptr_t(idx))
}
C.rocksdb_options_set_prefix_extractor(opts.c, opts.cst)
}
// SetNumLevels sets the number of levels for this database.
// Default: 7
func (opts *Options) SetNumLevels(value int) {
C.rocksdb_options_set_num_levels(opts.c, C.int(value))
}
// SetLevel0FileNumCompactionTrigger sets the number of files
// to trigger level-0 compaction.
//
// A value <0 means that level-0 compaction will not be
// triggered by number of files at all.
// Default: 4
func (opts *Options) SetLevel0FileNumCompactionTrigger(value int) {
C.rocksdb_options_set_level0_file_num_compaction_trigger(opts.c, C.int(value))
}
// SetLevel0SlowdownWritesTrigger sets the soft limit on number of level-0 files.
//
// We start slowing down writes at this point.
// A value <0 means that no writing slow down will be triggered by
// number of files in level-0.
// Default: 8
func (opts *Options) SetLevel0SlowdownWritesTrigger(value int) {
C.rocksdb_options_set_level0_slowdown_writes_trigger(opts.c, C.int(value))
}
// SetLevel0StopWritesTrigger sets the maximum number of level-0 files.
// We stop writes at this point.
// Default: 12
func (opts *Options) SetLevel0StopWritesTrigger(value int) {
C.rocksdb_options_set_level0_stop_writes_trigger(opts.c, C.int(value))
}
// SetMaxMemCompactionLevel sets the maximum level
// to which a new compacted memtable is pushed if it does not create overlap.
//
// We try to push to level 2 to avoid the
// relatively expensive level 0=>1 compactions and to avoid some
// expensive manifest file operations. We do not push all the way to
// the largest level since that can generate a lot of wasted disk
// space if the same key space is being repeatedly overwritten.
// Default: 2
func (opts *Options) SetMaxMemCompactionLevel(value int) {
C.rocksdb_options_set_max_mem_compaction_level(opts.c, C.int(value))
}
// SetTargetFileSizeBase sets the target file size for compaction.
//
// Target file size is per-file size for level-1.
// Target file size for level L can be calculated by
// target_file_size_base * (target_file_size_multiplier ^ (L-1))
//
// For example, if target_file_size_base is 2MB and
// target_file_size_multiplier is 10, then each file on level-1 will
// be 2MB, and each file on level 2 will be 20MB,
// and each file on level-3 will be 200MB.
// Default: 2MB
func (opts *Options) SetTargetFileSizeBase(value uint64) {
C.rocksdb_options_set_target_file_size_base(opts.c, C.uint64_t(value))
}
// SetTargetFileSizeMultiplier sets the target file size multiplier for compaction.
// Default: 1
func (opts *Options) SetTargetFileSizeMultiplier(value int) {
C.rocksdb_options_set_target_file_size_multiplier(opts.c, C.int(value))
}
// SetMaxBytesForLevelBase sets the maximum total data size for a level.
//
// It is the max total for level-1.
// Maximum number of bytes for level L can be calculated as
// (max_bytes_for_level_base) * (max_bytes_for_level_multiplier ^ (L-1))
//
// For example, if max_bytes_for_level_base is 20MB, and if
// max_bytes_for_level_multiplier is 10, total data size for level-1
// will be 20MB, total file size for level-2 will be 200MB,
// and total file size for level-3 will be 2GB.
// Default: 10MB
func (opts *Options) SetMaxBytesForLevelBase(value uint64) {
C.rocksdb_options_set_max_bytes_for_level_base(opts.c, C.uint64_t(value))
}
// SetMaxBytesForLevelMultiplier sets the max Bytes for level multiplier.
// Default: 10
func (opts *Options) SetMaxBytesForLevelMultiplier(value float64) {
C.rocksdb_options_set_max_bytes_for_level_multiplier(opts.c, C.double(value))
}
// SetLevelCompactiondynamiclevelbytes specifies whether to pick
// target size of each level dynamically.
//
// We will pick a base level b >= 1. L0 will be directly merged into level b,
// instead of always into level 1. Level 1 to b-1 need to be empty.
// We try to pick b and its target size so that
// 1. target size is in the range of
// (max_bytes_for_level_base / max_bytes_for_level_multiplier,
// max_bytes_for_level_base]
// 2. target size of the last level (level num_levels-1) equals to extra size
// of the level.
// At the same time max_bytes_for_level_multiplier and
// max_bytes_for_level_multiplier_additional are still satisfied.
//
// With this option on, from an empty DB, we make last level the base level,
// which means merging L0 data into the last level, until it exceeds
// max_bytes_for_level_base. And then we make the second last level to be
// base level, to start to merge L0 data to second last level, with its
// target size to be 1/max_bytes_for_level_multiplier of the last level's
// extra size. After the data accumulates more so that we need to move the
// base level to the third last one, and so on.
//
// For example, assume max_bytes_for_level_multiplier=10, num_levels=6,
// and max_bytes_for_level_base=10MB.
// Target sizes of level 1 to 5 starts with:
// [- - - - 10MB]
// with base level is level. Target sizes of level 1 to 4 are not applicable
// because they will not be used.
// Until the size of Level 5 grows to more than 10MB, say 11MB, we make
// base target to level 4 and now the targets looks like:
// [- - - 1.1MB 11MB]
// While data are accumulated, size targets are tuned based on actual data
// of level 5. When level 5 has 50MB of data, the target is like:
// [- - - 5MB 50MB]
// Until level 5's actual size is more than 100MB, say 101MB. Now if we keep
// level 4 to be the base level, its target size needs to be 10.1MB, which
// doesn't satisfy the target size range. So now we make level 3 the target
// size and the target sizes of the levels look like:
// [- - 1.01MB 10.1MB 101MB]
// In the same way, while level 5 further grows, all levels' targets grow,
// like
// [- - 5MB 50MB 500MB]
// Until level 5 exceeds 1000MB and becomes 1001MB, we make level 2 the
// base level and make levels' target sizes like this:
// [- 1.001MB 10.01MB 100.1MB 1001MB]
// and go on...
//
// By doing it, we give max_bytes_for_level_multiplier a priority against
// max_bytes_for_level_base, for a more predictable LSM tree shape. It is
// useful to limit worse case space amplification.
//
// max_bytes_for_level_multiplier_additional is ignored with this flag on.
//
// Turning this feature on or off for an existing DB can cause unexpected
// LSM tree structure so it's not recommended.
//
// Default: false
func (opts *Options) SetLevelCompactionDynamicLevelBytes(value bool) {
C.rocksdb_options_set_level_compaction_dynamic_level_bytes(opts.c, boolToChar(value))
}
// SetMaxCompactionBytes sets the maximum number of bytes in all compacted files.
// We try to limit number of bytes in one compaction to be lower than this
// threshold. But it's not guaranteed.
// Value 0 will be sanitized.
// Default: result.target_file_size_base * 25
func (opts *Options) SetMaxCompactionBytes(value uint64) {
C.rocksdb_options_set_max_compaction_bytes(opts.c, C.uint64_t(value))
}
// SetSoftPendingCompactionBytesLimit sets the threshold at which
// all writes will be slowed down to at least delayed_write_rate if estimated
// bytes needed to be compaction exceed this threshold.
//
// Default: 64GB
func (opts *Options) SetSoftPendingCompactionBytesLimit(value uint64) {
C.rocksdb_options_set_soft_pending_compaction_bytes_limit(opts.c, C.size_t(value))
}
// SetHardPendingCompactionBytesLimit sets the bytes threshold at which
// all writes are stopped if estimated bytes needed to be compaction exceed
// this threshold.
//
// Default: 256GB
func (opts *Options) SetHardPendingCompactionBytesLimit(value uint64) {
C.rocksdb_options_set_hard_pending_compaction_bytes_limit(opts.c, C.size_t(value))
}
// SetMaxBytesForLevelMultiplierAdditional sets different max-size multipliers
// for different levels.
//
// These are multiplied by max_bytes_for_level_multiplier to arrive
// at the max-size of each level.
// Default: 1 for each level
func (opts *Options) SetMaxBytesForLevelMultiplierAdditional(value []int) {
cLevels := make([]C.int, len(value))
for i, v := range value {
cLevels[i] = C.int(v)
}
C.rocksdb_options_set_max_bytes_for_level_multiplier_additional(opts.c, &cLevels[0], C.size_t(len(value)))
}
// SetUseFsync enable/disable fsync.
//
// If true, then every store to stable storage will issue a fsync.
// If false, then every store to stable storage will issue a fdatasync.
// This parameter should be set to true while storing data to
// filesystem like ext3 that can lose files after a reboot.
// Default: false
func (opts *Options) SetUseFsync(value bool) {
C.rocksdb_options_set_use_fsync(opts.c, C.int(btoi(value)))
}
// SetDbLogDir specifies the absolute info LOG dir.
//
// If it is empty, the log files will be in the same dir as data.
// If it is non empty, the log files will be in the specified dir,
// and the db data dir's absolute path will be used as the log file
// name's prefix.
// Default: empty
func (opts *Options) SetDbLogDir(value string) {
cvalue := C.CString(value)
defer C.free(unsafe.Pointer(cvalue))
C.rocksdb_options_set_db_log_dir(opts.c, cvalue)
}
// SetWalDir specifies the absolute dir path for write-ahead logs (WAL).
//
// If it is empty, the log files will be in the same dir as data.
// If it is non empty, the log files will be in the specified dir,
// When destroying the db, all log files and the dir itopts is deleted.
// Default: empty
func (opts *Options) SetWalDir(value string) {
cvalue := C.CString(value)
defer C.free(unsafe.Pointer(cvalue))
C.rocksdb_options_set_wal_dir(opts.c, cvalue)
}
// SetDeleteObsoleteFilesPeriodMicros sets the periodicity
// when obsolete files get deleted.
//
// The files that get out of scope by compaction
// process will still get automatically delete on every compaction,
// regardless of this setting.
// Default: 6 hours
func (opts *Options) SetDeleteObsoleteFilesPeriodMicros(value uint64) {
C.rocksdb_options_set_delete_obsolete_files_period_micros(opts.c, C.uint64_t(value))
}
// SetMaxBackgroundCompactions sets the maximum number of
// concurrent background jobs, submitted to
// the default LOW priority thread pool
// Default: 1
func (opts *Options) SetMaxBackgroundCompactions(value int) {
C.rocksdb_options_set_max_background_compactions(opts.c, C.int(value))
}
// SetMaxBackgroundFlushes sets the maximum number of
// concurrent background memtable flush jobs, submitted to
// the HIGH priority thread pool.
//
// By default, all background jobs (major compaction and memtable flush) go
// to the LOW priority pool. If this option is set to a positive number,
// memtable flush jobs will be submitted to the HIGH priority pool.
// It is important when the same Env is shared by multiple db instances.
// Without a separate pool, long running major compaction jobs could
// potentially block memtable flush jobs of other db instances, leading to
// unnecessary Put stalls.
// Default: 0
func (opts *Options) SetMaxBackgroundFlushes(value int) {
C.rocksdb_options_set_max_background_flushes(opts.c, C.int(value))
}
// SetMaxLogFileSize sets the maximal size of the info log file.
//
// If the log file is larger than `max_log_file_size`, a new info log
// file will be created.
// If max_log_file_size == 0, all logs will be written to one log file.
// Default: 0
func (opts *Options) SetMaxLogFileSize(value int) {
C.rocksdb_options_set_max_log_file_size(opts.c, C.size_t(value))
}
// SetLogFileTimeToRoll sets the time for the info log file to roll (in seconds).
//
// If specified with non-zero value, log file will be rolled
// if it has been active longer than `log_file_time_to_roll`.
// Default: 0 (disabled)
func (opts *Options) SetLogFileTimeToRoll(value int) {
C.rocksdb_options_set_log_file_time_to_roll(opts.c, C.size_t(value))
}
// SetKeepLogFileNum sets the maximal info log files to be kept.
// Default: 1000
func (opts *Options) SetKeepLogFileNum(value int) {
C.rocksdb_options_set_keep_log_file_num(opts.c, C.size_t(value))
}
// SetSoftRateLimit sets the soft rate limit.
//
// Puts are delayed 0-1 ms when any level has a compaction score that exceeds
// soft_rate_limit. This is ignored when == 0.0.
// CONSTRAINT: soft_rate_limit <= hard_rate_limit. If this constraint does not
// hold, RocksDB will set soft_rate_limit = hard_rate_limit
// Default: 0.0 (disabled)
func (opts *Options) SetSoftRateLimit(value float64) {
C.rocksdb_options_set_soft_rate_limit(opts.c, C.double(value))
}
// SetHardRateLimit sets the hard rate limit.
//
// Puts are delayed 1ms at a time when any level has a compaction score that
// exceeds hard_rate_limit. This is ignored when <= 1.0.
// Default: 0.0 (disabled)
func (opts *Options) SetHardRateLimit(value float64) {
C.rocksdb_options_set_hard_rate_limit(opts.c, C.double(value))
}
// SetRateLimitDelayMaxMilliseconds sets the max time
// a put will be stalled when hard_rate_limit is enforced.
// If 0, then there is no limit.
// Default: 1000
func (opts *Options) SetRateLimitDelayMaxMilliseconds(value uint) {
C.rocksdb_options_set_rate_limit_delay_max_milliseconds(opts.c, C.uint(value))
}
// SetMaxManifestFileSize sets the maximal manifest file size until is rolled over.
// The older manifest file be deleted.
// Default: MAX_INT so that roll-over does not take place.
func (opts *Options) SetMaxManifestFileSize(value uint64) {
C.rocksdb_options_set_max_manifest_file_size(opts.c, C.size_t(value))
}
// SetTableCacheNumshardbits sets the number of shards used for table cache.
// Default: 4
func (opts *Options) SetTableCacheNumshardbits(value int) {
C.rocksdb_options_set_table_cache_numshardbits(opts.c, C.int(value))
}
// SetTableCacheRemoveScanCountLimit sets the count limit during a scan.
//
// During data eviction of table's LRU cache, it would be inefficient
// to strictly follow LRU because this piece of memory will not really
// be released unless its refcount falls to zero. Instead, make two
// passes: the first pass will release items with refcount = 1,
// and if not enough space releases after scanning the number of
// elements specified by this parameter, we will remove items in LRU order.
// Default: 16
func (opts *Options) SetTableCacheRemoveScanCountLimit(value int) {
C.rocksdb_options_set_table_cache_remove_scan_count_limit(opts.c, C.int(value))
}
// SetArenaBlockSize sets the size of one block in arena memory allocation.
//
// If <= 0, a proper value is automatically calculated (usually 1/10 of
// writer_buffer_size).
// Default: 0
func (opts *Options) SetArenaBlockSize(value int) {
C.rocksdb_options_set_arena_block_size(opts.c, C.size_t(value))
}
// SetDisableAutoCompactions enable/disable automatic compactions.
//
// Manual compactions can still be issued on this database.
// Default: false
func (opts *Options) SetDisableAutoCompactions(value bool) {
C.rocksdb_options_set_disable_auto_compactions(opts.c, C.int(btoi(value)))
}
// SetWALTtlSeconds sets the WAL ttl in seconds.
//
// The following two options affect how archived logs will be deleted.
// 1. If both set to 0, logs will be deleted asap and will not get into
// the archive.
// 2. If wal_ttl_seconds is 0 and wal_size_limit_mb is not 0,
// WAL files will be checked every 10 min and if total size is greater
// then wal_size_limit_mb, they will be deleted starting with the
// earliest until size_limit is met. All empty files will be deleted.
// 3. If wal_ttl_seconds is not 0 and wall_size_limit_mb is 0, then
// WAL files will be checked every wal_ttl_seconds / 2 and those that
// are older than wal_ttl_seconds will be deleted.
// 4. If both are not 0, WAL files will be checked every 10 min and both
// checks will be performed with ttl being first.
// Default: 0
func (opts *Options) SetWALTtlSeconds(value uint64) {
C.rocksdb_options_set_WAL_ttl_seconds(opts.c, C.uint64_t(value))
}
// SetWalSizeLimitMb sets the WAL size limit in MB.
//
// If total size of WAL files is greater then wal_size_limit_mb,
// they will be deleted starting with the earliest until size_limit is met
// Default: 0
func (opts *Options) SetWalSizeLimitMb(value uint64) {
C.rocksdb_options_set_WAL_size_limit_MB(opts.c, C.uint64_t(value))
}
// SetManifestPreallocationSize sets the number of bytes
// to preallocate (via fallocate) the manifest files.
//
// Default is 4mb, which is reasonable to reduce random IO
// as well as prevent overallocation for mounts that preallocate
// large amounts of data (such as xfs's allocsize option).
// Default: 4mb
func (opts *Options) SetManifestPreallocationSize(value int) {
C.rocksdb_options_set_manifest_preallocation_size(opts.c, C.size_t(value))
}
// SetPurgeRedundantKvsWhileFlush enable/disable purging of
// duplicate/deleted keys when a memtable is flushed to storage.
// Default: true
func (opts *Options) SetPurgeRedundantKvsWhileFlush(value bool) {
C.rocksdb_options_set_purge_redundant_kvs_while_flush(opts.c, boolToChar(value))
}
// SetAllowMmapReads enable/disable mmap reads for reading sst tables.
// Default: false
func (opts *Options) SetAllowMmapReads(value bool) {
C.rocksdb_options_set_allow_mmap_reads(opts.c, boolToChar(value))
}
// SetAllowMmapWrites enable/disable mmap writes for writing sst tables.
// Default: false
func (opts *Options) SetAllowMmapWrites(value bool) {
C.rocksdb_options_set_allow_mmap_writes(opts.c, boolToChar(value))
}
// SetUseDirectReads enable/disable direct I/O mode (O_DIRECT) for reads
// Default: false
func (opts *Options) SetUseDirectReads(value bool) {
C.rocksdb_options_set_use_direct_reads(opts.c, boolToChar(value))
}
// SetUseDirectIOForFlushAndCompaction enable/disable direct I/O mode (O_DIRECT) for both reads and writes in background flush and compactions
// When true, new_table_reader_for_compaction_inputs is forced to true.
// Default: false
func (opts *Options) SetUseDirectIOForFlushAndCompaction(value bool) {
C.rocksdb_options_set_use_direct_io_for_flush_and_compaction(opts.c, boolToChar(value))
}
// SetIsFdCloseOnExec enable/dsiable child process inherit open files.
// Default: true
func (opts *Options) SetIsFdCloseOnExec(value bool) {
C.rocksdb_options_set_is_fd_close_on_exec(opts.c, boolToChar(value))
}
// SetSkipLogErrorOnRecovery enable/disable skipping of
// log corruption error on recovery (If client is ok with
// losing most recent changes)
// Default: false
func (opts *Options) SetSkipLogErrorOnRecovery(value bool) {
C.rocksdb_options_set_skip_log_error_on_recovery(opts.c, boolToChar(value))
}
// SetStatsDumpPeriodSec sets the stats dump period in seconds.
//
// If not zero, dump stats to LOG every stats_dump_period_sec
// Default: 3600 (1 hour)
func (opts *Options) SetStatsDumpPeriodSec(value uint) {
C.rocksdb_options_set_stats_dump_period_sec(opts.c, C.uint(value))
}
// SetAdviseRandomOnOpen specifies whether we will hint the underlying
// file system that the file access pattern is random, when a sst file is opened.
// Default: true
func (opts *Options) SetAdviseRandomOnOpen(value bool) {
C.rocksdb_options_set_advise_random_on_open(opts.c, boolToChar(value))
}
// SetDbWriteBufferSize sets the amount of data to build up
// in memtables across all column families before writing to disk.
//
// This is distinct from write_buffer_size, which enforces a limit
// for a single memtable.
//
// This feature is disabled by default. Specify a non-zero value
// to enable it.
//
// Default: 0 (disabled)
func (opts *Options) SetDbWriteBufferSize(value int) {
C.rocksdb_options_set_db_write_buffer_size(opts.c, C.size_t(value))
}
// SetAccessHintOnCompactionStart specifies the file access pattern
// once a compaction is started.
//
// It will be applied to all input files of a compaction.
// Default: NormalCompactionAccessPattern
func (opts *Options) SetAccessHintOnCompactionStart(value CompactionAccessPattern) {
C.rocksdb_options_set_access_hint_on_compaction_start(opts.c, C.int(value))
}
// SetUseAdaptiveMutex enable/disable adaptive mutex, which spins
// in the user space before resorting to kernel.
//
// This could reduce context switch when the mutex is not
// heavily contended. However, if the mutex is hot, we could end up
// wasting spin time.
// Default: false
func (opts *Options) SetUseAdaptiveMutex(value bool) {
C.rocksdb_options_set_use_adaptive_mutex(opts.c, boolToChar(value))
}
// SetBytesPerSync sets the bytes per sync.
//
// Allows OS to incrementally sync files to disk while they are being
// written, asynchronously, in the background.
// Issue one request for every bytes_per_sync written.
// Default: 0 (disabled)
func (opts *Options) SetBytesPerSync(value uint64) {
C.rocksdb_options_set_bytes_per_sync(opts.c, C.uint64_t(value))
}
// SetCompactionStyle sets the compaction style.
// Default: LevelCompactionStyle
func (opts *Options) SetCompactionStyle(value CompactionStyle) {
C.rocksdb_options_set_compaction_style(opts.c, C.int(value))
}
// SetUniversalCompactionOptions sets the options needed
// to support Universal Style compactions.
// Default: nil
func (opts *Options) SetUniversalCompactionOptions(value *UniversalCompactionOptions) {
C.rocksdb_options_set_universal_compaction_options(opts.c, value.c)
}
// SetFIFOCompactionOptions sets the options for FIFO compaction style.
// Default: nil
func (opts *Options) SetFIFOCompactionOptions(value *FIFOCompactionOptions) {
C.rocksdb_options_set_fifo_compaction_options(opts.c, value.c)
}
// SetRateLimiter sets the rate limiter of the options.
// Use to control write rate of flush and compaction. Flush has higher
// priority than compaction. Rate limiting is disabled if nullptr.
// If rate limiter is enabled, bytes_per_sync is set to 1MB by default.
// Default: nullptr
func (opts *Options) SetRateLimiter(rateLimiter *RateLimiter) {
C.rocksdb_options_set_ratelimiter(opts.c, rateLimiter.c)
}
// SetMaxSequentialSkipInIterations specifies whether an iteration->Next()
// sequentially skips over keys with the same user-key or not.
//
// This number specifies the number of keys (with the same userkey)
// that will be sequentially skipped before a reseek is issued.
// Default: 8
func (opts *Options) SetMaxSequentialSkipInIterations(value uint64) {
C.rocksdb_options_set_max_sequential_skip_in_iterations(opts.c, C.uint64_t(value))
}
// SetInplaceUpdateSupport enable/disable thread-safe inplace updates.
//
// Requires updates if
// * key exists in current memtable
// * new sizeof(new_value) <= sizeof(old_value)
// * old_value for that key is a put i.e. kTypeValue
// Default: false.
func (opts *Options) SetInplaceUpdateSupport(value bool) {
C.rocksdb_options_set_inplace_update_support(opts.c, boolToChar(value))
}
// SetInplaceUpdateNumLocks sets the number of locks used for inplace update.
// Default: 10000, if inplace_update_support = true, else 0.
func (opts *Options) SetInplaceUpdateNumLocks(value int) {
C.rocksdb_options_set_inplace_update_num_locks(opts.c, C.size_t(value))
}
// SetMemtableHugePageSize sets the page size for huge page for
// arena used by the memtable.
// If <=0, it won't allocate from huge page but from malloc.
// Users are responsible to reserve huge pages for it to be allocated. For
// example:
// sysctl -w vm.nr_hugepages=20
// See linux doc Documentation/vm/hugetlbpage.txt
// If there isn't enough free huge page available, it will fall back to
// malloc.
//
// Dynamically changeable through SetOptions() API
func (opts *Options) SetMemtableHugePageSize(value int) {
C.rocksdb_options_set_memtable_huge_page_size(opts.c, C.size_t(value))
}
// SetBloomLocality sets the bloom locality.
//
// Control locality of bloom filter probes to improve cache miss rate.
// This option only applies to memtable prefix bloom and plaintable
// prefix bloom. It essentially limits the max number of cache lines each
// bloom filter check can touch.
// This optimization is turned off when set to 0. The number should never
// be greater than number of probes. This option can boost performance
// for in-memory workload but should use with care since it can cause
// higher false positive rate.
// Default: 0
func (opts *Options) SetBloomLocality(value uint32) {
C.rocksdb_options_set_bloom_locality(opts.c, C.uint32_t(value))
}
// SetMaxSuccessiveMerges sets the maximum number of
// successive merge operations on a key in the memtable.
//
// When a merge operation is added to the memtable and the maximum number of
// successive merges is reached, the value of the key will be calculated and
// inserted into the memtable instead of the merge operation. This will
// ensure that there are never more than max_successive_merges merge
// operations in the memtable.
// Default: 0 (disabled)
func (opts *Options) SetMaxSuccessiveMerges(value int) {
C.rocksdb_options_set_max_successive_merges(opts.c, C.size_t(value))
}
// EnableStatistics enable statistics.
func (opts *Options) EnableStatistics() {
C.rocksdb_options_enable_statistics(opts.c)
}
// GetStatisticsString get the dump log of rocksdb.
func (opts *Options) GetStatisticsString() string {
cValue := C.rocksdb_options_statistics_get_string(opts.c)
defer C.free(unsafe.Pointer(cValue))
return C.GoString(cValue)
}
// PrepareForBulkLoad prepare the DB for bulk loading.
//
// All data will be in level 0 without any automatic compaction.
// It's recommended to manually call CompactRange(NULL, NULL) before reading
// from the database, because otherwise the read can be very slow.
func (opts *Options) PrepareForBulkLoad() {
C.rocksdb_options_prepare_for_bulk_load(opts.c)
}
// SetMemtableVectorRep sets a MemTableRep which is backed by a vector.
//
// On iteration, the vector is sorted. This is useful for workloads where
// iteration is very rare and writes are generally not issued after reads begin.
func (opts *Options) SetMemtableVectorRep() {
C.rocksdb_options_set_memtable_vector_rep(opts.c)
}
// SetHashSkipListRep sets a hash skip list as MemTableRep.
//
// It contains a fixed array of buckets, each
// pointing to a skiplist (null if the bucket is empty).
//
// bucketCount: number of fixed array buckets
// skiplistHeight: the max height of the skiplist
// skiplistBranchingFactor: probabilistic size ratio between adjacent
// link lists in the skiplist
func (opts *Options) SetHashSkipListRep(bucketCount int, skiplistHeight, skiplistBranchingFactor int32) {
C.rocksdb_options_set_hash_skip_list_rep(opts.c, C.size_t(bucketCount), C.int32_t(skiplistHeight), C.int32_t(skiplistBranchingFactor))
}
// SetHashLinkListRep sets a hashed linked list as MemTableRep.
//
// It contains a fixed array of buckets, each pointing to a sorted single
// linked list (null if the bucket is empty).
//
// bucketCount: number of fixed array buckets
func (opts *Options) SetHashLinkListRep(bucketCount int) {
C.rocksdb_options_set_hash_link_list_rep(opts.c, C.size_t(bucketCount))
}
// SetPlainTableFactory sets a plain table factory with prefix-only seek.
//
// For this factory, you need to set prefix_extractor properly to make it
// work. Look-up will starts with prefix hash lookup for key prefix. Inside the
// hash bucket found, a binary search is executed for hash conflicts. Finally,
// a linear search is used.
//
// keyLen: plain table has optimization for fix-sized keys,
// which can be specified via keyLen.
// bloomBitsPerKey: the number of bits used for bloom filer per prefix. You
// may disable it by passing a zero.
// hashTableRatio: the desired utilization of the hash table used for prefix
// hashing. hashTableRatio = number of prefixes / #buckets
// in the hash table
// indexSparseness: inside each prefix, need to build one index record for how
// many keys for binary search inside each hash bucket.
func (opts *Options) SetPlainTableFactory(keyLen uint32, bloomBitsPerKey int, hashTableRatio float64, indexSparseness int) {
C.rocksdb_options_set_plain_table_factory(opts.c, C.uint32_t(keyLen), C.int(bloomBitsPerKey), C.double(hashTableRatio), C.size_t(indexSparseness))
}
// SetCreateIfMissingColumnFamilies specifies whether the column families
// should be created if they are missing.
func (opts *Options) SetCreateIfMissingColumnFamilies(value bool) {
C.rocksdb_options_set_create_missing_column_families(opts.c, boolToChar(value))
}
// SetBlockBasedTableFactory sets the block based table factory.
func (opts *Options) SetBlockBasedTableFactory(value *BlockBasedTableOptions) {
opts.bbto = value
C.rocksdb_options_set_block_based_table_factory(opts.c, value.c)
}
// SetAllowIngestBehind sets allow_ingest_behind
// Set this option to true during creation of database if you want
// to be able to ingest behind (call IngestExternalFile() skipping keys
// that already exist, rather than overwriting matching keys).
// Setting this option to true will affect 2 things:
// 1) Disable some internal optimizations around SST file compression
// 2) Reserve bottom-most level for ingested files only.
// 3) Note that num_levels should be >= 3 if this option is turned on.
//
// DEFAULT: false
// Immutable.
func (opts *Options) SetAllowIngestBehind(value bool) {
C.rocksdb_options_set_allow_ingest_behind(opts.c, boolToChar(value))
}
// Destroy deallocates the Options object.
func (opts *Options) Destroy() {
C.rocksdb_options_destroy(opts.c)
if opts.ccmp != nil {
C.rocksdb_comparator_destroy(opts.ccmp)
}
if opts.cst != nil {
C.rocksdb_slicetransform_destroy(opts.cst)
}
if opts.ccf != nil {
C.rocksdb_compactionfilter_destroy(opts.ccf)
}
opts.c = nil
opts.env = nil
opts.bbto = nil
}
| {
return NewNativeOptions(C.rocksdb_options_create())
} |
draw_view3.js | var draw_view3 = {
data: 0,
height: 0,
width: 0,
div: 0,
view: 0,
graph_line_class: 0,
yScale: 0,
xScale: 0,
stroke_color: 0,
name_list: 0,
record_list: 0,
graph_text_class: 0,
initialize: function() {
var self = this;
self.div = "#view3";
self.width = $(self.div).width();
self.height = $(self.div).height();
self.view = d3.select(self.div).append("svg")
.attr("width", self.width) | self.stroke_color = "steelblue";
self.name_list = [];
self.record_list = [];
self.graph_line_class = [];
self.draw();
},
draw: function(data) {
var self = this;
self.yScale = d3.scale.linear()
.domain([0, 10])
.range([0, self.height * 0.7]);
var yAxis = d3.svg.axis()
.scale(self.yScale)
.orient("left")
.ticks(0);
self.yScale.range([self.height * 0.7, 0]);
self.xScale = d3.scale.linear()
.domain([1965, 2018])
.range([0, self.width * 0.8]);
var xAxis = d3.svg.axis()
.scale(self.xScale)
.ticks(10)
var gxAxis = self.view.append("g")
.attr("transform", 'translate(' + (self.width * 0.1) + ',' + (self.height * 0.8) + ')')
.attr("class", "axis");
var gyAxis = self.view.append("g")
.attr("transform", 'translate(' + (self.width * 0.1) + ',' + (self.height * 0.1) + ')')
.attr("class", "axis");
gxAxis.call(xAxis);
gyAxis.call(yAxis);
self.yScale.range([0, self.height * 0.7]);
d3.csv("data/all_data.csv", function(error, data) {
console.log(data[0].履历);
console.log(data);
})
},
get_record: function(name) {
var self = this;
self.name_list.push(name);
self.record_list = new Array(self.name_list.length);
console.log(self.name_list);
d3.csv("data/all_data.csv", function(error, data) {
for (var i = 0; i < data.length; i++) {
if (_.contains(self.name_list, data[i].姓名))
self.record_list[_.indexOf(self.name_list, data[i].姓名)] = data[i].履历;
}
for (var i = 0; i < self.record_list.length; i++) {
self.record_list[i] = self.record_list[i].toString().split('\n');
}
self.draw_line();
self.draw_text();
})
},
draw_text: function() {
var self = this;
self.remove_text();
self.graph_text_class = self.view.append("g")
.attr("id", "view3_text")
.selectAll("text")
.data(self.name_list)
.enter().append("text")
.attr("x", function(d, i) {
return self.width * 0.07;
})
.attr("y", function(d, i) {
return self.height * 0.8 - self.height * 0.7 / (self.name_list.length + 1) * (i + 1);
})
.text(function(d) {
return d
})
},
draw_line: function() {
var self = this;
self.remove_line();
self.graph_line_class = new Array(self.name_list.length);
for (var index = 0; index < self.name_list.length; index++) {
self.graph_line_class[index] = self.view.append("g")
.attr("id", "view3_line" + index)
.attr("stroke-width", 3)
.attr("stroke", self.stroke_color)
.selectAll("line")
.data(self.generate_line_data(index))
.enter().append("line")
.attr("x1", function(d, i) {
return d.x1;
})
.attr("x2", function(d, i) {
return d.x2;
})
.attr("y1", function(d, i) {
return d.y1;
})
.attr("y2", function(d, i) {
return d.y2;
})
}
for (var index = 0; index < self.name_list.length; index++) {
self.graph_line_class[index].attr("opacity", function(d, i) {
return (i % 2 == 1) ? 1 : 0.5;
})
.on("mouseover", function(d, i) {
for (var index = 0; index < location_list.length; index++) {
if (d.content.search(location_list[index]) != -1)
draw_view2.highlight_location(location_list[index], 1);
}
d3.select(this).attr("stroke-width", 4)
.attr("stroke", "red");
tooltip.html(d.content)
.style("left", (d3.event.pageX) + "px")
.style("top", (d3.event.pageY + 20) + "px")
.style("opacity", 1);
})
.on("mouseout", function(d, i) {
d3.select(this).attr("stroke-width", 3)
.attr("stroke", self.stroke_color)
tooltip.style("opacity", 0.0);
})
}
},
generate_line_data: function(index) {
var self = this;
console.log(self.record_list);
function LINE() {}
LINE.prototype.id = 0;
LINE.prototype.x1 = 0;
LINE.prototype.x2 = 0;
LINE.prototype.y1 = 0;
LINE.prototype.y2 = 0;
LINE.prototype.content = 0;
var line_class = new Array(),
tmp;
for (var i = 0; i < self.record_list[index].length; i++) {
tmp = self.record_list[index][i];
tmp = tmp.toString().split('—');
console.log("------------");
console.log(parseInt(tmp[0]));
console.log(parseInt(tmp[1]));
console.log("------------");
if (isNaN(parseInt(tmp[1]))) tmp[1] = 2018;
line_class[i] = new LINE();
line_class[i].id = index;
line_class[i].content = self.record_list[index][i];
line_class[i].x1 = self.width * 0.1 + self.xScale(Math.abs(parseInt(tmp[0])));
line_class[i].x2 = self.width * 0.1 + self.xScale(Math.abs(parseInt(tmp[1])));
line_class[i].y1 = self.height * 0.8 - self.height * 0.7 / (self.record_list.length + 1) * (index + 1);
line_class[i].y2 = self.height * 0.8 - self.height * 0.7 / (self.record_list.length + 1) * (index + 1);
}
return line_class;
},
remove_line: function() {
var self = this;
for (var i = 0; i < self.name_list.length; i++)
self.view.select("#view3_line" + i).remove();
},
remove_text: function() {
var self = this;
self.view.select("#view3_text").remove();
}
} | .attr("height", self.height); |
movements.py | '''
Created on Nov 29, 2020
@author: manik
'''
'''
File with classes and code which control how a particular person
will move and to where
'''
from src.population import Population
import numpy as np
import src.person_properties_util as idx
class Movement():
"""
Class providing abstraction into each movement of the population
"""
def | (self, persons: np.ndarray, size: int, speed: float = 0.1, heading_update_chance: float = 0.02) -> np.ndarray:
"""
Randomly updates/initializes the destination each person is headed to and corresponding speed randomly
Parameters
----------
person : np.ndarray
The NumPy array containing the details of the persons to be updated
size : int
The size of the array of the persons to be updated to
speed : float, optional
Mean of the speed to be generated randomly, by default 0.1
heading_update_chance : float, optional
The odds of updating the destination of each person, by default 0.02
Returns
-------
np.ndarray
The upated NumPy array with updated values
"""
#For updating the x position
#Generate a random array with update chance for each person in the population
update = np.random.random(size=(size,))
#Get the persons in the population who have a lower or equal to chance of getting updated in this epoch
shp = update[update <= heading_update_chance].shape
#Update the position for the direction in which they are heading
persons[:,idx.x_dir][update <= heading_update_chance] = np.random.normal(loc = 0, scale = 1/3, size = shp)
#For updating the y position, do the same
update = np.random.random(size=(size,))
shp = update[update <= heading_update_chance].shape
persons[:,idx.y_dir][update <= heading_update_chance] = np.random.normal(loc = 0, scale = 1/3, size = shp)
#Update the speed by generating a random normal distribution using the argument speed as the parameter
update = np.random.random(size=(size,))
shp = update[update <= heading_update_chance].shape
persons[:,idx.speed][update <= heading_update_chance] = np.random.normal(loc = speed, scale = speed / 3, size = shp)
persons[:,idx.speed] = np.clip(persons[:,idx.speed], a_min=0.0005, a_max=0.01)
#Return the updated array
return persons
def out_of_bounds(self, persons: np.ndarray, xbounds, ybounds):
"""
Check if the individual is heading out of bounds of the specified bounds.
Parameters
----------
person : np.ndarray
The NumPy array containing the details of the individuals
xbounds : list
List containing bounds for X axis.
ybounds : list
List containing bounds for Y axis.
Returns
-------
np.ndarray
The upated NumPy array with updated values
"""
# Store shape of list of people who are heading out of bounds based on X bound [0]
shp = persons[:,4][(persons[:,2] <= xbounds[:,0]) &
(persons[:,4] < 0)].shape
# Update them randomly using a normal distribution
persons[:,4][(persons[:,2] <= xbounds[:,0]) &
(persons[:,4] < 0)] = np.clip(np.random.normal(loc = 0.5,
scale = 0.5/3,
size = shp),
a_min = 0.05, a_max = 1)
# Store shape of list of people who are heading out of bounds based on X bound [1]
shp = persons[:,4][(persons[:,2] >= xbounds[:,1]) &
(persons[:,4] > 0)].shape
# Update them randomly using a normal distribution
persons[:,4][(persons[:,2] >= xbounds[:,1]) &
(persons[:,4] > 0)] = np.clip(-np.random.normal(loc = 0.5,
scale = 0.5/3,
size = shp),
a_min = -1, a_max = -0.05)
# Store shape of list of people who are heading out of bounds based on Y bound [0]
shp = persons[:,5][(persons[:,3] <= ybounds[:,0]) &
(persons[:,5] < 0)].shape
# Update them randomly using a normal distribution
persons[:,5][(persons[:,3] <= ybounds[:,0]) &
(persons[:,5] < 0)] = np.clip(np.random.normal(loc = 0.5,
scale = 0.5/3,
size = shp),
a_min = 0.05, a_max = 1)
# Store shape of list of people who are heading out of bounds based on Y bound [1]
shp = persons[:,5][(persons[:,3] >= ybounds[:,1]) &
(persons[:,5] > 0)].shape
# Update them randomly using a normal distribution
persons[:,5][(persons[:,3] >= ybounds[:,1]) &
(persons[:,5] > 0)] = np.clip(-np.random.normal(loc = 0.5,
scale = 0.5/3,
size = shp),
a_min = -1, a_max = -0.05)
return persons
def update_pop(self, persons):
"""
Update function to move people physically in the graph.
This function adds the X and Y direction value to the current postion of
the individual to move them.
Parameters
----------
person : np.ndarray
The NumPy array containing the details of the persons to be updated
Returns
-------
np.ndarray
The upated NumPy array with updated values
"""
filter = (persons[:, idx.current_state] != 3) & (persons[:, idx.social_distance] == 0)
#x
persons[:,2][filter] = persons[:,2][filter] + (persons[:,4][filter] * persons[:,6][filter])
#y
persons[:,3][filter] = persons[:,3][filter] + (persons [:,5][filter] * persons[:,6][filter])
return persons
| update_persons |
dcel.rs | // Copyright 2017 The Spade Developers.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
/// Handle to a vertex.
///
/// This handle is "fixed", meaning it is intended to be used for
/// mutation (e.g., removing a vertex) or storage (e.g., storing
/// references to vertices for later usage).
pub type FixedVertexHandle = usize;
/// Handle to an edge.
///
/// This handle is "fixed", meaning it is intended to be used
/// for storage. Note that removal operations will invalidate
/// edge handles.
pub type FixedEdgeHandle = usize;
/// Handle to a face.
///
/// This handle is "fixed", meaning it is intended to be used
/// for storage. Note that removal operations will invalidate
/// face handles.
pub type FixedFaceHandle = usize;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct VertexRemovalResult<V> {
pub updated_vertex: Option<FixedVertexHandle>,
pub data: V,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde_serialize", derive(Serialize, Deserialize))]
struct FaceEntry {
adjacent_edge: Option<FixedEdgeHandle>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde_serialize", derive(Serialize, Deserialize))]
struct VertexEntry<V> {
data: V,
out_edge: Option<FixedEdgeHandle>,
}
impl<V> VertexEntry<V> {
fn new(data: V) -> VertexEntry<V> {
VertexEntry {
data,
out_edge: None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde_serialize", derive(Serialize, Deserialize))]
struct HalfEdgeEntry<T> {
next: FixedEdgeHandle,
prev: FixedEdgeHandle,
twin: FixedEdgeHandle,
origin: FixedVertexHandle,
face: FixedFaceHandle,
data: T,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde_serialize", derive(Serialize, Deserialize))]
pub struct DCEL<V, E = ()> {
vertices: Vec<VertexEntry<V>>,
faces: Vec<FaceEntry>,
edges: Vec<HalfEdgeEntry<E>>,
}
impl<V> DCEL<V> {
pub fn new() -> Self {
Self::new_with_edge()
}
}
impl<V, E> DCEL<V, E>
where
E: Default,
{
pub fn new_with_edge() -> Self {
DCEL {
vertices: Vec::new(),
edges: Vec::new(),
faces: vec![FaceEntry {
adjacent_edge: None,
}],
}
}
pub fn num_vertices(&self) -> usize {
self.vertices.len()
}
pub fn num_edges(&self) -> usize {
self.edges.len() / 2
}
pub fn num_faces(&self) -> usize {
self.faces.len()
}
pub fn vertex(&self, handle: FixedVertexHandle) -> VertexHandle<V, E> {
VertexHandle::new(self, handle)
}
pub fn edge(&self, handle: FixedEdgeHandle) -> EdgeHandle<V, E> {
EdgeHandle::new(self, handle)
}
pub fn edge_data(&self, handle: FixedEdgeHandle) -> &E {
&self.edges[handle].data
}
pub fn edge_data_mut(&mut self, handle: FixedEdgeHandle) -> &mut E {
&mut self.edges[handle].data
}
pub fn face(&self, handle: FixedFaceHandle) -> FaceHandle<V, E> {
FaceHandle::new(self, handle)
}
pub fn vertex_mut(&mut self, handle: FixedVertexHandle) -> &mut V {
&mut self.vertices[handle].data
}
pub fn insert_vertex(&mut self, vertex: V) -> FixedVertexHandle {
self.vertices.push(VertexEntry::new(vertex));
self.vertices.len() - 1
}
pub fn get_edge_from_neighbors(
&self,
from: FixedVertexHandle,
to: FixedVertexHandle,
) -> Option<EdgeHandle<V, E>> {
let vertex = self.vertex(from);
for edge in vertex.ccw_out_edges() {
if edge.to().fix() == to {
return Some(edge);
}
}
None
}
pub fn connect_two_isolated_vertices(
&mut self,
v0: FixedVertexHandle,
v1: FixedVertexHandle,
face: FixedFaceHandle,
) -> FixedEdgeHandle {
assert!(self.vertices[v0].out_edge.is_none(), "v0 is not isolated");
assert!(self.vertices[v1].out_edge.is_none(), "v1 is not isolated");
assert!(
self.faces[face].adjacent_edge.is_none(),
"face must not contain any adjacent edges"
);
let edge_index = self.edges.len();
let twin_index = edge_index + 1;
let edge = HalfEdgeEntry {
next: twin_index,
prev: twin_index,
twin: twin_index,
origin: v0,
face,
data: Default::default(),
};
self.edges.push(edge);
let twin = HalfEdgeEntry {
next: edge_index,
prev: edge_index,
twin: edge_index,
origin: v1,
face,
data: Default::default(),
};
self.edges.push(twin);
self.vertices[v0].out_edge = Some(edge_index);
self.vertices[v1].out_edge = Some(twin_index);
self.faces[face].adjacent_edge = Some(edge_index);
edge_index
}
pub fn update_vertex(&mut self, handle: FixedVertexHandle, data: V) {
self.vertices[handle].data = data;
}
pub fn edges(&self) -> EdgesIterator<V, E> {
EdgesIterator::new(&self)
}
pub fn vertices(&self) -> VerticesIterator<V, E> {
VerticesIterator::new(&self)
}
pub fn fixed_vertices(&self) -> FixedVerticesIterator {
0..self.num_vertices()
}
pub fn faces(&self) -> FacesIterator<V, E> {
FacesIterator::new(&self)
}
}
impl<V, E> DCEL<V, E>
where
E: Default + Copy,
{
pub fn connect_edge_to_isolated_vertex(
&mut self,
prev_handle: FixedEdgeHandle,
vertex: FixedVertexHandle,
) -> FixedEdgeHandle {
assert!(
self.vertices[vertex].out_edge.is_none(),
"Given vertex is not isolated"
);
let prev = self.edges[prev_handle];
let edge_index = self.edges.len();
let twin_index = edge_index + 1;
let edge = HalfEdgeEntry {
next: twin_index,
prev: prev_handle,
twin: twin_index,
origin: self.edges[prev.twin].origin,
face: prev.face,
data: Default::default(),
};
self.edges.push(edge);
let twin = HalfEdgeEntry {
next: prev.next,
prev: edge_index,
twin: edge_index,
origin: vertex,
face: prev.face,
data: Default::default(),
};
self.edges.push(twin);
self.edges[prev_handle].next = edge_index;
self.edges[prev.next].prev = twin_index;
self.vertices[vertex].out_edge = Some(twin_index);
edge_index
}
pub fn remove_vertex(
&mut self,
vertex_handle: FixedVertexHandle,
remaining_face: Option<FixedFaceHandle>,
) -> VertexRemovalResult<V> {
while let Some(out_edge) = self.vertices[vertex_handle].out_edge {
self.remove_edge(out_edge, remaining_face);
}
let data = self.vertices.swap_remove(vertex_handle).data;
let updated_vertex = if self.vertices.len() == vertex_handle {
None
} else {
// Update origin of all out edges
let to_update: Vec<_> = self
.vertex(vertex_handle)
.ccw_out_edges()
.map(|e| e.fix())
.collect();
for e in to_update {
self.edges[e].origin = vertex_handle;
}
Some(self.vertices.len())
};
VertexRemovalResult {
updated_vertex,
data,
}
}
pub fn connect_edge_to_edge(
&mut self,
prev_edge_handle: FixedEdgeHandle,
next_edge_handle: FixedEdgeHandle,
) -> FixedEdgeHandle {
let edge_index = self.edges.len();
let twin_index = edge_index + 1;
let next_edge = self.edges[next_edge_handle];
let prev_edge = self.edges[prev_edge_handle];
let edge = HalfEdgeEntry {
next: next_edge_handle,
prev: prev_edge_handle,
twin: twin_index,
origin: self.edges[prev_edge.twin].origin,
face: next_edge.face,
data: Default::default(),
};
self.edges.push(edge);
let twin = HalfEdgeEntry {
next: prev_edge.next,
prev: next_edge.prev,
twin: edge_index,
origin: next_edge.origin,
face: next_edge.face,
data: Default::default(),
};
self.edges.push(twin);
self.edges[next_edge_handle].prev = edge_index;
self.edges[prev_edge_handle].next = edge_index;
self.edges[next_edge.prev].next = twin_index;
self.edges[prev_edge.next].prev = twin_index;
edge_index
}
pub fn split_edge(
&mut self,
edge_handle: FixedEdgeHandle,
split_vertex: FixedVertexHandle,
) -> FixedEdgeHandle {
assert!(
self.vertices[split_vertex].out_edge.is_none(),
"Given vertex must be isolated"
);
let edge = self.edges[edge_handle];
let twin = self.edges[edge.twin];
let is_isolated = edge.next == edge.twin;
let new_edge_index = self.edges.len();
let new_twin_index = new_edge_index + 1;
let (new_edge_next, new_twin_prev) = if is_isolated {
(new_twin_index, new_edge_index)
} else {
(edge.next, twin.prev)
};
let new_edge = HalfEdgeEntry {
next: new_edge_next,
prev: edge_handle,
twin: new_twin_index,
origin: split_vertex,
face: edge.face,
data: Default::default(),
};
let new_twin = HalfEdgeEntry {
next: edge.twin,
prev: new_twin_prev,
twin: new_edge_index,
origin: twin.origin,
face: twin.face,
data: Default::default(),
};
if !is_isolated {
self.edges[edge.next].prev = new_edge_index;
self.edges[twin.prev].next = new_twin_index;
}
self.edges[edge.twin].prev = new_twin_index;
self.edges[edge_handle].next = new_edge_index;
self.edges[edge.twin].origin = split_vertex;
self.vertices[twin.origin].out_edge = Some(new_twin_index);
self.vertices[split_vertex].out_edge = Some(new_edge_index);
self.edges.push(new_edge);
self.edges.push(new_twin);
new_edge_index
}
pub fn remove_edge(
&mut self,
edge_handle: FixedEdgeHandle,
remaining_face: Option<FixedFaceHandle>,
) {
let edge = self.edges[edge_handle];
let twin = self.edges[edge.twin];
self.edges[edge.prev].next = twin.next;
self.edges[twin.next].prev = edge.prev;
self.edges[edge.next].prev = twin.prev;
self.edges[twin.prev].next = edge.next;
let (to_remove, to_keep) = if remaining_face == Some(twin.face) {
(edge, twin)
} else {
(twin, edge)
};
if edge.prev == edge.twin && edge.next == edge.twin {
// We remove an isolated edge
self.faces[to_keep.face].adjacent_edge = None;
} else {
let new_adjacent_edge = if edge.prev != edge.twin {
edge.prev
} else {
edge.next
};
self.faces[to_keep.face].adjacent_edge = Some(new_adjacent_edge);
self.edges[new_adjacent_edge].face = to_keep.face;
}
if edge.prev == edge.twin {
self.vertices[edge.origin].out_edge = None;
} else {
self.vertices[edge.origin].out_edge = Some(twin.next);
}
if edge.next == edge.twin {
self.vertices[twin.origin].out_edge = None;
} else {
self.vertices[twin.origin].out_edge = Some(edge.next);
}
// We must remove the larger index first to prevent the other edge
// from being updated
if edge_handle > edge.twin {
self.swap_out_edge(edge_handle);
self.swap_out_edge(edge.twin);
} else {
self.swap_out_edge(edge.twin);
self.swap_out_edge(edge_handle);
}
if edge.face != twin.face {
let neighs: Vec<_> = self
.face(to_keep.face)
.adjacent_edges()
.map(|e| e.fix())
.collect();
for n in neighs {
self.edges[n].face = to_keep.face
}
self.remove_face(to_remove.face);
}
}
fn remove_face(&mut self, face: FixedFaceHandle) {
self.faces.swap_remove(face);
if self.faces.len() > face {
let neighs: Vec<_> = self.face(face).adjacent_edges().map(|e| e.fix()).collect();
for n in neighs {
self.edges[n].face = face;
}
}
}
fn swap_out_edge(&mut self, edge_handle: FixedEdgeHandle) {
self.edges.swap_remove(edge_handle);
if self.edges.len() > edge_handle {
// Update edge index
let old_handle = self.edges.len();
let edge = self.edges[edge_handle];
self.edges[edge.next].prev = edge_handle;
self.edges[edge.prev].next = edge_handle;
self.edges[edge.twin].twin = edge_handle;
if self.vertices[edge.origin].out_edge == Some(old_handle) {
self.vertices[edge.origin].out_edge = Some(edge_handle);
}
self.faces[edge.face].adjacent_edge = Some(edge_handle);
}
}
pub fn create_face(
&mut self,
prev_edge_handle: FixedEdgeHandle,
next_edge_handle: FixedEdgeHandle,
) -> FixedEdgeHandle {
let edge_index = self.connect_edge_to_edge(prev_edge_handle, next_edge_handle);
let new_face = self.num_faces();
self.faces.push(FaceEntry {
adjacent_edge: Some(edge_index),
});
// Set the face to the left of the new edge
let mut cur_edge = edge_index;
loop {
self.edges[cur_edge].face = new_face;
cur_edge = self.edges[cur_edge].next;
if cur_edge == edge_index {
break;
}
}
let twin = self.edges[edge_index].twin;
self.faces[self.edges[twin].face].adjacent_edge = Some(twin);
edge_index
}
pub fn flip_cw(&mut self, e: FixedEdgeHandle) {
let en = self.edges[e].next;
let ep = self.edges[e].prev;
let t = self.edges[e].twin;
let tn = self.edges[t].next;
let tp = self.edges[t].prev;
self.edges[en].next = e;
self.edges[en].prev = tp;
self.edges[e].next = tp;
self.edges[e].prev = en;
self.edges[tp].next = en;
self.edges[tp].prev = e;
self.edges[tn].next = t;
self.edges[tn].prev = ep;
self.edges[t].next = ep;
self.edges[t].prev = tn;
self.edges[ep].next = tn;
self.edges[ep].prev = t;
self.vertices[self.edges[e].origin].out_edge = Some(tn);
self.vertices[self.edges[t].origin].out_edge = Some(en);
self.edges[e].origin = self.edges[ep].origin;
self.edges[t].origin = self.edges[tp].origin;
self.faces[self.edges[e].face].adjacent_edge = Some(e);
self.faces[self.edges[t].face].adjacent_edge = Some(t);
self.edges[tp].face = self.edges[e].face;
self.edges[ep].face = self.edges[t].face;
}
#[cfg(test)]
pub fn sanity_check(&self) {
for (index, face) in self.faces.iter().enumerate() {
if let Some(adj) = face.adjacent_edge {
assert_eq!(self.edges[adj].face, index);
}
}
for (index, vertex) in self.vertices.iter().enumerate() {
if let Some(out_edge) = vertex.out_edge {
assert_eq!(self.edges[out_edge].origin, index);
}
}
for handle in 0..self.num_edges() {
let edge = self.edge(handle);
assert_eq!(edge, edge.o_next().o_prev());
assert_eq!(edge, edge.o_prev().o_next());
assert_eq!(edge, edge.sym().sym());
}
}
}
impl<V, E> DCEL<V, E>
where
E: ::std::fmt::Debug,
{
#[cfg(test)]
fn print(&self) {
for (index, edge) in self.edges.iter().enumerate() {
println!("edge {}: {:#?}", index, edge);
}
for (index, vertex) in self.vertices.iter().enumerate() {
println!("vertex {}: {:?}", index, vertex.out_edge);
}
for (index, face) in self.faces.iter().enumerate() {
println!("face {}: {:?}", index, face);
}
}
}
/// An iterator that iterates over the edges adjacent to a face.
///
/// The iterator will traverse the edges in oriented order.
/// This order is counterclockwise for right handed coordinate systems
/// or clockwise for left handed systems.
pub struct ONextIterator<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
cur_until: Option<(FixedEdgeHandle, FixedEdgeHandle)>,
}
impl<'a, V, E> ONextIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
fn new_empty(dcel: &'a DCEL<V, E>) -> Self {
ONextIterator {
dcel,
cur_until: None,
}
}
fn new(dcel: &'a DCEL<V, E>, edge: FixedEdgeHandle) -> Self {
let edge = dcel.edge(edge);
ONextIterator {
dcel,
cur_until: Some((edge.fix(), edge.o_prev().fix())),
}
}
}
impl<'a, V, E> Iterator for ONextIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
type Item = EdgeHandle<'a, V, E>;
fn next(&mut self) -> Option<EdgeHandle<'a, V, E>> {
if let Some((cur, until)) = self.cur_until {
let cur_handle = self.dcel.edge(cur);
if cur == until {
self.cur_until = None;
} else {
let new_cur = cur_handle.o_next().fix();
self.cur_until = Some((new_cur, until));
}
Some(cur_handle)
} else {
None
}
}
}
impl<'a, V, E> DoubleEndedIterator for ONextIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
fn next_back(&mut self) -> Option<EdgeHandle<'a, V, E>> {
if let Some((cur, until)) = self.cur_until {
let until_handle = self.dcel.edge(until);
if cur == until {
self.cur_until = None;
} else {
let new_until = until_handle.o_prev().fix();
self.cur_until = Some((cur, new_until));
}
Some(until_handle)
} else {
None
}
}
}
/// An iterator that iterates over the outgoing edges from a vertex.
///
/// The edges will be iterated in counterclockwise order. Note that
/// this assumes that you use a right handed coordinate system,
/// otherwise the sense of orientation is inverted.
pub struct CCWIterator<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
cur_until: Option<(FixedEdgeHandle, FixedEdgeHandle)>,
}
impl<'a, V, E> CCWIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
fn new(dcel: &'a DCEL<V, E>, vertex: FixedVertexHandle) -> Self {
let cur_until = if let Some(edge) = dcel.vertex(vertex).out_edge() {
Some((edge.ccw().fix(), edge.fix()))
} else {
None
};
CCWIterator { dcel, cur_until }
}
fn from_edge(dcel: &'a DCEL<V, E>, edge: FixedEdgeHandle) -> Self {
let edge = dcel.edge(edge);
CCWIterator {
dcel,
cur_until: Some((edge.fix(), edge.cw().fix())),
}
}
}
impl<'a, V, E> Iterator for CCWIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
type Item = EdgeHandle<'a, V, E>;
fn next(&mut self) -> Option<EdgeHandle<'a, V, E>> {
if let Some((cur, until)) = self.cur_until {
let cur_handle = self.dcel.edge(cur);
if cur == until {
self.cur_until = None;
} else {
let new_cur = cur_handle.ccw().fix();
self.cur_until = Some((new_cur, until));
}
Some(cur_handle)
} else {
None
}
}
}
impl<'a, V, E> DoubleEndedIterator for CCWIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
fn next_back(&mut self) -> Option<EdgeHandle<'a, V, E>> {
if let Some((cur, until)) = self.cur_until {
let until_handle = self.dcel.edge(until);
if cur == until {
self.cur_until = None;
} else {
let new_until = until_handle.cw().fix();
self.cur_until = Some((cur, new_until));
}
Some(until_handle)
} else {
None
}
}
}
pub struct FacesIterator<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
current: FixedFaceHandle,
}
impl<'a, V, E> FacesIterator<'a, V, E>
where
V: 'a,
E: 'a,
{
fn new(dcel: &'a DCEL<V, E>) -> Self {
FacesIterator { dcel, current: 0 }
}
}
impl<'a, V, E> Iterator for FacesIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
type Item = FaceHandle<'a, V, E>;
fn next(&mut self) -> Option<FaceHandle<'a, V, E>> {
if self.current < self.dcel.num_faces() {
let result = FaceHandle::new(self.dcel, self.current);
self.current += 1;
Some(result)
} else {
None
}
}
}
type FixedVerticesIterator = ::std::ops::Range<usize>;
pub struct VerticesIterator<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
current: FixedVertexHandle,
}
impl<'a, V, E> VerticesIterator<'a, V, E>
where
V: 'a,
E: 'a,
{
fn new(dcel: &'a DCEL<V, E>) -> Self {
VerticesIterator { dcel, current: 0 }
}
}
impl<'a, V, E> Iterator for VerticesIterator<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
type Item = VertexHandle<'a, V, E>;
fn next(&mut self) -> Option<VertexHandle<'a, V, E>> {
if self.current < self.dcel.num_vertices() {
let result = VertexHandle::new(self.dcel, self.current);
self.current += 1;
Some(result)
} else {
None
}
}
}
pub struct EdgesIterator<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
current: FixedEdgeHandle,
}
impl<'a, V, E> EdgesIterator<'a, V, E>
where
V: 'a,
E: 'a,
{
fn new(dcel: &'a DCEL<V, E>) -> Self {
EdgesIterator { dcel, current: 0 }
}
}
impl<'a, V, E> Iterator for EdgesIterator<'a, V, E>
where
E: Default,
{
type Item = EdgeHandle<'a, V, E>;
fn next(&mut self) -> Option<EdgeHandle<'a, V, E>> {
if let Some(edge) = self.dcel.edges.get(self.current) {
let twin = edge.twin;
self.current += 1;
if self.current - 1 < twin {
Some(EdgeHandle::new(self.dcel, self.current - 1))
} else {
self.next()
}
} else {
None
}
}
}
/// A handle to a directed edge.
///
/// Used to retrieve adjacent vertices and faces.
pub struct EdgeHandle<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
handle: FixedEdgeHandle,
}
/// A handle to a vertex.
///
/// Used to retrieve its outgoing edges.
pub struct VertexHandle<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
handle: FixedVertexHandle,
}
/// A handle to a face.
///
/// Used to retrieve its adjacent edges.
pub struct FaceHandle<'a, V, E = ()>
where
V: 'a,
E: 'a,
{
dcel: &'a DCEL<V, E>,
handle: FixedFaceHandle,
}
impl<'a, V, E> ::std::fmt::Debug for VertexHandle<'a, V, E>
where
V: 'a,
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "VertexHandle({:?})", self.handle)
}
}
impl<'a, V, E> PartialEq for VertexHandle<'a, V, E>
where
V: 'a,
{
fn eq(&self, other: &Self) -> bool {
self.handle == other.handle
}
}
impl<'a, V, E> Copy for VertexHandle<'a, V, E> where V: 'a {}
impl<'a, V, E> VertexHandle<'a, V, E>
where
V: 'a,
E: 'a,
{
fn new(dcel: &'a DCEL<V, E>, handle: FixedVertexHandle) -> Self {
VertexHandle { dcel, handle }
}
}
impl<'a, V, E> VertexHandle<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
/// Returns an outgoing edge.
///
/// If the vertex has multiple outgoing edges, any of them is returned.
pub fn out_edge(&self) -> Option<EdgeHandle<'a, V, E>> {
self.dcel.vertices[self.handle]
.out_edge
.map(|e| self.dcel.edge(e))
}
/// Returns all outgoing edges in counter clockwise order.
///
/// Note that this assumes that you use a right handed coordinate system,
/// otherwise the sense of orientation is inverted.
pub fn ccw_out_edges(&self) -> CCWIterator<'a, V, E> {
CCWIterator::new(self.dcel, self.handle)
}
/// Creates a fixed vertex handle from this dynamic handle.
///
/// # Notes
///
/// Calling `DelaunayTriangulation::insert()` will create vertices in increasing order.
pub fn fix(&self) -> FixedVertexHandle {
self.handle
}
}
impl<'a, V, E> Clone for VertexHandle<'a, V, E>
where
V: 'a,
E: 'a,
{
fn clone(&self) -> Self {
VertexHandle::new(self.dcel, self.handle)
}
}
impl<'a, V, E> ::std::ops::Deref for VertexHandle<'a, V, E> {
type Target = V;
fn deref(&self) -> &V {
&self.dcel.vertices[self.handle].data
}
}
impl<'a, V, E> Copy for EdgeHandle<'a, V, E> where V: 'a {}
impl<'a, V, E> Clone for EdgeHandle<'a, V, E>
where
V: 'a,
{
fn clone(&self) -> Self {
EdgeHandle::new(self.dcel, self.handle)
}
}
impl<'a, V, E> PartialEq for EdgeHandle<'a, V, E>
where
V: 'a,
{
fn eq(&self, other: &Self) -> bool {
self.handle == other.handle
}
}
impl<'a, V, E> ::std::fmt::Debug for EdgeHandle<'a, V, E>
where
V: 'a,
E: Default,
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(
f,
"EdgeHandle - id: {:?} ({:?} -> {:?})",
self.handle,
self.from().fix(),
self.to().fix()
)
}
}
impl<'a, V, E> EdgeHandle<'a, V, E>
where
V: 'a,
E: 'a,
{
fn new(dcel: &'a DCEL<V, E>, handle: FixedEdgeHandle) -> Self {
EdgeHandle { dcel, handle }
}
}
impl<'a, V, E> EdgeHandle<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
/// Creates a fixed edge handle from this dynamic handle.
pub fn fix(&self) -> FixedEdgeHandle {
self.handle
}
/// Returns the edge's source vertex.
pub fn from(&self) -> VertexHandle<'a, V, E> {
let edge = &self.dcel.edges[self.handle];
VertexHandle::new(self.dcel, edge.origin)
}
/// Returns the oriented next edge.
///
/// The oriented next edge shares the same face as this edge.
/// When traversing the face's edges in oriented order,
/// this edge is the predecessor of the oriented next edge.
/// "Oriented" means counterclockwise for right handed
/// coordinate systems.
pub fn o_next(&self) -> EdgeHandle<'a, V, E> {
EdgeHandle::new(self.dcel, self.dcel.edges[self.handle].next)
}
/// Returns the oriented previous edge.
///
/// The oriented previous edge shares the same face as this edge.
/// When traversing the face's edges in oriented order,
/// this edge is the successor of the oriented previous edge.
/// "Oriented" means counterclockwise for right handed
/// coordinate systems.
pub fn o_prev(&self) -> EdgeHandle<'a, V, E> {
EdgeHandle::new(self.dcel, self.dcel.edges[self.handle].prev)
}
/// Returns an iterator over all edges sharing the same face
/// as this edge.
///
/// The face's edges will be traversed in oriented order.
/// This order is counterclockwise for right handed coordinate
/// systems or clockwise for left handed systems.
pub fn o_next_iterator(&self) -> ONextIterator<'a, V, E> {
ONextIterator::new(self.dcel, self.handle)
}
/// Returns the edges destination vertex.
pub fn to(&self) -> VertexHandle<'a, V, E> {
self.sym().from()
}
/// Returns the face located to the left of this edge.
pub fn face(&self) -> FaceHandle<'a, V, E> {
self.dcel.face(self.dcel.edges[self.handle].face)
}
/// Returns this edge's mirror edge.
pub fn sym(&self) -> EdgeHandle<'a, V, E> {
EdgeHandle {
dcel: self.dcel,
handle: self.dcel.edges[self.handle].twin,
}
}
/// Returns the next edge in clockwise direction.
///
/// Note that this assumes that you use a right handed coordinate system,
/// otherwise the sense of orientation is inverted.
pub fn cw(&self) -> EdgeHandle<'a, V, E> {
let twin = self.sym().handle;
EdgeHandle {
dcel: self.dcel,
handle: self.dcel.edges[twin].next,
}
}
/// Returns the next edge in counter clockwise direction.
///
/// Note that this assumes that you use a right handed coordinate system,
/// otherwise the sense of orientation is inverted.
pub fn ccw(&self) -> EdgeHandle<'a, V, E> {
EdgeHandle {
dcel: self.dcel,
handle: self.dcel.edges[self.handle].prev,
}
.sym()
}
/// Returns an iterator over all edges in counter clockwise
/// order.
///
/// Note that this assumes that you use a right handed coordinate system,
/// otherwise the sense of orientation is inverted.
pub fn ccw_iter(&self) -> CCWIterator<'a, V, E> |
}
impl<'a, V, E> Copy for FaceHandle<'a, V, E> where V: 'a {}
impl<'a, V, E> Clone for FaceHandle<'a, V, E>
where
V: 'a,
{
fn clone(&self) -> Self {
FaceHandle::new(self.dcel, self.handle)
}
}
impl<'a, V, E> PartialEq for FaceHandle<'a, V, E>
where
V: 'a,
{
fn eq(&self, other: &Self) -> bool {
self.handle == other.handle
}
}
impl<'a, V, E> ::std::fmt::Debug for FaceHandle<'a, V, E>
where
V: 'a,
{
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "FaceHandle({:?})", self.handle)
}
}
impl<'a, V, E> FaceHandle<'a, V, E>
where
V: 'a,
E: 'a,
{
fn new(dcel: &'a DCEL<V, E>, handle: FixedFaceHandle) -> Self {
FaceHandle { dcel, handle }
}
}
impl<'a, V, E> FaceHandle<'a, V, E>
where
V: 'a,
E: Default + 'a,
{
/// Tries to interpret this face as a triangle, returning its 3 vertices.
///
/// # Notes
///
/// The retuned vertices are in clockwise order. The position of the first one is undefined.
///
/// # Panic
/// This method will panic if the face does not form a triangle, for example if it is called on the [infinite face].
///
/// [infinite face]: struct.DelaunayTriangulation.html#method.infinite_face
pub fn as_triangle(&self) -> [VertexHandle<'a, V, E>; 3] {
let adjacent = self.dcel.faces[self.handle]
.adjacent_edge
.expect("Face has no adjacent edge");
let edge = self.dcel.edge(adjacent);
let prev = edge.o_prev();
debug_assert!(
prev.o_prev() == edge.o_next(),
"Face does not form a triangle"
);
[prev.from(), edge.from(), edge.to()]
}
/// Returns an edge that is adjacent to this face.
///
/// If this face has multiple adjacent edges, any of them is returned.
pub fn adjacent_edge(&self) -> Option<EdgeHandle<'a, V, E>> {
self.dcel.faces[self.handle]
.adjacent_edge
.map(|e| EdgeHandle::new(self.dcel, e))
}
/// Returns an iterator that iterates over all adjacent edges.
///
/// The edges are traversed in oriented order.
/// This order will be counterclockwise for right handed coordinate
/// system or clockwise for left handed systems.
pub fn adjacent_edges(&self) -> ONextIterator<'a, V, E> {
if let Some(adj) = self.dcel.faces[self.handle].adjacent_edge {
ONextIterator::new(self.dcel, adj)
} else {
ONextIterator::new_empty(self.dcel)
}
}
/// Creates a fixed face handle from this dynamic face handle.
pub fn fix(&self) -> FixedFaceHandle {
self.handle
}
}
#[cfg(test)]
mod test {
use super::{HalfEdgeEntry, DCEL};
#[test]
fn test_create_triangle() {
let mut dcel = DCEL::new();
let v0 = dcel.insert_vertex(());
let v1 = dcel.insert_vertex(());
let v2 = dcel.insert_vertex(());
let e01 = dcel.connect_two_isolated_vertices(v0, v1, 0);
let e12 = dcel.connect_edge_to_isolated_vertex(e01, v2);
let e20 = dcel.create_face(e12, e01);
let t01 = dcel.edges[e01].twin;
let t12 = dcel.edges[e12].twin;
let t20 = dcel.edges[e20].twin;
assert_eq!(
dcel.edges[e01],
HalfEdgeEntry {
next: e12,
prev: e20,
twin: t01,
origin: 0,
face: 1,
data: (),
}
);
assert_eq!(
dcel.edges[e12],
HalfEdgeEntry {
next: e20,
prev: e01,
twin: t12,
origin: 1,
face: 1,
data: (),
}
);
assert_eq!(
dcel.edges[e20],
HalfEdgeEntry {
next: e01,
prev: e12,
twin: t20,
origin: 2,
face: 1,
data: (),
}
);
assert_eq!(dcel.edges[t01].face, 0);
assert_eq!(dcel.edges[t12].face, 0);
assert_eq!(dcel.edges[t20].face, 0);
}
#[test]
fn test_flip() {
let mut dcel = DCEL::new();
let v0 = dcel.insert_vertex(());
let v1 = dcel.insert_vertex(());
let v2 = dcel.insert_vertex(());
let v3 = dcel.insert_vertex(());
let e01 = dcel.connect_two_isolated_vertices(v0, v1, 0);
let e12 = dcel.connect_edge_to_isolated_vertex(e01, v2);
let e23 = dcel.connect_edge_to_isolated_vertex(e12, v3);
let e30 = dcel.create_face(e23, e01);
let e_flip = dcel.create_face(e30, e23);
assert_eq!(
dcel.edges[e_flip],
HalfEdgeEntry {
next: e23,
prev: e30,
twin: dcel.edges[e_flip].twin,
origin: 0,
face: 2,
data: (),
}
);
dcel.flip_cw(e_flip);
let twin = dcel.edges[e_flip].twin;
assert_eq!(
dcel.edges[e_flip],
HalfEdgeEntry {
next: e12,
prev: e23,
twin,
origin: 3,
face: 2,
data: (),
}
);
assert_eq!(
dcel.edges[twin],
HalfEdgeEntry {
next: e30,
prev: e01,
twin: e_flip,
origin: 1,
face: 1,
data: (),
}
);
}
#[test]
fn test_split_isolated_edge() {
let mut dcel = DCEL::new();
let v0 = dcel.insert_vertex(());
let v1 = dcel.insert_vertex(());
let edge = dcel.connect_two_isolated_vertices(v0, v1, 0);
let split_vertex = dcel.insert_vertex(());
dcel.split_edge(edge, split_vertex);
dcel.print();
dcel.sanity_check();
}
#[test]
fn test_split_unisolated() {
let mut dcel = DCEL::new();
let v0 = dcel.insert_vertex(());
let v1 = dcel.insert_vertex(());
let v2 = dcel.insert_vertex(());
let v3 = dcel.insert_vertex(());
let e01 = dcel.connect_two_isolated_vertices(v0, v1, 0);
let t01 = dcel.edge(e01).sym().fix();
let e12 = dcel.connect_edge_to_isolated_vertex(e01, v2);
let t12 = dcel.edge(e12).sym().fix();
let e20 = dcel.create_face(e12, e01);
let t20 = dcel.edge(e20).sym().fix();
let e_split = dcel.split_edge(e20, v3);
let t_split = dcel.edge(e_split).sym().fix();
assert_eq!(
dcel.edges[e20],
HalfEdgeEntry {
next: e_split,
prev: e12,
twin: t20,
origin: v2,
face: 1,
data: (),
}
);
assert_eq!(
dcel.edges[e_split],
HalfEdgeEntry {
next: e01,
prev: e20,
twin: t_split,
origin: v3,
face: 1,
data: (),
}
);
assert_eq!(
dcel.edges[t_split],
HalfEdgeEntry {
next: t20,
prev: t01,
origin: v0,
twin: e_split,
face: 0,
data: (),
}
);
assert_eq!(
dcel.edges[t20],
HalfEdgeEntry {
next: t12,
prev: t_split,
origin: v3,
twin: e20,
face: 0,
data: (),
}
);
assert_eq!(dcel.edges[t01].next, t_split);
assert_eq!(dcel.edges[e01].prev, e_split);
assert_eq!(dcel.edges[t12].prev, t20);
assert_eq!(dcel.edges[e12].next, e20);
assert!(
dcel.vertices[v3].out_edge == Some(e_split) || dcel.vertices[v3].out_edge == Some(t20)
);
dcel.sanity_check();
}
#[test]
fn test_split_half_isolated() {
let mut dcel = DCEL::new();
let v0 = dcel.insert_vertex(());
let v1 = dcel.insert_vertex(());
let v2 = dcel.insert_vertex(());
let v_split = dcel.insert_vertex(());
let e1 = dcel.connect_two_isolated_vertices(v0, v1, 0);
let e2 = dcel.connect_edge_to_isolated_vertex(e1, v2);
dcel.split_edge(e2, v_split);
dcel.sanity_check();
}
#[test]
fn test_cw_ccw() {
let mut dcel = DCEL::new();
let v0 = dcel.insert_vertex(());
let v1 = dcel.insert_vertex(());
let v2 = dcel.insert_vertex(());
let v3 = dcel.insert_vertex(());
let e01 = dcel.connect_two_isolated_vertices(v0, v1, 0);
let e12 = dcel.connect_edge_to_isolated_vertex(e01, v2);
let e23 = dcel.connect_edge_to_isolated_vertex(e12, v3);
let e30 = dcel.create_face(e23, e01);
let e02 = dcel.create_face(e30, e23);
let e02 = dcel.edge(e02);
assert_eq!(e02.cw().fix(), e01);
assert_eq!(e02.ccw().fix(), dcel.edges[e30].twin);
}
#[test]
fn pentagon_test() {
let mut dcel = DCEL::new();
let mut v = Vec::new();
for _ in 0..5 {
v.push(dcel.insert_vertex(()));
}
let e01 = dcel.connect_two_isolated_vertices(v[0], v[1], 0);
let e12 = dcel.connect_edge_to_isolated_vertex(e01, v[2]);
let e23 = dcel.connect_edge_to_isolated_vertex(e12, v[3]);
let e34 = dcel.connect_edge_to_isolated_vertex(e23, v[4]);
let e40 = dcel.create_face(e34, e01);
let e02 = dcel.create_face(e40, e23);
let e03 = dcel.create_face(e40, e34);
let entry = dcel.edges[e02];
assert_eq!(entry.next, e23);
assert_eq!(entry.prev, dcel.edges[e03].twin);
assert_eq!(entry.origin, v[0]);
}
#[test]
fn test_ccw_iterator() {
let mut dcel = DCEL::new();
let mut vs = Vec::new();
let central = dcel.insert_vertex(());
assert_eq!(dcel.vertex(central).ccw_out_edges().next(), None);
for _ in 0..5 {
vs.push(dcel.insert_vertex(()));
}
let mut last_edge = dcel.connect_two_isolated_vertices(central, vs[0], 0);
last_edge = dcel.edge(last_edge).sym().fix();
for vertex in &vs[1..] {
last_edge = dcel.connect_edge_to_isolated_vertex(last_edge, *vertex);
last_edge = dcel.edge(last_edge).sym().fix();
}
let out_edge = dcel.vertex(central).out_edge().unwrap();
let mut neighs: Vec<_> = out_edge.ccw_iter().map(|e| e.to().fix()).collect();
assert_eq!(neighs.len(), 5);
for i in 0..5 {
let first = neighs[i];
let second = neighs[(i + 1) % 5];
assert_eq!(first - 1, second % 5);
}
let revs: Vec<_> = out_edge.ccw_iter().rev().map(|e| e.to().fix()).collect();
neighs.reverse();
assert_eq!(neighs, revs);
}
#[test]
fn test_o_next_iterator() {
let mut dcel = DCEL::new();
let mut vs = Vec::new();
for _ in 0..5 {
vs.push(dcel.insert_vertex(()));
}
let mut last_edge = dcel.connect_two_isolated_vertices(vs[0], vs[1], 0);
let mut edges = vec![last_edge];
for vertex in &vs[2..] {
last_edge = dcel.connect_edge_to_isolated_vertex(last_edge, *vertex);
edges.push(last_edge);
}
edges.push(dcel.connect_edge_to_edge(last_edge, vs[0]));
let mut iterated: Vec<_> = dcel
.edge(edges[0])
.o_next_iterator()
.map(|e| e.fix())
.collect();
assert_eq!(iterated, edges);
let rev: Vec<_> = dcel
.edge(edges[0])
.o_next_iterator()
.rev()
.map(|e| e.fix())
.collect();
iterated.reverse();
assert_eq!(iterated, rev);
}
}
| {
CCWIterator::from_edge(self.dcel, self.handle)
} |
lib.rs | /*
Copyright (c) 2020 Todd Stellanova
LICENSE: BSD3 (see LICENSE file)
*/
#![no_std]
#[cfg(feature = "rttdebug")]
use panic_rtt_core::rprintln;
use crate::interface::SensorInterface;
use embedded_hal as hal;
use hal::blocking::delay::DelayMs;
pub mod interface;
/// Errors in this crate
#[derive(Debug)]
pub enum Error<CommE, PinE> {
/// Sensor communication error
Comm(CommE),
/// Pin setting error
Pin(PinE),
/// Sensor reading out of range
OutOfRange,
/// Configuration reads invalid
Configuration,
/// Unrecognized chip ID
UnknownChipId,
}
/// Gain settings ( in LSb/Gauss )
/// One tesla (T) is equal to 104 gauss
#[repr(u8)]
pub enum GainSetting {
///± 0.88 Ga / 0.73 (mGa/LSb)
Gain1370 = 0b00000000,
///± 1.30 Ga / 0.92 (mGa/LSb)
Gain1090 = 0b00100000,
///± 1.90 Ga / 1.22 (mGa/LSb)
Gain0820 = 0b01000000,
///± 2.50 Ga / 1.52 (mGa/LSb)
Gain0660 = 0b01100000,
///± 4.00 Ga / 2.27 (mGa/LSb)
Gain0440 = 0b10000000,
///± 4.70 Ga / 2.56 (mGa/LSb)
Gain0390 = 0b10100000,
///± 5.60 Ga / 3.03 (mGa/LSb)
Gain0330 = 0b11000000,
///± 8.10 Ga / 4.35 (mGa/LSb)
Gain0230 = 0b11100000,
}
/// Output Data Rate settings in Hz
#[repr(u8)]
pub enum OdrSetting {
Odr0_75Hz = 0b000,
Odr1_5Hz = 0b001,
Odr3_0Hz = 0b010,
Odr7_5Hz = 0b011,
Odr15_0Hz = 0b100,
Odr30_0Hz = 0b110,
Odr220_0Hz = 0b111,
}
/// Configuring sample averaging
#[repr(u8)]
pub enum SampleAvgSetting {
AvgSamples1 = 0b00,
AvgSamples2 = 0b01,
AvgSamples4 = 0b10,
/// Average 8 samples
AvgSamples8 = 0b11,
}
/// Measurement mode settings
#[repr(u8)]
pub enum MeasurementModeSetting {
NormalMode = 0b00,
/// Positive bias current
PositiveBias = 0b01,
/// Negative bias current-- unsupported on HMC5883
NegativeBias = 0b10,
/// Temperature sensor only -- unsupported on HMC5883
TemperatureOnly = 0b11,
}
pub struct HMC5983<SI> {
pub(crate) sensor_interface: SI,
/// Buffer for reads and writes to the sensor
block_buf: [u8; BLOCK_BUF_LEN],
}
impl<SI, CommE, PinE> HMC5983<SI>
where
SI: SensorInterface<InterfaceError = crate::Error<CommE, PinE>>,
{
pub fn new_with_interface(sensor_interface: SI) -> Self {
Self {
sensor_interface,
block_buf: [0; BLOCK_BUF_LEN],
}
}
pub fn init(
&mut self,
delay_source: &mut impl DelayMs<u8>,
) -> Result<(), crate::Error<CommE, PinE>> {
self.reset(delay_source)
}
fn reset(
&mut self,
delay_source: &mut impl DelayMs<u8>,
) -> Result<(), crate::Error<CommE, PinE>> {
//wakeup the chip
for reg in 0x00..0x0D {
let _val = self.read_reg(reg)?;
#[cfg(feature = "rttdebug")]
rprintln!("0x{:0x} : {} ", reg, _val);
}
const EXPECTED_PROD_ID_A: u8 = 72; //'H';
const EXPECTED_PROD_ID_B: u8 = 52; //'4';
const EXPECTED_PROD_ID_C: u8 = 51; //'3';
//compare product ID against known product ID
//read the product identifiers
self.sensor_interface
.read_block(REG_ID_A, &mut self.block_buf[..3])?;
if self.block_buf[0] != EXPECTED_PROD_ID_A
|| self.block_buf[1] != EXPECTED_PROD_ID_B
|| self.block_buf[2] != EXPECTED_PROD_ID_C
{
#[cfg(feature = "rttdebug")]
rprintln!(
"bad ID block: {},{},{}",
self.block_buf[0],
self.block_buf[1],
self.block_buf[2]
);
return Err(Error::UnknownChipId);
}
self.set_all_config_a(
MeasurementModeSetting::NormalMode,
OdrSetting::Odr30_0Hz,
SampleAvgSetting::AvgSamples8,
true,
)?;
self.set_gain(GainSetting::Gain0820)?;
// (Continuous-measurement mode)
self.sensor_interface.write_reg(
REG_CONFIG_C,
MeasurementModeSetting::NormalMode as u8,
)?;
delay_source.delay_ms(100);
Ok(())
}
/// Set the mag gain, which determines the range
pub fn set_gain(
&mut self,
gain: GainSetting,
) -> Result<(), crate::Error<CommE, PinE>> {
let gain_val: u8 = gain as u8;
self.sensor_interface.write_reg(REG_CONFIG_B, gain_val)?;
let confirm_val = self.read_reg(REG_CONFIG_B)?;
if confirm_val != gain_val {
#[cfg(feature = "rttdebug")]
rprintln!("gain bad: expected {} got {}", gain_val, confirm_val);
return Err(Error::Configuration);
}
Ok(())
}
/// Set all of the Config A register settings
pub fn set_all_config_a(
&mut self,
mode: MeasurementModeSetting,
odr: OdrSetting,
averaging: SampleAvgSetting,
temp_enabled: bool,
) -> Result<(), crate::Error<CommE, PinE>> {
| / Read a single register
fn read_reg(&mut self, reg: u8) -> Result<u8, crate::Error<CommE, PinE>> {
self.sensor_interface
.read_block(reg, &mut self.block_buf[..1])?;
Ok(self.block_buf[0])
}
/// Verify that a magnetometer reading is within the expected range.
// fn reading_in_range(sample: &[i16; 3]) -> bool {
// /// Maximum Dynamic Range for X and Y axes (micro Teslas)
// const MDR_XY_AXES: i16 = 1600;
// /// Maximum Dynamic Range for Z axis (micro Teslas)
// const MDR_Z_AXIS: i16 = 2500;
// /// Resolution (micro Teslas per LSB)
// const RESO_PER_BIT: f32 = 0.3;
// const MAX_VAL_XY: i16 =
// (((MDR_XY_AXES as f32) / RESO_PER_BIT) as i16) + 1;
// const MAX_VAL_Z: i16 =
// (((MDR_Z_AXIS as f32) / RESO_PER_BIT) as i16) + 1;
//
// sample[0].abs() < MAX_VAL_XY
// && sample[1].abs() < MAX_VAL_XY
// && sample[2].abs() < MAX_VAL_Z
// }
/// Combine high and low bytes of i16 mag value
fn raw_reading_to_i16(buf: &[u8], idx: usize) -> i16 {
let val: i16 = (buf[idx] as i16) | ((buf[idx + 1] as i16) << 8);
val
}
pub fn get_mag_vector(
&mut self,
) -> Result<[i16; 3], crate::Error<CommE, PinE>> {
const XYZ_DATA_LEN: usize = 6;
//get the actual mag data from the sensor
self.sensor_interface.read_block(
REG_MAG_DATA_START,
&mut self.block_buf[..XYZ_DATA_LEN],
)?;
let sample_i16 = [
Self::raw_reading_to_i16(&self.block_buf, 0),
Self::raw_reading_to_i16(&self.block_buf, 2),
Self::raw_reading_to_i16(&self.block_buf, 4),
];
// if !Self::reading_in_range(&sample_i16) {
// #[cfg(feature = "rttdebug")]
// rprintln!("bad reading?");
//
// return Err(Error::OutOfRange);
// }
//TODO do cross-axis flow calibration?
Ok(sample_i16)
}
/// Read temperature from device
/// Result is degrees Celsius
pub fn get_temperature(
&mut self,
) -> Result<i16, crate::Error<CommE, PinE>> {
const TEMP_DATA_LEN: usize = 2;
self.sensor_interface.read_block(
REG_TEMP_OUTPUT_MSB,
&mut self.block_buf[..TEMP_DATA_LEN],
)?;
//TODO datasheet is not clear whether the temp can go negative
// Temperature=(MSB*2^8+LSB)/(2^4*8)+25in C
let celsius = (((self.block_buf[0] as i16) * 256)
+ (self.block_buf[1] as i16))
/ 128
+ 25;
Ok(celsius)
}
}
const REG_CONFIG_A: u8 = 0x00;
const REG_CONFIG_B: u8 = 0x01;
const REG_CONFIG_C: u8 = 0x02;
/// X-axis output value register
const REG_DATA_X: u8 = 0x03;
// Y-axis output value register
// const REG_DATA_Y:u8 = 0x05;
// Z-axis output value register
// const REG_DATA_Z:u8 = 0x07;
// const REG_STATUS:u8 = 0x09;
/// Register to read out all three dimensions of mag data
const REG_MAG_DATA_START: u8 = REG_DATA_X;
/// Identification Register A
const REG_ID_A: u8 = 0x0A;
// Identification Register B
// const REG_ID_B: u8 = 0x0B;
// Identification Register C
// const REG_ID_C: u8 = 0x0C;
/// Temperature outputs, HMC5983
const REG_TEMP_OUTPUT_MSB: u8 = 0x31;
// const REG_TEMP_OUTPUT_LSB: u8 = 0x32;
// Status Register 2
// const REG_STATUS2: u8 = 0x09;
const BLOCK_BUF_LEN: usize = 32;
| let new_val = (if temp_enabled { (1 << 7) } else { 0 })
& ((averaging as u8) << 6)
& ((odr as u8) << 4)
& ((mode as u8) << 2);
self.sensor_interface.write_reg(REG_CONFIG_A, new_val)
}
// |
ShallowWrapper.js | import React from 'react';
import flatten from 'lodash/flatten';
import unique from 'lodash/uniq';
import compact from 'lodash/compact';
import cheerio from 'cheerio';
import {
nodeEqual,
containsChildrenSubArray,
propFromEvent,
withSetStateAllowed,
propsOfNode,
typeOfNode,
} from './Utils';
import {
debugNodes,
} from './Debug';
import {
getTextFromNode,
hasClassName,
childrenOfNode,
parentsOfNode,
treeFilter,
buildPredicate,
} from './ShallowTraversal';
import {
createShallowRenderer,
renderToStaticMarkup,
} from './react-compat';
/**
* Finds all nodes in the current wrapper nodes' render trees that match the provided predicate
* function.
*
* @param {ShallowWrapper} wrapper
* @param {Function} predicate
* @returns {ShallowWrapper}
*/
function findWhereUnwrapped(wrapper, predicate) {
return wrapper.flatMap(n => treeFilter(n.node, predicate));
}
/**
* Returns a new wrapper instance with only the nodes of the current wrapper instance that match
* the provided predicate function.
*
* @param {ShallowWrapper} wrapper
* @param {Function} predicate
* @returns {ShallowWrapper}
*/
function filterWhereUnwrapped(wrapper, predicate) {
return wrapper.wrap(compact(wrapper.nodes.filter(predicate)));
}
/**
* @class ShallowWrapper
*/
export default class ShallowWrapper {
constructor(nodes, root, options = {}) {
if (!root) {
this.root = this;
this.unrendered = nodes;
this.renderer = createShallowRenderer();
this.renderer.render(nodes, options.context);
this.node = this.renderer.getRenderOutput();
this.nodes = [this.node];
this.length = 1;
} else {
this.root = root;
this.unrendered = null;
this.renderer = null;
if (!Array.isArray(nodes)) {
this.node = nodes;
this.nodes = [nodes];
} else {
this.node = nodes[0];
this.nodes = nodes;
}
this.length = this.nodes.length;
}
this.options = options;
}
/**
* Gets the instance of the component being rendered as the root node passed into `shallow()`.
*
* NOTE: can only be called on a wrapper instance that is also the root instance.
*
* Example:
* ```
* const wrapper = shallow(<MyComponent />);
* const inst = wrapper.instance();
* expect(inst).to.be.instanceOf(MyComponent);
* ```
* @returns {ReactComponent}
*/
instance() {
return this.renderer._instance._instance;
}
/**
* Forces a re-render. Useful to run before checking the render output if something external
* may be updating the state of the component somewhere.
*
* NOTE: can only be called on a wrapper instance that is also the root instance.
*
* @returns {ShallowWrapper}
*/
update() {
if (this.root !== this) {
throw new Error('ShallowWrapper::update() can only be called on the root');
}
this.single(() => {
this.node = this.renderer.getRenderOutput();
this.nodes = [this.node];
});
return this;
}
/**
* A method that sets the props of the root component, and re-renders. Useful for when you are
* wanting to test how the component behaves over time with changing props. Calling this, for
* instance, will call the `componentWillReceiveProps` lifecycle method.
*
* Similar to `setState`, this method accepts a props object and will merge it in with the already
* existing props.
*
* NOTE: can only be called on a wrapper instance that is also the root instance.
*
* @param {Object} props object
* @returns {ShallowWrapper}
*/
setProps(props) {
if (this.root !== this) {
throw new Error('ShallowWrapper::setProps() can only be called on the root');
}
this.single(() => {
withSetStateAllowed(() => {
this.unrendered = React.cloneElement(this.unrendered, props);
this.renderer.render(this.unrendered, this.options.context);
this.update();
});
});
return this;
}
/**
* A method to invoke `setState` on the root component instance similar to how you might in the
* definition of the component, and re-renders. This method is useful for testing your component
* in hard to achieve states, however should be used sparingly. If possible, you should utilize
* your component's external API in order to get it into whatever state you want to test, in order
* to be as accurate of a test as possible. This is not always practical, however.
*
* NOTE: can only be called on a wrapper instance that is also the root instance.
*
* @param {Object} state to merge
* @returns {ShallowWrapper}
*/
setState(state) {
if (this.root !== this) {
throw new Error('ShallowWrapper::setState() can only be called on the root');
}
this.single(() => {
withSetStateAllowed(() => {
this.instance().setState(state);
this.update();
});
});
return this;
}
/**
* A method that sets the context of the root component, and re-renders. Useful for when you are
* wanting to test how the component behaves over time with changing contexts.
*
* NOTE: can only be called on a wrapper instance that is also the root instance.
*
* @param {Object} context object
* @returns {ShallowWrapper}
*/
setContext(context) {
if (this.root !== this) {
throw new Error('ShallowWrapper::setContext() can only be called on the root');
}
if (!this.options.context) {
throw new Error(
'ShallowWrapper::setContext() can only be called on a wrapper that was originally passed ' +
'a context option'
);
}
this.renderer.render(this.unrendered, context);
this.update();
return this;
}
/**
* Whether or not a given react element exists in the shallow render tree.
*
* Example:
* ```
* const wrapper = shallow(<MyComponent />);
* expect(wrapper.contains(<div className="foo bar" />)).to.equal(true);
* ```
*
* @param {ReactElement|Array<ReactElement>} nodeOrNodes
* @returns {Boolean}
*/
contains(nodeOrNodes) {
const predicate = Array.isArray(nodeOrNodes)
? other => containsChildrenSubArray(nodeEqual, other, nodeOrNodes)
: other => nodeEqual(nodeOrNodes, other);
return findWhereUnwrapped(this, predicate).length > 0;
}
/**
* Whether or not a given react element exists in the shallow render tree.
*
* Example:
* ```
* const wrapper = shallow(<MyComponent />);
* expect(wrapper.contains(<div className="foo bar" />)).to.equal(true);
* ```
*
* @param {ReactElement} node
* @returns {Boolean}
*/
equals(node) {
return this.single(() => nodeEqual(this.node, node));
}
/**
* Finds every node in the render tree of the current wrapper that matches the provided selector.
*
* @param {String|Function} selector
* @returns {ShallowWrapper}
*/
find(selector) {
const predicate = buildPredicate(selector);
return findWhereUnwrapped(this, predicate);
}
/**
* Returns whether or not current node matches a provided selector.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @param {String|Function} selector
* @returns {boolean}
*/
is(selector) {
const predicate = buildPredicate(selector);
return this.single(predicate);
}
/**
* Returns a new wrapper instance with only the nodes of the current wrapper instance that match
* the provided predicate function. The predicate should receive a wrapped node as its first
* argument.
*
* @param {Function} predicate
* @returns {ShallowWrapper}
*/
filterWhere(predicate) {
return filterWhereUnwrapped(this, n => predicate(this.wrap(n)));
}
/**
* Returns a new wrapper instance with only the nodes of the current wrapper instance that match
* the provided selector.
*
* @param {String|Function} selector
* @returns {ShallowWrapper}
*/
filter(selector) {
const predicate = buildPredicate(selector);
return filterWhereUnwrapped(this, predicate);
}
/**
* Returns a new wrapper instance with only the nodes of the current wrapper that did not match
* the provided selector. Essentially the inverse of `filter`.
*
* @param {String|Function} selector
* @returns {ShallowWrapper}
*/
not(selector) {
const predicate = buildPredicate(selector);
return filterWhereUnwrapped(this, n => !predicate(n));
}
/**
* Returns a string of the rendered text of the current render tree. This function should be
* looked at with skepticism if being used to test what the actual HTML output of the component
* will be. If that is what you would like to test, use enzyme's `render` function instead.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @returns {String}
*/ | text() {
return this.single(getTextFromNode);
}
/**
* Returns the HTML of the node.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @returns {String}
*/
html() {
return this.single(n => this.type() === null ? null : renderToStaticMarkup(n));
}
/**
* Returns the current node rendered to HTML and wrapped in a CheerioWrapper.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @returns {CheerioWrapper}
*/
render() {
return this.type() === null ? cheerio() : cheerio.load(this.html()).root();
}
/**
* A method that unmounts the component. This can be used to simulate a component going through
* and unmount/mount lifecycle.
* @returns {ShallowWrapper}
*/
unmount() {
this.renderer.unmount();
return this;
}
/**
* Used to simulate events. Pass an eventname and (optionally) event arguments. This method of
* testing events should be met with some skepticism.
*
* @param {String} event
* @param {Array} args
* @returns {ShallowWrapper}
*/
simulate(event, ...args) {
const handler = this.prop(propFromEvent(event));
if (handler) {
withSetStateAllowed(() => {
// TODO(lmr): create/use synthetic events
// TODO(lmr): emulate React's event propagation
handler(...args);
this.root.update();
});
}
return this;
}
/**
* Returns the props hash for the root node of the wrapper.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @returns {Object}
*/
props() {
return this.single(propsOfNode);
}
/**
* Returns the state hash for the root node of the wrapper. Optionally pass in a prop name and it
* will return just that value.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @param {String} name (optional)
* @returns {*}
*/
state(name) {
if (this.root !== this) {
throw new Error('ShallowWrapper::state() can only be called on the root');
}
const _state = this.single(() => this.instance().state);
if (name !== undefined) {
return _state[name];
}
return _state;
}
/**
* Returns the context hash for the root node of the wrapper.
* Optionally pass in a prop name and it will return just that value.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @param {String} name (optional)
* @returns {*}
*/
context(name) {
if (this.root !== this) {
throw new Error('ShallowWrapper::context() can only be called on the root');
}
const _context = this.single(() => this.instance().context);
if (name) {
return _context[name];
}
return _context;
}
/**
* Returns a new wrapper with all of the children of the current wrapper.
*
* @param {String|Function} [selector]
* @returns {ShallowWrapper}
*/
children(selector) {
const allChildren = this.flatMap(n => childrenOfNode(n.node));
return selector ? allChildren.filter(selector) : allChildren;
}
/**
* Returns a new wrapper with a specific child
*
* @param {Number} [index]
* @returns {ShallowWrapper}
*/
childAt(index) {
return this.single(() => this.children().at(index));
}
/**
* Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node
* in the current wrapper.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @param {String|Function} [selector]
* @returns {ShallowWrapper}
*/
parents(selector) {
const allParents = this.wrap(this.single(n => parentsOfNode(n, this.root.node)));
return selector ? allParents.filter(selector) : allParents;
}
/**
* Returns a wrapper around the immediate parent of the current node.
*
* @returns {ShallowWrapper}
*/
parent() {
return this.flatMap(n => [n.parents().get(0)]);
}
/**
*
* @param {String|Function} selector
* @returns {ShallowWrapper}
*/
closest(selector) {
return this.is(selector) ? this : this.parents().filter(selector).first();
}
/**
* Shallow renders the current node and returns a shallow wrapper around it.
*
* NOTE: can only be called on wrapper of a single node.
*
* @param options object
* @returns {ShallowWrapper}
*/
shallow(options) {
return this.single((n) => new ShallowWrapper(n, null, options));
}
/**
* Returns the value of prop with the given name of the root node.
*
* @param propName
* @returns {*}
*/
prop(propName) {
return this.props()[propName];
}
/**
* Returns the type of the root ndoe of this wrapper. If it's a composite component, this will be
* the component constructor. If it's native DOM node, it will be a string.
*
* @returns {String|Function}
*/
type() {
return this.single(typeOfNode);
}
/**
* Returns whether or not the current root node has the given class name or not.
*
* NOTE: can only be called on a wrapper of a single node.
*
* @param className
* @returns {Boolean}
*/
hasClass(className) {
if (className && className.indexOf('.') !== -1) {
console.warn(
'It looks like you\'re calling `ShallowWrapper::hasClass()` with a CSS selector. ' +
'hasClass() expects a class name, not a CSS selector.'
);
}
return this.single(n => hasClassName(n, className));
}
/**
* Iterates through each node of the current wrapper and executes the provided function with a
* wrapper around the corresponding node passed in as the first argument.
*
* @param {Function} fn
* @returns {ShallowWrapper}
*/
forEach(fn) {
this.nodes.forEach((n, i) => fn.call(this, this.wrap(n), i));
return this;
}
/**
* Maps the current array of nodes to another array. Each node is passed in as a `ShallowWrapper`
* to the map function.
*
* @param {Function} fn
* @returns {Array}
*/
map(fn) {
return this.nodes.map((n, i) => fn.call(this, this.wrap(n), i));
}
/**
* Reduces the current array of nodes to a value. Each node is passed in as a `ShallowWrapper`
* to the reducer function.
*
* @param {Function} fn - the reducer function
* @param {*} initialValue - the initial value
* @returns {*}
*/
reduce(fn, initialValue) {
return this.nodes.reduce(
(accum, n, i) => fn.call(this, accum, this.wrap(n), i),
initialValue
);
}
/**
* Reduces the current array of nodes to another array, from right to left. Each node is passed
* in as a `ShallowWrapper` to the reducer function.
*
* @param {Function} fn - the reducer function
* @param {*} initialValue - the initial value
* @returns {*}
*/
reduceRight(fn, initialValue) {
return this.nodes.reduceRight(
(accum, n, i) => fn.call(this, accum, this.wrap(n), i),
initialValue
);
}
/**
* Returns whether or not any of the nodes in the wrapper match the provided selector.
*
* @param {Function|String} selector
* @returns {Boolean}
*/
some(selector) {
const predicate = buildPredicate(selector);
return this.nodes.some(predicate);
}
/**
* Returns whether or not any of the nodes in the wrapper pass the provided predicate function.
*
* @param {Function} predicate
* @returns {Boolean}
*/
someWhere(predicate) {
return this.nodes.some((n, i) => predicate.call(this, this.wrap(n), i));
}
/**
* Returns whether or not all of the nodes in the wrapper match the provided selector.
*
* @param {Function|String} selector
* @returns {Boolean}
*/
every(selector) {
const predicate = buildPredicate(selector);
return this.nodes.every(predicate);
}
/**
* Returns whether or not any of the nodes in the wrapper pass the provided predicate function.
*
* @param {Function} predicate
* @returns {Boolean}
*/
everyWhere(predicate) {
return this.nodes.every((n, i) => predicate.call(this, this.wrap(n), i));
}
/**
* Utility method used to create new wrappers with a mapping function that returns an array of
* nodes in response to a single node wrapper. The returned wrapper is a single wrapper around
* all of the mapped nodes flattened (and de-duplicated).
*
* @param {Function} fn
* @returns {ShallowWrapper}
*/
flatMap(fn) {
const nodes = this.nodes.map((n, i) => fn.call(this, this.wrap(n), i));
const flattened = flatten(nodes, true);
const uniques = unique(flattened);
return this.wrap(uniques);
}
/**
* Finds all nodes in the current wrapper nodes' render trees that match the provided predicate
* function. The predicate function will receive the nodes inside a ShallowWrapper as its
* first argument.
*
* @param {Function} predicate
* @returns {ShallowWrapper}
*/
findWhere(predicate) {
return findWhereUnwrapped(this, n => predicate(this.wrap(n)));
}
/**
* Returns the node at a given index of the current wrapper.
*
* @param index
* @returns {ReactElement}
*/
get(index) {
return this.nodes[index];
}
/**
* Returns a wrapper around the node at a given index of the current wrapper.
*
* @param index
* @returns {ShallowWrapper}
*/
at(index) {
return this.wrap(this.nodes[index]);
}
/**
* Returns a wrapper around the first node of the current wrapper.
*
* @returns {ShallowWrapper}
*/
first() {
return this.at(0);
}
/**
* Returns a wrapper around the last node of the current wrapper.
*
* @returns {ShallowWrapper}
*/
last() {
return this.at(this.length - 1);
}
/**
* Returns true if the current wrapper has no nodes. False otherwise.
*
* @returns {boolean}
*/
isEmpty() {
return this.length === 0;
}
/**
* Utility method that throws an error if the current instance has a length other than one.
* This is primarily used to enforce that certain methods are only run on a wrapper when it is
* wrapping a single node.
*
* @param fn
* @returns {*}
*/
single(fn) {
if (this.length !== 1) {
throw new Error(
`This method is only meant to be run on single node. ${this.length} found instead.`
);
}
return fn.call(this, this.node);
}
/**
* Helpful utility method to create a new wrapper with the same root as the current wrapper, with
* any nodes passed in as the first parameter automatically wrapped.
*
* @param node
* @returns {ShallowWrapper}
*/
wrap(node) {
if (node instanceof ShallowWrapper) {
return node;
}
return new ShallowWrapper(node, this.root);
}
/**
* Returns an HTML-like string of the shallow render for debugging purposes.
*
* @returns {String}
*/
debug() {
return debugNodes(this.nodes);
}
} | |
ball_against_ball.rs | use na;
use math::{Scalar, Point, Vect};
use entities::shape::Ball;
/// Distance between balls.
#[inline]
pub fn ball_against_ball<N, P, V>(center1: &P, b1: &Ball<N>, center2: &P, b2: &Ball<N>) -> N
where N: Scalar,
P: Point<N, V>,
V: Vect<N> {
let r1 = b1.radius();
let r2 = b2.radius();
let delta_pos = *center2 - *center1;
let sqdist = na::sqnorm(&delta_pos);
let sum_radius = r1 + r2;
if sqdist <= sum_radius * sum_radius {
na::zero()
}
else {
sqdist.sqrt() - sum_radius | }
} |
|
dashboard.go | /*
Copyright 2017 The Nuclio 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 app
import (
"strings"
"time"
"github.com/nuclio/nuclio/pkg/dashboard"
"github.com/nuclio/nuclio/pkg/dashboard/functiontemplates"
"github.com/nuclio/nuclio/pkg/errors"
"github.com/nuclio/nuclio/pkg/loggersink"
"github.com/nuclio/nuclio/pkg/platform/factory"
"github.com/nuclio/nuclio/pkg/platformconfig"
// load all sinks
_ "github.com/nuclio/nuclio/pkg/sinks"
"github.com/nuclio/nuclio/pkg/version"
"github.com/nuclio/logger"
)
func Run(listenAddress string,
dockerKeyDir string,
defaultRegistryURL string,
defaultRunRegistryURL string,
platformType string,
noPullBaseImages bool,
defaultCredRefreshIntervalString string,
externalIPAddresses string,
defaultNamespace string,
offline bool,
platformConfigurationPath string,
templatesGitRepository string,
templatesGitRef string,
templatesArchiveAddress string,
templatesGitUsername string,
templatesGitPassword string,
templatesGithubAccessToken string,
defaultHTTPIngressHostTemplate string,
platformAuthorizationMode string,
dependantImageRegistryURL string) error {
var functionGitTemplateFetcher *functiontemplates.GitFunctionTemplateFetcher
var functionZipTemplateFetcher *functiontemplates.ZipFunctionTemplateFetcher
// read platform configuration
platformConfiguration, err := readPlatformConfiguration(platformConfigurationPath)
if err != nil {
return errors.Wrap(err, "Failed to read platform configuration")
}
// create a root logger
rootLogger, err := loggersink.CreateSystemLogger("dashboard", platformConfiguration)
if err != nil {
return errors.Wrap(err, "Failed to create logger")
}
// create a platform
platformInstance, err := factory.CreatePlatform(rootLogger, platformType, nil)
if err != nil {
return errors.Wrap(err, "Failed to create platform")
}
// create git fetcher
if templatesGitRepository != "" && templatesGitRef != "" {
rootLogger.DebugWith("Fetching function templates from git repository",
"templatesGitRepository", templatesGitRepository,
"templatesGitRef", templatesGitRef)
// attach credentials if given
templatesGitRepository = attachCredentialsToGitRepository(rootLogger,
templatesGitRepository,
templatesGitUsername,
templatesGitPassword,
templatesGithubAccessToken)
functionGitTemplateFetcher, err = functiontemplates.NewGitFunctionTemplateFetcher(rootLogger,
templatesGitRepository,
templatesGitRef)
if err != nil {
return errors.Wrap(err, "Failed to create git fetcher")
}
} else {
rootLogger.DebugWith("Missing git fetcher configuration, templates from git won't be fetched",
"gitTemplateRepository", templatesGitRepository,
"templatesGitRef", templatesGitRef)
}
// create zip fetcher
if templatesArchiveAddress != "" {
functionZipTemplateFetcher, err = functiontemplates.NewZipFunctionTemplateFetcher(rootLogger,
templatesArchiveAddress)
if err != nil {
return errors.Wrap(err, "Failed to create zip template fetcher")
}
}
// create pre-generated templates fetcher
functionTemplatesGeneratedFetcher, err := functiontemplates.NewGeneratedFunctionTemplateFetcher(rootLogger)
if err != nil {
return errors.Wrap(err, "Failed to create pre-generated fetcher")
}
// make repository for fetchers
functionTemplateFetchers := []functiontemplates.FunctionTemplateFetcher{functionTemplatesGeneratedFetcher}
if functionGitTemplateFetcher != nil {
functionTemplateFetchers = append(functionTemplateFetchers, functionGitTemplateFetcher)
}
if functionZipTemplateFetcher != nil {
functionTemplateFetchers = append(functionTemplateFetchers, functionZipTemplateFetcher)
}
functionTemplatesRepository, err := functiontemplates.NewRepository(rootLogger, functionTemplateFetchers)
if err != nil {
return errors.Wrap(err, "Failed to create repository out of given fetchers")
}
// set external ip addresses based if user passed overriding values or not
var splitExternalIPAddresses []string
if externalIPAddresses == "" {
splitExternalIPAddresses, err = platformInstance.GetDefaultInvokeIPAddresses()
if err != nil {
return errors.Wrap(err, "Failed to get default invoke ip addresses")
}
} else {
// "10.0.0.1,10.0.0.2" -> ["10.0.0.1", "10.0.0.2"]
splitExternalIPAddresses = strings.Split(externalIPAddresses, ",")
}
err = platformInstance.SetExternalIPAddresses(splitExternalIPAddresses)
if err != nil {
return errors.Wrap(err, "Failed to set external ip addresses")
}
if defaultHTTPIngressHostTemplate != "" {
platformInstance.SetDefaultHTTPIngressHostTemplate(defaultHTTPIngressHostTemplate)
}
rootLogger.InfoWith("Starting",
"name", platformInstance.GetName(),
"noPull", noPullBaseImages,
"offline", offline,
"defaultCredRefreshInterval", defaultCredRefreshIntervalString,
"defaultNamespace", defaultNamespace,
"platformConfiguration", platformConfiguration)
// see if the platform has anything to say about the namespace
defaultNamespace = platformInstance.ResolveDefaultNamespace(defaultNamespace)
version.Log(rootLogger)
trueValue := true
// create a web server configuration
webServerConfiguration := &platformconfig.WebServer{
Enabled: &trueValue,
ListenAddress: listenAddress,
}
server, err := dashboard.NewServer(rootLogger,
dockerKeyDir,
defaultRegistryURL,
defaultRunRegistryURL,
platformInstance,
noPullBaseImages,
webServerConfiguration,
getDefaultCredRefreshInterval(rootLogger, defaultCredRefreshIntervalString),
splitExternalIPAddresses,
defaultNamespace,
offline,
functionTemplatesRepository,
platformConfiguration,
defaultHTTPIngressHostTemplate,
platformAuthorizationMode,
dependantImageRegistryURL)
if err != nil {
return errors.Wrap(err, "Failed to create server")
}
err = server.Start()
if err != nil {
return errors.Wrap(err, "Failed to start server")
}
select {}
}
func getDefaultCredRefreshInterval(logger logger.Logger, defaultCredRefreshIntervalString string) *time.Duration {
var defaultCredRefreshInterval time.Duration
defaultInterval := 12 * time.Hour
// if set to "none" - no refresh interval
if defaultCredRefreshIntervalString == "none" {
return nil
}
// if unspecified, default to 12 hours
if defaultCredRefreshIntervalString == "" {
return &defaultInterval
}
// try to parse the refresh interval - if failed
defaultCredRefreshInterval, err := time.ParseDuration(defaultCredRefreshIntervalString)
if err != nil {
logger.WarnWith("Failed to parse default credential refresh interval, defaulting",
"given", defaultCredRefreshIntervalString,
"default", defaultInterval)
return &defaultInterval
}
return &defaultCredRefreshInterval
}
func readPlatformConfiguration(configurationPath string) (*platformconfig.Config, error) {
platformConfigurationReader, err := platformconfig.NewReader()
if err != nil {
return nil, errors.Wrap(err, "Failed to create platform configuration reader")
}
return platformConfigurationReader.ReadFileOrDefault(configurationPath)
}
// create new repo URL with the credentials inside of it (when credentials are passed)
// example: https://github.com/owner/repo.git -> https://<USERNAME>:<PASSWORD>@github.com/owner/repo.git
func attachCredentialsToGitRepository(logger logger.Logger, repo, username, password, accessToken string) string {
if accessToken != "" {
username = accessToken
password = "x-oauth-basic"
} else if username == "" || password == "" {
return repo
}
splitRepo := strings.Split(repo, "//")
if len(splitRepo) != 2 |
return strings.Join([]string{splitRepo[0], "//", username, ":", password, "@", splitRepo[1]}, "")
}
| {
logger.WarnWith("Unknown git repository structure. Skipping credentials attachment", "repo", repo)
return repo
} |
khr_dedicated_allocation.rs | // Copyright (c) 2017, Dennis Hamester <[email protected]>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
//! [`VK_KHR_dedicated_allocation`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VK_KHR_dedicated_allocation)
use core::ptr;
use libc::c_void;
use vk;
pub const VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION: u32 = 3;
pub const VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME: &'static [u8; 28] = b"VK_KHR_dedicated_allocation\x00";
pub const VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME_STR: &'static str = "VK_KHR_dedicated_allocation";
/// See [`VkMemoryDedicatedRequirementsKHR`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryDedicatedRequirementsKHR)
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkMemoryDedicatedRequirementsKHR {
pub sType: vk::VkStructureType,
pub pNext: *mut c_void,
pub prefersDedicatedAllocation: vk::VkBool32,
pub requiresDedicatedAllocation: vk::VkBool32,
}
impl Default for VkMemoryDedicatedRequirementsKHR {
fn | () -> Self {
VkMemoryDedicatedRequirementsKHR {
sType: vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
pNext: ptr::null_mut(),
prefersDedicatedAllocation: Default::default(),
requiresDedicatedAllocation: Default::default(),
}
}
}
/// See [`VkMemoryDedicatedAllocateInfoKHR`](https://www.khronos.org/registry/vulkan/specs/1.0-extensions/html/vkspec.html#VkMemoryDedicatedAllocateInfoKHR)
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VkMemoryDedicatedAllocateInfoKHR {
pub sType: vk::VkStructureType,
pub pNext: *const c_void,
pub image: vk::VkImage,
pub buffer: vk::VkBuffer,
}
impl Default for VkMemoryDedicatedAllocateInfoKHR {
fn default() -> Self {
VkMemoryDedicatedAllocateInfoKHR {
sType: vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
pNext: ptr::null(),
image: Default::default(),
buffer: Default::default(),
}
}
}
| default |
main.rs | use mongodb::bson::{doc, Document, };
#[macro_use]
extern crate rocket;
use rocket::fairing::AdHoc;
use rocket_cors::{AllowedHeaders, AllowedOrigins};
use rocket::http::Method;
use rocket::{get, routes};
mod config;
mod mdb;
mod shared;
mod crypto;
mod user;
#[get("/")]
pub async fn index() -> &'static str {
"C02 Emissions"
}
#[launch]
async fn rocket() -> _ {
println!("Initializing config...");
let config_figment = config::get_figment().expect("Initializing config failed");
let config: config::Config = config_figment.extract().expect("Initializing config failed");
println!("Connecting to database...");
let mongo = mdb::MongoDb::new(&config.db_connection, Some(String::from("MongoDB")), &config.db_name).await.expect("Creating DB pool failed");
mongo.get_con().run_command(doc! { "ping": 1 }, None).await.unwrap();
println!("Connected to mongodb");
let allowed_origins = AllowedOrigins::all();
let cors = rocket_cors::CorsOptions {
allowed_origins,
allowed_methods: vec![
Method::Get,
Method::Post,
Method::Patch,
Method::Put,
Method::Delete,
Method::Head,
Method::Options].into_iter().map(From::from).collect(),
allowed_headers: AllowedHeaders::all(),
allow_credentials: true,
..Default::default()
}
.to_cors().unwrap();
| user::register::register_route,
user::login::login_route
])
.register("/", vec![rocketjson::error::get_catcher()])
.attach(AdHoc::config::<config::Config>())
.attach(cors)
.manage(mongo)
} |
rocket::custom(config_figment)
.mount("/", routes![
index, |
abstract_dataset.py | import abc
from abc import abstractmethod
class Dataset(abc.ABC):
def __init__(
self,
input_params,
with_labels=False,
):
self.batch_size = input_params.batch_size
self.buffer_size = input_params.buffer_size
if with_labels:
self.train_dataset = self.load_data_with_labels()
else:
self.train_dataset = self.load_data()
@abstractmethod
def load_data(self):
raise NotImplementedError
@abstractmethod
def load_data_with_labels(self):
raise NotImplementedError |
def __iter__(self):
return iter(self.train_dataset) |
|
BitcoinTransactionDetail.ts | import BigNumber from 'bignumber.js';
import { Transform, Type } from 'class-transformer';
class | {
@Transform(value => new BigNumber(value), { toClassOnly: true })
value: BigNumber;
addresses: string[];
hex: string;
get address(): string | null {
return this.addresses.length > 0 ? this.addresses[0] : null;
}
}
export class BitcoinTransactionDetail {
txid: string;
confirmations: number;
fees: string;
version: number;
@Transform(value => new BigNumber(value), { toClassOnly: true })
blockHeight: BigNumber;
@Transform(value => new BigNumber(value), { toClassOnly: true })
blockTime: BigNumber;
@Type(() => Output)
vin: Output[];
@Type(() => Output)
vout: Output[];
get from(): string[] {
return BitcoinTransactionDetail.txAddresses(this.vin);
}
get to(): string[] {
return BitcoinTransactionDetail.txAddresses(this.vout);
}
private static txAddresses(array: Output[]): string[] {
return array
.reduce((acc, output) => [...acc, ...output.addresses], [] as string[]) // Flatmap
.reduce((acc, addr) => (acc.indexOf(addr) >= 0 ? [...acc, addr] : acc), [] as string[]); // Unique
}
}
| Output |
mark_fixed.py | # Copyright 2019 Google LLC
#
# 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.
"""Handler for marking a testcase as fixed."""
from flask import request
from handlers import base_handler_flask
from handlers.testcase_detail import show
from libs import handler_flask
from libs import helpers
def mark(testcase):
"""Mark the testcase as fixed."""
testcase.fixed = 'Yes'
testcase.open = False
testcase.put()
helpers.log('Marked testcase %s as fixed' % testcase.key.id(),
helpers.MODIFY_OPERATION)
return testcase
class Handler(base_handler_flask.Handler):
"""Handler that marks a testcase as fixed."""
| def post(self):
"""Mark the testcase as fixed."""
testcase_id = request.get('testcaseId')
testcase = helpers.get_testcase(testcase_id)
mark(testcase)
return self.render_json(show.get_testcase_detail(testcase)) | @handler_flask.post(handler_flask.JSON, handler_flask.JSON)
@handler_flask.require_csrf_token
@handler_flask.check_admin_access |
mod.rs | // Copyright 2020 The Vega Team
//
// 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.
//! Common building blocks that compose runtimes for the Vega blockchain.
//!
//! Each runtime contains specific services that execute transactions, process events,
//! provide user APIs, etc. A unified *dispatcher* redirects all the calls
//! and requests to an appropriate runtime environment. Thus, a blockchain interacts with the
//! dispatcher, and not with specific runtime instances.
//!
//! # Artifacts
//!
//! An artifact creates service instances similar to classes in object-oriented programming.
//! Artifacts reflect the assumption that deploying business logic onto the blockchain
//! may take a long time, may fail, end up with differing results on different nodes, etc.
//! Thus, artifacts decouple the complex *deployment* of the business logic from its instantiation
//! (which we assume is simple / non-fallible).
//!
//! Depending on the runtime, an artifact may have an additional specification required
//! for its deployment; e.g., files to be compiled.
//!
//! Each runtime has its own [artifacts] registry. Users can create services from the stored
//! artifacts. An artifact identifier is required by the runtime to construct service instances.
//! In other words, an artifact identifier is similar to a class name, and a specific
//! service instance - to a class instance. A single artifact may be used to instantiate
//! zero or more services.
//!
//! The format of the artifact ID is uniform across runtimes - it is essentially a string.
//! But the runtime may customize artifact deployment via runtime-specific deployment arguments.
//!
//! # Artifact Lifecycle
//!
//! 1. An artifact is assembled in a way specific to the runtime. For example, an artifact may
//! be compiled from sources and packaged using an automated build system.
//!
//! 2. The artifact with the service is deployed on the blockchain. The decision to deploy the
//! artifact and the deployment spec are usually performed by the blockchain administrators.
//! The corresponding logic is customizable via the [supervisor service](#supervisor-service).
//! What deployment entails depends on the runtime; e.g., the artifact may be downloaded
//! by each Vega node, verified for integrity and then added into the execution environment.
//!
//! 3. For each node, an artifact may be deployed either asynchronously or synchronously, that is
//! in a blocking manner. The supervisor usually first commands a node to deploy the artifact
//! asynchronously via [`Mailbox`], once the decision to start deployment is reached
//! by the blockchain administrators. Asynchronous deployment speed and outcome may differ among
//! nodes.
//!
//! 4. The supervisor translates the local deployment outcomes into a consensus-agreed result.
//! For example, the supervisor may collect confirmations from the validator nodes that have
//! successfully deployed the artifact. Once all the validator nodes have sent
//! their confirmations, the artifact is *committed*. As a part of the service logic,
//! artifact commitment is completely deterministic, agreed via consensus,
//! and occurs at the same blockchain height for all nodes in the network.
//!
//! 5. Once the artifact is committed, every node in the network must have it deployed
//! in order to continue functioning.
//! If a node has not deployed the artifact previously, deployment becomes blocking. The node
//! does not participate in consensus or block processing until the deployment is completed
//! successfully. If the deployment is unsuccessful, the node stops indefinitely.
//! The deployment confirmation mechanics is built into the supervisor. Thus, it is reasonable
//! to assume that a deployment failure at this stage is local to the node and
//! could be fixed by the node admin.
//!
//! # Service Lifecycle
//!
//! 1. Once the artifact is committed, it is possible to instantiate the corresponding service.
//! Each instantiation request contains an ID of the previously deployed artifact,
//! a string instance ID, and instantiation arguments in a binary encoding
//! (by convention, Protobuf). As with the artifacts, the logic that controls instantiation
//! is encapsulated in the supervisor service.
//!
//! 2. During instantiation the service gets a numeric ID, which is used to reference
//! the service in transactions. The runtime can execute initialization logic defined
//! in the service artifact; e.g., the service may store some initial data in the storage,
//! check service dependencies, etc. If the service (or the enclosing runtime) signals that
//! the initialization failed, the service is considered not instantiated.
//!
//! 3. Once the service is instantiated, it can process transactions and interact with the
//! external users in other ways. Different services instantiated from the same artifact
//! are independent and have separate blockchain storages. Users can distinguish services
//! by their IDs; both numeric and string IDs are unique within a blockchain. (Note that
//! the transition to the "active" state is not immediate;
//! see [*Service State Transitions*](#service-state-transitions) section below.)
//!
//! 4. Active service instances can be stopped by a corresponding request to the dispatcher.
//! A stopped service no longer participates in business logic, i.e. it does not process
//! transactions, events, does not interact with the users in any way.
//! Service data becomes unavailable for the other services, but still exists. The service name
//! and identifier remain reserved for the stopped service and can't be used again for
//! adding new services.
//!
//! The dispatcher is responsible for persisting artifacts and services across node restarts.
//!
//! ## Service Hooks
//!
//! Each active service is called before any transactions in the block are processed;
//! we call this `before_transactions` hook. The service may modify the blockchain state in this hook.
//! Likewise, each active service is called after all transactions in the block have been processed
//! (we call this `after_transactions` hook). These calls are quite similar to transactions:
//!
//! - Each call is isolated
//! - Service logic may return an error, meaning that all state changes made within the hook
//! are rolled back
//! - The service may call other services within the hook
//!
//! ## Service State Transitions
//!
//! Transitions between service states (including service creation) occur once the block
//! with the transition is committed; the effect of a transition is not immediate. This means
//! that, for example, an instantiated service cannot process transactions or internal calls
//! in the block with instantiation, but can in the following block. Likewise, the service hooks
//! (`before_transactions` / `after_transactions`) are *not* called in the block with service
//! instantiation.
//!
//! When the service is stopped, the reverse is true:
//!
//! - The service continues processing transactions until the end of the block containing
//! the stop command
//! - The service hooks *are* called for the service in this block
//!
//! # Transaction Lifecycle
//!
//! 1. An Vega client creates a transaction message which includes two parts. The first part is
//! the [`CallInfo`] - information about a method to call. The second part is the
//! serialized method parameters as a payload.
//! The client then signs the message using the Ed25519 signature system.
//!
//! 2. The client transmits the message to one of the Vega nodes in the network.
//!
//! 3. The node verifies correctness of the transaction signature and retransmits it to
//! the other network nodes if it is correct.
//!
//! 4. When the consensus algorithm finds a feasible candidate for the next block
//! of transactions, transactions in this block are passed to the dispatcher for execution.
//!
//! 5. The dispatcher uses a lookup table to find the corresponding [`Runtime`] for each transaction
//! by the [`instance_id`] recorded in the transaction message. If the corresponding runtime exists,
//! the dispatcher passes the transaction into this runtime for immediate [execution].
//!
//! 6. After execution the transaction [execution status] is written into the blockchain.
//!
//! # Data Migration Lifecycle
//!
//! Service data can be migrated to a newer version of the service artifact.
//! See [`migrations` module docs] for details.
//!
//! # Supervisor Service
//!
//! A supervisor service is a service that has additional privileges. This service
//! allows deploying artifacts and instantiating new services after the blockchain is launched
//! and running. Moreover the Supervisor service allows update the configuration or stop the
//! active service instances.
//! Other than that, it looks like an ordinary service.
//!
//! To enable adding new artifacts / services to the blockchain after its start, the supervisor
//! must be one of the builtin service instances.
//!
//! The supervisor service is distinguished by its numerical ID, which must be set
//! to [`SUPERVISOR_INSTANCE_ID`]. Services may assume that transactions originating from
//! the supervisor service are authorized by the blockchain administrators. This can be used
//! in services: if a certain transaction originates from a service with `SUPERVISOR_INSTANCE_ID`,
//! it is authorized by the administrators.
//!
//! [`AnyTx`]: struct.AnyTx.html
//! [`CallInfo`]: struct.CallInfo.html
//! [`instance_id`]: struct.CallInfo.html#structfield.instance_id
//! [`Runtime`]: trait.Runtime.html
//! [execution]: trait.Runtime.html#execute
//! [execution status]: struct.ExecutionStatus.html
//! [artifacts]: struct.ArtifactId.html
//! [`migrations` module docs]: migrations/index.html
//! [`SUPERVISOR_INSTANCE_ID`]: constant.SUPERVISOR_INSTANCE_ID.html
//! [`Mailbox`]: struct.Mailbox.html
//! [`ExecutionError`]: struct.ExecutionError.html
//! [`instance_id`]: struct.CallInfo.html#structfield.method_id
pub(crate) use self::dispatcher::Dispatcher;
pub use self::{
blockchain_data::{BlockchainData, SnapshotExt},
dispatcher::{Action as DispatcherAction, Mailbox, Schema as DispatcherSchema},
error::{
catch_panic, CallSite, CallType, CommonError, CoreError, ErrorKind, ErrorMatch,
ExecutionError, ExecutionFail, ExecutionStatus,
},
execution_context::{ExecutionContext, ExecutionContextUnstable, SupervisorExtensions},
types::{
AnyTx, ArtifactId, ArtifactSpec, ArtifactState, ArtifactStatus, CallInfo, Caller,
CallerAddress, InstanceId, InstanceQuery, InstanceSpec, InstanceState, InstanceStatus,
MethodId,
},
};
// Re-export for serializing `ExecutionError` via `serde`.
#[doc(hidden)]
pub use error::execution_error::ExecutionErrorSerde;
pub mod migrations;
pub mod versioning;
use vega_merkledb::Snapshot;
use futures::Future;
use semver::Version;
use std::fmt;
use self::migrations::{InitMigrationError, MigrationScript};
use crate::blockchain::Blockchain;
mod blockchain_data;
mod dispatcher;
pub(crate) mod error;
mod execution_context;
mod types;
/// Persistent identifier of a supervisor service instance.
///
/// Only a service with this ID can perform actions with the dispatcher.
pub const SUPERVISOR_INSTANCE_ID: InstanceId = 0;
/// List of predefined runtimes.
///
/// This type is not intended to be exhaustively matched. It can be extended in the future
/// without breaking the semver compatibility.
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
#[repr(u32)]
pub enum RuntimeIdentifier {
/// Built-in Rust runtime.
Rust = 0,
/// Vega Java Binding runtime.
Java = 1,
/// Never actually generated.
#[doc(hidden)]
__NonExhaustive,
}
impl From<RuntimeIdentifier> for u32 {
fn from(id: RuntimeIdentifier) -> Self |
}
impl RuntimeIdentifier {
fn transform(id: u32) -> Result<Self, ()> {
match id {
0 => Ok(RuntimeIdentifier::Rust),
1 => Ok(RuntimeIdentifier::Java),
_ => Err(()),
}
}
}
impl fmt::Display for RuntimeIdentifier {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
RuntimeIdentifier::Rust => f.write_str("Rust runtime"),
RuntimeIdentifier::Java => f.write_str("Java runtime"),
RuntimeIdentifier::__NonExhaustive => unreachable!("Never actually generated"),
}
}
}
/// Runtime environment for Vega services.
///
/// You can read more about the life cycle of services and transactions
/// [in the module docs](index.html#service-life-cycle).
///
/// Using this trait, you can extend the Vega blockchain with the services written in
/// different languages.
///
/// # Stability
///
/// This trait is considered unstable; breaking changes may be introduced to it within
/// semantically non-breaking releases. However, it is guaranteed that such changes
/// will require reasonable amount of updates from the `Runtime` implementations.
///
/// # Call Ordering
///
/// Within the lifetime of a `Runtime`, calls to its methods have the following order:
///
/// ```text
/// LIFE ::= initialize (GENESIS | RESUME) BLOCK* shutdown
/// GENESIS ::= (deploy_artifact | initiate_adding_service update_service_status)* after_commit
/// RESUME ::= (deploy_artifact | update_service_status)* on_resume
/// BLOCK* ::= PROPOSAL+ COMMIT
/// PROPOSAL ::= before_transactions* (execute | initiate_adding_service)* after_transactions*
/// COMMIT ::= deploy_artifact* update_service_status* after_commit
/// ```
///
/// The ordering for the "read-only" method `is_artifact_deployed` in relation
/// to the lifecycle above is not specified.
///
/// # Consensus and Local Methods
///
/// The following methods should return the same result if provided arguments are the same for all
/// the nodes in the blockchain network:
///
/// - `before_transactions`
/// - `execute`
/// - `after_transactions`
/// - `initiate_adding_service`
/// - `initiate_resuming_service`
///
/// All these methods should also produce the same changes to the storage via
/// the provided `ExecutionContext`. Discrepancy in node behavior within these methods may lead
/// to a consensus failure.
///
/// Other `Runtime` methods may execute logic specific to the node.
///
/// # Handling Panics
///
/// Panics in the `Runtime` methods are **not** caught. A panic in the runtime method will cause
/// the node termination. To catch panics in the Rust code and convert them to unchecked execution
/// errors, use the [`catch_panic`](fn.catch_panic.html) method.
#[allow(unused_variables)]
pub trait Runtime: Send + fmt::Debug + 'static {
/// Initializes the runtime, providing a `Blockchain` instance for further use.
///
/// Calling this method always takes place before calling any other `Runtime` methods.
/// The `initialize` method is called *exactly once* during the `Runtime` lifetime.
///
/// The default implementation does nothing.
fn initialize(&mut self, blockchain: &Blockchain) {}
/// Notifies the runtime that the dispatcher has completed re-initialization after the
/// node restart. Re-initialization includes restoring the deployed artifacts / started service
/// instances for all the runtimes.
///
/// This method is called *maximum once* during the `Runtime` lifetime. It is called iff
/// the genesis block was already created before the node start (e.g. after node relaunch).
/// The blockchain state will remain the same between the `initialize` and `on_resume` calls.
///
/// The default implementation does nothing.
fn on_resume(&mut self) {}
/// A request to deploy an artifact with the given identifier and an additional deploy
/// specification.
///
/// This method is called *once* for a specific artifact during the `Runtime` lifetime:
///
/// - For newly added artifacts, the method is called as the supervisor service decides to deploy
/// the artifact.
/// - After the node restart, the method is called for all the previously deployed artifacts.
///
/// Core guarantees that there will be no request to deploy an artifact which is already deployed,
/// thus runtime should not report an attempt to do so as `ExecutionError`, but should consider it
/// a bug in core.
// TODO: Elaborate constraints on `Runtime::deploy_artifact` futures (ECR-3840)
fn deploy_artifact(
&mut self,
artifact: ArtifactId,
deploy_spec: Vec<u8>,
) -> Box<dyn Future<Item = (), Error = ExecutionError>>;
/// Returns `true` if the specified artifact is deployed in this runtime.
fn is_artifact_deployed(&self, id: &ArtifactId) -> bool;
/// Runs the constructor of a new service instance with the given specification
/// and initial arguments. The constructor can initialize the storage of the service,
/// check for dependencies, etc.
///
/// The constructor runs *exactly once* during the blockchain lifetime for each successfully
/// initialized service instance. That is to say, the constructor is *not* called on a node
/// restart.
///
/// At the same time, when `initiate_adding_service` is called,
/// there is no guarantee that the service will eventually get to the blockchain via
/// `update_service_status`. The consensus may accept an alternative block proposal, in which
/// the service is not instantiated or instantiated with different parameters.
///
/// The `update_service_status` call always takes place
/// in the closest committed block, i.e., before the nearest `Runtime::after_commit()`.
/// The dispatcher routes transactions and `before_transactions` / `after_transactions`
/// events to the service only after `update_service_status()` is called with the same instance
/// specification.
///
/// The runtime should discard the instantiated service instance after completing this method.
/// Otherwise, if the service is successfully committed in the block, it will duplicate the one
/// instantiated in the runtime. There may be compelling reasons for the runtime to retain
/// the instantiated service. For example, if creating an instance takes very long time.
/// In this case, the "garbage" services may be removed from the runtime in `after_commit`
/// because of the time dependence between `update_service_status` and `after_commit` described above.
///
/// The runtime should commit long-term resources for the service only after the
/// `update_service_status()` call. In other words, the runtime must be sure that the service
/// has been committed to the blockchain.
///
/// # Return Value
///
/// Returning an error is a signal of `Runtime` that the
/// service instantiation has failed. As a rule of a thumb, changes made by the
/// `initiate_adding_service` method will be rolled back after such a signal. The exact logic of
/// the rollback is determined by the supervisor.
///
/// An error is one of the expected / handled outcomes of the service instantiation procedure.
/// Thus, verifying prerequisites
/// for instantiation and reporting corresponding failures should be performed at this stage
/// rather than in `update_service_status`.
///
/// Core guarantees that there will be no request to start a service instance which is already running,
/// thus runtime should not report an attempt to do so as `ExecutionError`, but should consider it
/// a bug in core.
fn initiate_adding_service(
&self,
context: ExecutionContext<'_>,
artifact: &ArtifactId,
parameters: Vec<u8>,
) -> Result<(), ExecutionError>;
/// Resumes previously stopped service instance with the given specification and arguments.
/// As an example, arguments can be used to update the service configuration.
///
/// The dispatcher ensures that a service instance with the given specification has been
/// previously stopped and has the proper artifact version and name.
///
/// This method has the same workflow as [`initiate_adding_service`] method.
/// The main difference is that `initialize_adding_service` should call the service
/// `initialize` method and `initiate_resuming_service` should call the service `resume` method.
///
/// [`initiate_adding_service`]: #tymethod.initiate_adding_service
fn initiate_resuming_service(
&self,
context: ExecutionContext<'_>,
artifact: &ArtifactId,
parameters: Vec<u8>,
) -> Result<(), ExecutionError>;
/// Notifies runtime about changes of the service instance state.
///
/// This method notifies runtime about a specific service instance state changes in the
/// dispatcher. Runtime should perform corresponding actions in according to changes in
/// the service instance state.
///
/// Method is called for a specific service instance during the `Runtime` lifetime in the
/// following cases:
///
/// - For newly added instances, or modified existing this method is called when the fork
/// with the corresponding changes is committed.
/// - After a node restart, the method is called for all existing service instances regardless
/// of their statuses.
///
/// For newly added instances invocation of this method guarantees that
/// `initiate_adding_service()` has been called with the same `spec` already and returned
/// `Ok(())`. The results of the call (i.e., changes to the blockchain state) will be
/// persisted from the call.
///
/// # Arguments
///
/// `snapshot` is a storage snapshot at the latest height when the method is called:
///
/// - Suppose the service is committed during the node operation. Then `snapshot` is taken at the
/// moment the fork applies for which the corresponding `initiate_adding_service`
/// has been performed.
/// - Suppose the service is stopped during the node operation. `Then `snapshot` is taken at
/// the moment the fork applies for which the corresponding request has been performed.
/// - Suppose the service resumes after the node restart. Then `snapshot` is the storage state
/// at the node start.
///
/// For the built-in services, on the first node start `snapshot` will not contain information
/// on the genesis block. Thus, using some core APIs, like requesting the current
/// blockchain height, will result in a panic.
///
/// `status` is the resulting status of the service instance.
///
/// # Return value
///
/// This method does not return a value, meaning that any error occurred during this method execution
/// is considered critical and should lead to the node stopping.
///
/// It is assumed that if `initiate_adding_service` didn't return an error previously,
/// the runtime is able to update service status and within normal conditions no error is
/// expected to happen.
fn update_service_status(
&mut self,
snapshot: &dyn Snapshot,
spec: &InstanceSpec,
status: &InstanceStatus,
);
/// Gets the migration script to migrate the data of the service to the state usable
/// by a newer version of the artifact.
///
/// An implementation of this method should be idempotent, i.e., return the same script or error
/// for the same input.
///
/// # Invariants Ensured by the Caller
///
/// - `new_artifact` is deployed in the runtime
/// - `data_version < new_artifact.version`
///
/// # Return Value
///
/// - An error signals that the runtime does not know how to migrate the service
/// to a newer version.
/// - `Ok(Some(_))` provides a script to execute against service data. After the script
/// is executed, [`data_version`] of the service will be updated to `end_version`
/// from the script. `end_version` does not need to correspond to the version of `new_artifact`,
/// or to a version of an artifact deployed on the blockchain in general.
/// - `Ok(None)` means that the service does not require data migration. `data_version`
/// of the service will be updated to the version of `new_artifact` once the block
/// with the migration command is committed; see [*Service State Transitions*] for details.
///
/// [`data_version`]: struct.InstanceState.html#field.data_version
/// [*Service State Transitions*]: index.html#service-state-transitions
fn migrate(
&self,
new_artifact: &ArtifactId,
data_version: &Version,
) -> Result<Option<MigrationScript>, InitMigrationError>;
/// Dispatches payload to the method of a specific service instance.
///
/// The call is dispatched iff the service is considered active at the moment.
/// See [*Service State Transitions*] for more details.
///
/// # Arguments
///
/// The service instance name and method ID are provided in the `call_info` argument and
/// the interface name is provided as the corresponding field of the `context` argument.
///
/// A blank interface name denotes the "default" interface; it should be supported by all
/// services. The methods of the default interface are defined by the service artifact
/// and thus may have different signatures for different services.
///
/// A non-empty interface name denotes an interface defined externally to the service instance.
/// In this case, the name is a Protobuf flavor of a fully qualified name
/// (e.g., `vega.Configure`). And the method signatures can be inferred from the name
/// using an interface definition.
///
/// **Note**. Support of non-default interfaces is experimental; as such, an IDL for them
/// is not stabilized yet.
///
/// # Return Value
///
/// - If the service does not implement an interface, returns a `NoSuchInterface` error.
/// - If the interface does not have a method, returns a `NoSuchMethod` error.
///
/// An error returned from this method will lead to the rollback of all changes
/// in the fork enclosed in the `context`.
///
/// [*Service State Transitions*]: index.html#service-state-transitions
fn execute(
&self,
context: ExecutionContext<'_>,
method_id: MethodId,
arguments: &[u8],
) -> Result<(), ExecutionError>;
/// Notifies a service stored in the present runtime about the beginning of the block. Allows
/// the service to modify the blockchain state before any transaction in the block is processed.
///
/// `before_transactions` is called for every service active at the beginning of the block
/// exactly once for each block. Services that will be instantiated within the block do **not**
/// receive a call. The method is not called for the genesis block.
///
/// # Return Value
///
/// An error returned from this method will lead to the rollback of all changes
/// in the fork enclosed in the `context`.
fn before_transactions(&self, context: ExecutionContext<'_>) -> Result<(), ExecutionError>;
/// Notifies a service stored in this runtime about the end of the block. Allows the method
/// to modify the blockchain state after all transactions in the block are processed.
///
/// `after_transactions` is called for every service active at the beginning of the block
/// exactly once for each block. Services instantiated within the block do **not** receive a call.
/// Services instantiated within genesis block are activated **immediately** and
/// thus `after_transactions` is invoked for them in the genesis block.
///
/// # Return value
///
/// An error returned from this method will lead to the rollback of all changes
/// in the fork enclosed in the `context`.
fn after_transactions(&self, context: ExecutionContext<'_>) -> Result<(), ExecutionError>;
/// Notifies the runtime about commit of a new block.
///
/// This method is called *after* all `update_service_status` calls related
/// to the same block. The method is called exactly once for each block in the blockchain,
/// including the genesis block.
///
/// A block is not yet persisted when this method is called. The `snapshot` provides an up-to-date
/// block information. It corresponds exactly to the information
/// eventually persisted.
///
/// `mailbox` is used to send async commands to the dispatcher. This mechanism is used, e.g.,
/// by the supervisor service to enqueue artifact deployment. A runtime may ignore `mailbox`
/// if its services (or the runtime itself) do not require privileged access to the dispatcher.
fn after_commit(&mut self, snapshot: &dyn Snapshot, mailbox: &mut Mailbox);
/// Notifies the runtime that it has to shutdown.
///
/// This callback is invoked sequentially for each runtime just before the node shutdown.
/// Thus, the runtimes can stop themselves gracefully.
///
/// Invoking this callback is the last operation for the runtime.
/// This method is a part of shutdown process. Thus, the runtimes can block and perform
/// heavy operations here if needed.
fn shutdown(&mut self) {}
}
impl<T: Runtime> From<T> for Box<dyn Runtime> {
fn from(value: T) -> Self {
Box::new(value)
}
}
/// A subset of [`Runtime`]s with a well-known runtime identifier.
///
/// [`Runtime`]: trait.Runtime.html
pub trait WellKnownRuntime: Runtime {
/// Identifier of the present runtime.
const ID: u32;
}
// TODO: Rethink visibility [ECR-3913]
/// Instance of [`Runtime`] with the corresponding ID.
///
/// [`Runtime`]: trait.Runtime.html
#[derive(Debug)]
pub struct RuntimeInstance {
/// Identifier of the enclosed runtime.
pub id: u32,
/// Enclosed `Runtime` object.
pub instance: Box<dyn Runtime>,
/// No-op field for forward compatibility.
non_exhaustive: (),
}
impl RuntimeInstance {
/// Constructs a new `RuntimeInstance` object.
pub fn new(id: u32, instance: Box<dyn Runtime>) -> Self {
Self {
id,
instance,
non_exhaustive: (),
}
}
}
impl<T: WellKnownRuntime> From<T> for RuntimeInstance {
fn from(runtime: T) -> Self {
RuntimeInstance::new(T::ID, runtime.into())
}
}
/// Instance descriptor contains information to access the running service instance.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct InstanceDescriptor<'a> {
/// A unique numeric ID of the service instance.
/// [Read more.](struct.InstanceSpec.html#structfield.id)
pub id: InstanceId,
/// A unique name of the service instance.
/// [Read more.](struct.InstanceSpec.html#structfield.name)
pub name: &'a str,
/// No-op field for forward compatibility.
non_exhaustive: (),
}
impl<'a> InstanceDescriptor<'a> {
/// Creates a new `InstanceDescriptor` object.
pub fn new(id: InstanceId, name: &'a str) -> Self {
Self {
id,
name,
non_exhaustive: (),
}
}
}
impl fmt::Display for InstanceDescriptor<'_> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "{}:{}", self.id, self.name)
}
}
| {
id as Self
} |
_compat.py | # -*- coding: utf-8 -*-
"""
Salt compatibility code
"""
# pylint: disable=import-error,unused-import,invalid-name,W0231,W0233
# Import python libs
from __future__ import absolute_import, print_function, unicode_literals
import binascii
import logging
import sys
# Import 3rd-party libs
from salt.exceptions import SaltException
from salt.ext.six import binary_type, integer_types, string_types, text_type
from salt.ext.six.moves import StringIO, cStringIO
log = logging.getLogger(__name__)
try:
# Python >2.5
import xml.etree.cElementTree as ElementTree
except Exception: # pylint: disable=broad-except
try:
# Python >2.5
import xml.etree.ElementTree as ElementTree
except Exception: # pylint: disable=broad-except
try:
# normal cElementTree install
import elementtree.cElementTree as ElementTree
except Exception: # pylint: disable=broad-except
try:
# normal ElementTree install
import elementtree.ElementTree as ElementTree
except Exception: # pylint: disable=broad-except
ElementTree = None
# True if we are running on Python 3.
PY3 = sys.version_info.major == 3
if PY3:
import builtins
exceptions = builtins
else:
import exceptions
if ElementTree is not None:
if not hasattr(ElementTree, "ParseError"):
class ParseError(Exception):
"""
older versions of ElementTree do not have ParseError
"""
ElementTree.ParseError = ParseError
def text_(s, encoding="latin-1", errors="strict"):
"""
If ``s`` is an instance of ``binary_type``, return
``s.decode(encoding, errors)``, otherwise return ``s``
"""
return s.decode(encoding, errors) if isinstance(s, binary_type) else s
def bytes_(s, encoding="latin-1", errors="strict"):
"""
If ``s`` is an instance of ``text_type``, return
``s.encode(encoding, errors)``, otherwise return ``s``
"""
return s.encode(encoding, errors) if isinstance(s, text_type) else s
def ascii_native_(s):
"""
Python 3: If ``s`` is an instance of ``text_type``, return
``s.encode('ascii')``, otherwise return ``str(s, 'ascii', 'strict')``
Python 2: If ``s`` is an instance of ``text_type``, return
``s.encode('ascii')``, otherwise return ``str(s)``
"""
if isinstance(s, text_type):
s = s.encode("ascii")
return str(s, "ascii", "strict") if PY3 else s
def native_(s, encoding="latin-1", errors="strict"):
"""
Python 3: If ``s`` is an instance of ``text_type``, return ``s``, otherwise
return ``str(s, encoding, errors)``
Python 2: If ``s`` is an instance of ``text_type``, return
``s.encode(encoding, errors)``, otherwise return ``str(s)``
"""
if PY3:
out = s if isinstance(s, text_type) else str(s, encoding, errors)
else:
out = s.encode(encoding, errors) if isinstance(s, text_type) else str(s)
return out
def string_io(data=None): # cStringIO can't handle unicode
"""
Pass data through to stringIO module and return result
"""
try:
return cStringIO(bytes(data))
except (UnicodeEncodeError, TypeError):
return StringIO(data)
try:
if PY3:
import ipaddress
else:
import salt.ext.ipaddress as ipaddress
except ImportError:
ipaddress = None
class IPv6AddressScoped(ipaddress.IPv6Address):
"""
Represent and manipulate single IPv6 Addresses.
Scope-aware version
"""
def __init__(self, address):
"""
Instantiate a new IPv6 address object. Scope is moved to an attribute 'scope'.
Args:
address: A string or integer representing the IP
Additionally, an integer can be passed, so
IPv6Address('2001:db8::') == IPv6Address(42540766411282592856903984951653826560)
or, more generally
IPv6Address(int(IPv6Address('2001:db8::'))) == IPv6Address('2001:db8::')
Raises:
AddressValueError: If address isn't a valid IPv6 address.
:param address:
"""
# pylint: disable-all
if not hasattr(self, "_is_packed_binary"):
# This method (below) won't be around for some Python 3 versions
# and we need check this differently anyway
self._is_packed_binary = lambda p: isinstance(p, bytes)
# pylint: enable-all
if isinstance(address, string_types) and "%" in address:
buff = address.split("%")
if len(buff) != 2:
raise SaltException('Invalid IPv6 address: "{}"'.format(address))
address, self.__scope = buff
else:
self.__scope = None
if sys.version_info.major == 2:
ipaddress._BaseAddress.__init__(self, address)
ipaddress._BaseV6.__init__(self, address)
else:
# Python 3.4 fix. Versions higher are simply not affected
# https://github.com/python/cpython/blob/3.4/Lib/ipaddress.py#L543-L544
self._version = 6
self._max_prefixlen = ipaddress.IPV6LENGTH
# Efficient constructor from integer.
if isinstance(address, integer_types):
self._check_int_address(address)
self._ip = address
elif self._is_packed_binary(address):
self._check_packed_address(address, 16)
self._ip = int(binascii.hexlify(address), 16)
else:
address = str(address)
if "/" in address:
raise ipaddress.AddressValueError(
"Unexpected '/' in {}".format(address)
)
self._ip = self._ip_int_from_string(address)
def | (self, data):
"""
Check if data is hexadecimal packed
:param data:
:return:
"""
packed = False
if isinstance(data, bytes) and len(data) == 16 and b":" not in data:
try:
packed = bool(int(binascii.hexlify(data), 16))
except (ValueError, TypeError):
pass
return packed
@property
def scope(self):
"""
Return scope of IPv6 address.
:return:
"""
return self.__scope
def __str__(self):
return text_type(
self._string_from_ip_int(self._ip)
+ ("%" + self.scope if self.scope is not None else "")
)
class IPv6InterfaceScoped(ipaddress.IPv6Interface, IPv6AddressScoped):
"""
Update
"""
def __init__(self, address):
if (
PY3
and isinstance(address, (bytes, int))
or not PY3
and isinstance(address, int)
):
IPv6AddressScoped.__init__(self, address)
self.network = ipaddress.IPv6Network(self._ip)
self._prefixlen = self._max_prefixlen
return
addr = ipaddress._split_optional_netmask(address)
IPv6AddressScoped.__init__(self, addr[0])
self.network = ipaddress.IPv6Network(address, strict=False)
self.netmask = self.network.netmask
self._prefixlen = self.network._prefixlen
self.hostmask = self.network.hostmask
if ipaddress:
ipaddress.IPv6Address = IPv6AddressScoped
if sys.version_info.major == 2:
ipaddress.IPv6Interface = IPv6InterfaceScoped
| _is_packed_binary |
index.js | import React from "react";
import ReactDOM from "react-dom";
import App from "./App";
import "./index.css";
ReactDOM.render(
<App />,
document.getElementById("root") // eslint-disable-line no-undef | ); |
|
aws_driver.py | # type: ignore
import json
import uuid
from json import JSONDecodeError
from typing import Tuple, Dict, List
import boto3
from melange.drivers.interfaces import Queue, Topic, MessagingDriver, Message
class AWSDriver(MessagingDriver):
def __init__(self, **kwargs):
super().__init__()
self.max_number_of_messages = kwargs.get("max_number_of_messages", 10)
self.visibility_timeout = kwargs.get("visibility_timeout", 100)
self.wait_time_seconds = kwargs.get("wait_time_seconds", 10)
def declare_topic(self, topic_name) -> Topic:
sns = boto3.resource("sns")
topic = sns.create_topic(Name=topic_name)
return topic
def get_queue(self, queue_name) -> Queue:
sqs_res = boto3.resource("sqs")
return sqs_res.get_queue_by_name(QueueName=queue_name)
def declare_queue(
self,
queue_name: str,
*topics_to_bind: Topic,
dead_letter_queue_name: str = None,
**kwargs
) -> Tuple[Queue, Queue]:
try:
queue = self.get_queue(queue_name)
except Exception:
queue = self._create_queue(queue_name, content_based_deduplication="true")
if topics_to_bind:
statements = []
for topic in topics_to_bind:
statement = {
"Sid": "Sid{}".format(uuid.uuid4()),
"Effect": "Allow",
"Principal": "*",
"Resource": queue.attributes["QueueArn"], |
statements.append(statement)
subscription = topic.subscribe(
Protocol="sqs",
Endpoint=queue.attributes[
"QueueArn"
], # , Attributes={"RawMessageDelivery": "true"}
)
if kwargs.get("filter_events"):
filter_policy = {"event_type": kwargs["filter_events"]}
else:
filter_policy = {}
subscription.set_attributes(
AttributeName="FilterPolicy",
AttributeValue=json.dumps(filter_policy),
)
policy = {
"Version": "2012-10-17",
"Id": "sqspolicy",
"Statement": statements,
}
queue.set_attributes(Attributes={"Policy": json.dumps(policy)})
dead_letter_queue = None
if dead_letter_queue_name:
try:
dead_letter_queue = self.get_queue(dead_letter_queue_name)
except Exception:
dead_letter_queue = self._create_queue(
dead_letter_queue_name, content_based_deduplication="true"
)
redrive_policy = {
"deadLetterTargetArn": dead_letter_queue.attributes["QueueArn"],
"maxReceiveCount": "4",
}
queue.set_attributes(
Attributes={"RedrivePolicy": json.dumps(redrive_policy)}
)
return queue, dead_letter_queue
def _create_queue(self, queue_name: str, **kwargs) -> Queue:
sqs_res = boto3.resource("sqs")
fifo = queue_name.endswith(".fifo")
attributes = {}
if fifo:
attributes["FifoQueue"] = "true"
attributes["ContentBasedDeduplication"] = (
"true" if kwargs.get("content_based_deduplication") else "false"
)
queue = sqs_res.create_queue(QueueName=queue_name, Attributes=attributes)
return queue
def retrieve_messages(self, queue: Queue, attempt_id=None) -> List[Message]:
kwargs = dict(
MaxNumberOfMessages=self.max_number_of_messages,
VisibilityTimeout=self.visibility_timeout,
WaitTimeSeconds=self.wait_time_seconds,
MessageAttributeNames=["All"],
AttributeNames=["All"],
)
if attempt_id:
kwargs["ReceiveRequestAttemptId"] = attempt_id
messages = queue.receive_messages(**kwargs)
# We need to differentiate here whether the message came from SNS or SQS
return [self._construct_message(message) for message in messages]
def queue_publish(
self,
content: str,
queue,
event_type_name: str = None,
message_group_id: str = None,
message_deduplication_id: str = None,
):
kwargs = dict(MessageBody=json.dumps({"Message": content}))
if event_type_name:
kwargs["MessageAttributes"] = {
"event_type": {"DataType": "String", "StringValue": event_type_name}
}
if message_group_id:
kwargs["MessageGroupId"] = message_group_id
if message_deduplication_id:
kwargs["MessageDeduplicationId"] = message_deduplication_id
queue.send_message(**kwargs)
def publish(
self,
content: str,
topic: Topic,
event_type_name: str,
extra_attributes: Dict = None,
):
args = dict(
Message=content,
MessageAttributes={
"event_type": {"DataType": "String", "StringValue": event_type_name}
},
)
if extra_attributes:
if "subject" in extra_attributes:
args["Subject"] = extra_attributes["subject"]
if "message_attributes" in extra_attributes:
args["MessageAttributes"].update(extra_attributes["message_attributes"])
if "message_structure" in extra_attributes:
args["MessageStructure"] = extra_attributes["message_structure"]
response = topic.publish(**args)
if "MessageId" not in response:
raise ConnectionError("Could not send the event to the SNS TOPIC")
def acknowledge(self, message: Message) -> None:
message.metadata.delete()
def close_connection(self) -> None:
pass
def delete_queue(self, queue: Queue) -> None:
queue.delete()
def delete_topic(self, topic: Topic) -> None:
topic.delete()
def _construct_message(self, message) -> Message:
body = message.body
manifest = ""
try:
message_content = json.loads(body)
if "Message" in message_content:
content = message_content["Message"]
# Does the content have more attributes? If so, it is very likely that the message came from a non-raw
# SNS redirection
if "MessageAttributes" in message_content:
manifest = (
message_content["MessageAttributes"]
.get("event_type", {})
.get("Value")
or ""
)
else:
content = message_content
except JSONDecodeError:
content = body
manifest = (
manifest
or message.message_attributes.get("event_type", {}).get("StringValue")
or ""
)
return Message(message.message_id, content, message, manifest) | "Action": "sqs:SendMessage",
"Condition": {"ArnEquals": {"aws:SourceArn": topic.arn}},
} |
express_route_circuit_py3.py | # coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from .resource_py3 import Resource
class ExpressRouteCircuit(Resource):
| """ExpressRouteCircuit resource.
Variables are only populated by the server, and will be ignored when
sending a request.
:param id: Resource ID.
:type id: str
:ivar name: Resource name.
:vartype name: str
:ivar type: Resource type.
:vartype type: str
:param location: Resource location.
:type location: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param sku: The SKU.
:type sku: ~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitSku
:param allow_classic_operations: Allow classic operations
:type allow_classic_operations: bool
:param circuit_provisioning_state: The CircuitProvisioningState state of
the resource.
:type circuit_provisioning_state: str
:param service_provider_provisioning_state: The
ServiceProviderProvisioningState state of the resource. Possible values
are 'NotProvisioned', 'Provisioning', 'Provisioned', and 'Deprovisioning'.
Possible values include: 'NotProvisioned', 'Provisioning', 'Provisioned',
'Deprovisioning'
:type service_provider_provisioning_state: str or
~azure.mgmt.network.v2018_04_01.models.ServiceProviderProvisioningState
:param authorizations: The list of authorizations.
:type authorizations:
list[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitAuthorization]
:param peerings: The list of peerings.
:type peerings:
list[~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitPeering]
:param service_key: The ServiceKey.
:type service_key: str
:param service_provider_notes: The ServiceProviderNotes.
:type service_provider_notes: str
:param service_provider_properties: The ServiceProviderProperties.
:type service_provider_properties:
~azure.mgmt.network.v2018_04_01.models.ExpressRouteCircuitServiceProviderProperties
:param provisioning_state: Gets the provisioning state of the public IP
resource. Possible values are: 'Updating', 'Deleting', and 'Failed'.
:type provisioning_state: str
:param gateway_manager_etag: The GatewayManager Etag.
:type gateway_manager_etag: str
:ivar etag: Gets a unique read-only string that changes whenever the
resource is updated.
:vartype etag: str
"""
_validation = {
'name': {'readonly': True},
'type': {'readonly': True},
'etag': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'sku': {'key': 'sku', 'type': 'ExpressRouteCircuitSku'},
'allow_classic_operations': {'key': 'properties.allowClassicOperations', 'type': 'bool'},
'circuit_provisioning_state': {'key': 'properties.circuitProvisioningState', 'type': 'str'},
'service_provider_provisioning_state': {'key': 'properties.serviceProviderProvisioningState', 'type': 'str'},
'authorizations': {'key': 'properties.authorizations', 'type': '[ExpressRouteCircuitAuthorization]'},
'peerings': {'key': 'properties.peerings', 'type': '[ExpressRouteCircuitPeering]'},
'service_key': {'key': 'properties.serviceKey', 'type': 'str'},
'service_provider_notes': {'key': 'properties.serviceProviderNotes', 'type': 'str'},
'service_provider_properties': {'key': 'properties.serviceProviderProperties', 'type': 'ExpressRouteCircuitServiceProviderProperties'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'gateway_manager_etag': {'key': 'properties.gatewayManagerEtag', 'type': 'str'},
'etag': {'key': 'etag', 'type': 'str'},
}
def __init__(self, *, id: str=None, location: str=None, tags=None, sku=None, allow_classic_operations: bool=None, circuit_provisioning_state: str=None, service_provider_provisioning_state=None, authorizations=None, peerings=None, service_key: str=None, service_provider_notes: str=None, service_provider_properties=None, provisioning_state: str=None, gateway_manager_etag: str=None, **kwargs) -> None:
super(ExpressRouteCircuit, self).__init__(id=id, location=location, tags=tags, **kwargs)
self.sku = sku
self.allow_classic_operations = allow_classic_operations
self.circuit_provisioning_state = circuit_provisioning_state
self.service_provider_provisioning_state = service_provider_provisioning_state
self.authorizations = authorizations
self.peerings = peerings
self.service_key = service_key
self.service_provider_notes = service_provider_notes
self.service_provider_properties = service_provider_properties
self.provisioning_state = provisioning_state
self.gateway_manager_etag = gateway_manager_etag
self.etag = None |
|
backfill_job.py | # -*- coding: utf-8 -*-
#
# 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.
#
import time
from collections import OrderedDict
from datetime import datetime
from sqlalchemy.orm.session import Session, make_transient
from airflow import executors, models
from airflow.exceptions import (
AirflowException, DagConcurrencyLimitReached, NoAvailablePoolSlot, PoolNotFound,
TaskConcurrencyLimitReached,
)
from airflow.jobs.base_job import BaseJob
from airflow.models import DAG, DagPickle, DagRun
from airflow.ti_deps.dep_context import BACKFILL_QUEUED_DEPS, DepContext
from airflow.utils import timezone
from airflow.utils.configuration import tmp_configuration_copy
from airflow.utils.db import provide_session
from airflow.utils.state import State
class BackfillJob(BaseJob):
"""
A backfill job consists of a dag or subdag for a specific time range. It
triggers a set of task instance runs, in the right order and lasts for
as long as it takes for the set of task instance to be completed.
"""
ID_PREFIX = 'backfill_'
ID_FORMAT_PREFIX = ID_PREFIX + '{0}'
STATES_COUNT_AS_RUNNING = (State.RUNNING, State.QUEUED)
__mapper_args__ = {
'polymorphic_identity': 'BackfillJob'
}
class _DagRunTaskStatus:
"""
Internal status of the backfill job. This class is intended to be instantiated
only within a BackfillJob instance and will track the execution of tasks,
e.g. running, skipped, succeeded, failed, etc. Information about the dag runs
related to the backfill job are also being tracked in this structure,
.e.g finished runs, etc. Any other status related information related to the
execution of dag runs / tasks can be included in this structure since it makes
it easier to pass it around.
"""
# TODO(edgarRd): AIRFLOW-1444: Add consistency check on counts
def __init__(self,
to_run=None,
running=None,
skipped=None,
succeeded=None,
failed=None,
not_ready=None,
deadlocked=None,
active_runs=None,
executed_dag_run_dates=None,
finished_runs=0,
total_runs=0,
):
"""
:param to_run: Tasks to run in the backfill
:type to_run: dict[tuple[string, string, datetime.datetime], airflow.models.TaskInstance]
:param running: Maps running task instance key to task instance object
:type running: dict[tuple[string, string, datetime.datetime], airflow.models.TaskInstance]
:param skipped: Tasks that have been skipped
:type skipped: set[tuple[string, string, datetime.datetime]]
:param succeeded: Tasks that have succeeded so far
:type succeeded: set[tuple[string, string, datetime.datetime]]
:param failed: Tasks that have failed
:type failed: set[tuple[string, string, datetime.datetime]]
:param not_ready: Tasks not ready for execution
:type not_ready: set[tuple[string, string, datetime.datetime]]
:param deadlocked: Deadlocked tasks
:type deadlocked: set[tuple[string, string, datetime.datetime]]
:param active_runs: Active dag runs at a certain point in time
:type active_runs: list[DagRun]
:param executed_dag_run_dates: Datetime objects for the executed dag runs
:type executed_dag_run_dates: set[datetime.datetime]
:param finished_runs: Number of finished runs so far
:type finished_runs: int
:param total_runs: Number of total dag runs able to run
:type total_runs: int
"""
self.to_run = to_run or OrderedDict()
self.running = running or dict()
self.skipped = skipped or set()
self.succeeded = succeeded or set()
self.failed = failed or set()
self.not_ready = not_ready or set()
self.deadlocked = deadlocked or set()
self.active_runs = active_runs or list()
self.executed_dag_run_dates = executed_dag_run_dates or set()
self.finished_runs = finished_runs
self.total_runs = total_runs
def __init__(
self,
dag,
start_date=None,
end_date=None,
mark_success=False,
donot_pickle=False,
ignore_first_depends_on_past=False,
ignore_task_deps=False,
pool=None,
delay_on_limit_secs=1.0,
verbose=False,
conf=None,
rerun_failed_tasks=False,
run_backwards=False,
*args, **kwargs):
"""
:param dag: DAG object.
:type dag: airflow.models.DAG
:param start_date: start date for the backfill date range.
:type start_date: datetime.datetime
:param end_date: end date for the backfill date range.
:type end_date: datetime.datetime
:param mark_success: flag whether to mark the task auto success.
:type mark_success: bool
:param donot_pickle: whether pickle
:type donot_pickle: bool
:param ignore_first_depends_on_past: whether to ignore depend on past
:type ignore_first_depends_on_past: bool
:param ignore_task_deps: whether to ignore the task dependency
:type ignore_task_deps: bool
:param pool: pool to backfill
:type pool: str
:param delay_on_limit_secs:
:param verbose:
:type verbose: flag to whether display verbose message to backfill console
:param conf: a dictionary which user could pass k-v pairs for backfill
:type conf: dictionary
:param rerun_failed_tasks: flag to whether to
auto rerun the failed task in backfill
:type rerun_failed_tasks: bool
:param run_backwards: Whether to process the dates from most to least recent
:type run_backwards bool
:param args:
:param kwargs:
"""
self.dag = dag
self.dag_id = dag.dag_id
self.bf_start_date = start_date
self.bf_end_date = end_date
self.mark_success = mark_success
self.donot_pickle = donot_pickle
self.ignore_first_depends_on_past = ignore_first_depends_on_past
self.ignore_task_deps = ignore_task_deps
self.pool = pool
self.delay_on_limit_secs = delay_on_limit_secs
self.verbose = verbose
self.conf = conf
self.rerun_failed_tasks = rerun_failed_tasks
self.run_backwards = run_backwards
super().__init__(*args, **kwargs)
def _update_counters(self, ti_status):
"""
Updates the counters per state of the tasks that were running. Can re-add
to tasks to run in case required.
:param ti_status: the internal status of the backfill job tasks
:type ti_status: BackfillJob._DagRunTaskStatus
"""
for key, ti in list(ti_status.running.items()):
ti.refresh_from_db()
if ti.state == State.SUCCESS:
ti_status.succeeded.add(key)
self.log.debug("Task instance %s succeeded. Don't rerun.", ti)
ti_status.running.pop(key)
continue
elif ti.state == State.SKIPPED:
ti_status.skipped.add(key)
self.log.debug("Task instance %s skipped. Don't rerun.", ti)
ti_status.running.pop(key)
continue
elif ti.state == State.FAILED:
self.log.error("Task instance %s failed", ti)
ti_status.failed.add(key)
ti_status.running.pop(key)
continue
# special case: if the task needs to run again put it back
elif ti.state == State.UP_FOR_RETRY:
self.log.warning("Task instance %s is up for retry", ti)
ti_status.running.pop(key)
ti_status.to_run[key] = ti
# special case: if the task needs to be rescheduled put it back
elif ti.state == State.UP_FOR_RESCHEDULE:
self.log.warning("Task instance %s is up for reschedule", ti)
ti_status.running.pop(key)
ti_status.to_run[key] = ti
# special case: The state of the task can be set to NONE by the task itself
# when it reaches concurrency limits. It could also happen when the state
# is changed externally, e.g. by clearing tasks from the ui. We need to cover
# for that as otherwise those tasks would fall outside of the scope of
# the backfill suddenly.
elif ti.state == State.NONE:
self.log.warning(
"FIXME: task instance %s state was set to none externally or "
"reaching concurrency limits. Re-adding task to queue.",
ti
)
ti.set_state(State.SCHEDULED)
ti_status.running.pop(key)
ti_status.to_run[key] = ti
def _manage_executor_state(self, running):
"""
Checks if the executor agrees with the state of task instances
that are running
:param running: dict of key, task to verify
"""
executor = self.executor
for key, state in list(executor.get_event_buffer().items()):
if key not in running:
self.log.warning(
"%s state %s not in running=%s",
key, state, running.values()
)
continue
ti = running[key]
ti.refresh_from_db()
self.log.debug("Executor state: %s task %s", state, ti)
if state == State.FAILED or state == State.SUCCESS:
if ti.state == State.RUNNING or ti.state == State.QUEUED:
msg = ("Executor reports task instance {} finished ({}) "
"although the task says its {}. Was the task "
"killed externally?".format(ti, state, ti.state))
self.log.error(msg)
ti.handle_failure(msg)
@provide_session
def _get_dag_run(self, run_date: datetime, dag: DAG, session: Session = None):
"""
Returns a dag run for the given run date, which will be matched to an existing
dag run if available or create a new dag run otherwise. If the max_active_runs
limit is reached, this function will return None.
:param run_date: the execution date for the dag run
:param dag: DAG
:param session: the database session object
:return: a DagRun in state RUNNING or None
"""
run_id = BackfillJob.ID_FORMAT_PREFIX.format(run_date.isoformat())
# consider max_active_runs but ignore when running subdags
respect_dag_max_active_limit = (True
if (dag.schedule_interval and
not dag.is_subdag)
else False)
current_active_dag_count = dag.get_num_active_runs(external_trigger=False)
# check if we are scheduling on top of a already existing dag_run
# we could find a "scheduled" run instead of a "backfill"
run = DagRun.find(dag_id=dag.dag_id,
execution_date=run_date,
session=session)
if run is not None and len(run) > 0:
run = run[0]
if run.state == State.RUNNING:
respect_dag_max_active_limit = False
else:
run = None
# enforce max_active_runs limit for dag, special cases already
# handled by respect_dag_max_active_limit
if (respect_dag_max_active_limit and
current_active_dag_count >= dag.max_active_runs):
return None
run = run or dag.create_dagrun(
run_id=run_id,
execution_date=run_date,
start_date=timezone.utcnow(),
state=State.RUNNING,
external_trigger=False,
session=session,
conf=self.conf,
)
# set required transient field
run.dag = dag
# explicitly mark as backfill and running
run.state = State.RUNNING
run.run_id = run_id
run.verify_integrity(session=session)
return run
@provide_session
def _task_instances_for_dag_run(self, dag_run, session=None):
"""
Returns a map of task instance key to task instance object for the tasks to
run in the given dag run.
:param dag_run: the dag run to get the tasks from
:type dag_run: airflow.models.DagRun
:param session: the database session object
:type session: sqlalchemy.orm.session.Session
"""
tasks_to_run = {}
if dag_run is None:
return tasks_to_run
# check if we have orphaned tasks
self.reset_state_for_orphaned_tasks(filter_by_dag_run=dag_run, session=session)
# for some reason if we don't refresh the reference to run is lost
dag_run.refresh_from_db()
make_transient(dag_run)
try:
for ti in dag_run.get_task_instances():
# all tasks part of the backfill are scheduled to run
if ti.state == State.NONE:
ti.set_state(State.SCHEDULED, session=session, commit=False)
if ti.state != State.REMOVED:
tasks_to_run[ti.key] = ti
session.commit()
except Exception:
session.rollback()
raise
return tasks_to_run
def _log_progress(self, ti_status):
self.log.info(
'[backfill progress] | finished run %s of %s | tasks waiting: %s | succeeded: %s | '
'running: %s | failed: %s | skipped: %s | deadlocked: %s | not ready: %s',
ti_status.finished_runs, ti_status.total_runs, len(ti_status.to_run), len(ti_status.succeeded),
len(ti_status.running), len(ti_status.failed), len(ti_status.skipped), len(ti_status.deadlocked),
len(ti_status.not_ready)
)
self.log.debug(
"Finished dag run loop iteration. Remaining tasks %s",
ti_status.to_run.values()
)
@provide_session
def _process_backfill_task_instances(self,
ti_status,
executor,
pickle_id,
start_date=None, session=None):
"""
Process a set of task instances from a set of dag runs. Special handling is done
to account for different task instance states that could be present when running
them in a backfill process.
:param ti_status: the internal status of the job
:type ti_status: BackfillJob._DagRunTaskStatus
:param executor: the executor to run the task instances
:type executor: BaseExecutor
:param pickle_id: the pickle_id if dag is pickled, None otherwise
:type pickle_id: int
:param start_date: the start date of the backfill job
:type start_date: datetime.datetime
:param session: the current session object
:type session: sqlalchemy.orm.session.Session
:return: the list of execution_dates for the finished dag runs
:rtype: list
"""
executed_run_dates = []
while ((len(ti_status.to_run) > 0 or len(ti_status.running) > 0) and
len(ti_status.deadlocked) == 0):
self.log.debug("*** Clearing out not_ready list ***")
ti_status.not_ready.clear()
# we need to execute the tasks bottom to top
# or leaf to root, as otherwise tasks might be
# determined deadlocked while they are actually
# waiting for their upstream to finish
@provide_session
def _per_task_process(task, key, ti, session=None):
ti.refresh_from_db()
task = self.dag.get_task(ti.task_id, include_subdags=True)
ti.task = task
ignore_depends_on_past = (
self.ignore_first_depends_on_past and
ti.execution_date == (start_date or ti.start_date))
self.log.debug(
"Task instance to run %s state %s", ti, ti.state)
# The task was already marked successful or skipped by a
# different Job. Don't rerun it.
if ti.state == State.SUCCESS:
ti_status.succeeded.add(key)
self.log.debug("Task instance %s succeeded. Don't rerun.", ti)
ti_status.to_run.pop(key)
if key in ti_status.running:
ti_status.running.pop(key)
return
elif ti.state == State.SKIPPED:
ti_status.skipped.add(key)
self.log.debug("Task instance %s skipped. Don't rerun.", ti)
ti_status.to_run.pop(key)
if key in ti_status.running:
ti_status.running.pop(key)
return
# guard against externally modified tasks instances or
# in case max concurrency has been reached at task runtime
elif ti.state == State.NONE:
self.log.warning(
"FIXME: task instance {} state was set to None "
"externally. This should not happen"
)
ti.set_state(State.SCHEDULED, session=session)
if self.rerun_failed_tasks:
# Rerun failed tasks or upstreamed failed tasks
if ti.state in (State.FAILED, State.UPSTREAM_FAILED):
self.log.error("Task instance {ti} "
"with state {state}".format(ti=ti,
state=ti.state))
if key in ti_status.running:
ti_status.running.pop(key)
# Reset the failed task in backfill to scheduled state
ti.set_state(State.SCHEDULED, session=session)
else:
# Default behaviour which works for subdag.
if ti.state in (State.FAILED, State.UPSTREAM_FAILED):
self.log.error("Task instance {ti} "
"with {state} state".format(ti=ti,
state=ti.state))
ti_status.failed.add(key)
ti_status.to_run.pop(key)
if key in ti_status.running:
ti_status.running.pop(key)
return
backfill_context = DepContext(
deps=BACKFILL_QUEUED_DEPS,
ignore_depends_on_past=ignore_depends_on_past,
ignore_task_deps=self.ignore_task_deps,
flag_upstream_failed=True)
ti.refresh_from_db(lock_for_update=True, session=session)
# Is the task runnable? -- then run it
# the dependency checker can change states of tis
if ti.are_dependencies_met(
dep_context=backfill_context,
session=session,
verbose=self.verbose):
if executor.has_task(ti):
self.log.debug(
"Task Instance %s already in executor "
"waiting for queue to clear",
ti
)
else:
self.log.debug('Sending %s to executor', ti)
# Skip scheduled state, we are executing immediately
ti.state = State.QUEUED
ti.queued_dttm = timezone.utcnow() if not ti.queued_dttm else ti.queued_dttm
session.merge(ti)
cfg_path = None
if executor.__class__ in (executors.LocalExecutor,
executors.SequentialExecutor):
cfg_path = tmp_configuration_copy()
executor.queue_task_instance(
ti,
mark_success=self.mark_success,
pickle_id=pickle_id,
ignore_task_deps=self.ignore_task_deps,
ignore_depends_on_past=ignore_depends_on_past,
pool=self.pool,
cfg_path=cfg_path)
ti_status.running[key] = ti
ti_status.to_run.pop(key)
session.commit()
return
if ti.state == State.UPSTREAM_FAILED:
self.log.error("Task instance %s upstream failed", ti)
ti_status.failed.add(key)
ti_status.to_run.pop(key)
if key in ti_status.running:
ti_status.running.pop(key)
return
# special case
if ti.state == State.UP_FOR_RETRY:
self.log.debug(
"Task instance %s retry period not "
"expired yet", ti)
if key in ti_status.running:
ti_status.running.pop(key)
ti_status.to_run[key] = ti
return
# special case
if ti.state == State.UP_FOR_RESCHEDULE:
self.log.debug(
"Task instance %s reschedule period not "
"expired yet", ti)
if key in ti_status.running:
ti_status.running.pop(key)
ti_status.to_run[key] = ti
return
# all remaining tasks
self.log.debug('Adding %s to not_ready', ti)
ti_status.not_ready.add(key)
try:
for task in self.dag.topological_sort(include_subdag_tasks=True):
for key, ti in list(ti_status.to_run.items()):
if task.task_id != ti.task_id:
continue
pool = session.query(models.Pool) \
.filter(models.Pool.pool == task.pool) \
.first()
if not pool:
raise PoolNotFound('Unknown pool: {}'.format(task.pool))
open_slots = pool.open_slots(session=session)
if open_slots <= 0:
raise NoAvailablePoolSlot(
"Not scheduling since there are "
"%s open slots in pool %s".format(
open_slots, task.pool))
num_running_task_instances_in_dag = DAG.get_num_task_instances(
self.dag_id,
states=self.STATES_COUNT_AS_RUNNING,
)
if num_running_task_instances_in_dag >= self.dag.concurrency:
raise DagConcurrencyLimitReached(
"Not scheduling since DAG concurrency limit "
"is reached."
)
if task.task_concurrency:
num_running_task_instances_in_task = DAG.get_num_task_instances(
dag_id=self.dag_id,
task_ids=[task.task_id],
states=self.STATES_COUNT_AS_RUNNING,
)
if num_running_task_instances_in_task >= task.task_concurrency:
raise TaskConcurrencyLimitReached(
"Not scheduling since Task concurrency limit "
"is reached."
)
_per_task_process(task, key, ti)
except (NoAvailablePoolSlot, DagConcurrencyLimitReached, TaskConcurrencyLimitReached) as e:
self.log.debug(e)
# execute the tasks in the queue
self.heartbeat()
executor.heartbeat()
# If the set of tasks that aren't ready ever equals the set of
# tasks to run and there are no running tasks then the backfill
# is deadlocked
if (ti_status.not_ready and
ti_status.not_ready == set(ti_status.to_run) and
len(ti_status.running) == 0):
self.log.warning(
"Deadlock discovered for ti_status.to_run=%s",
ti_status.to_run.values()
)
ti_status.deadlocked.update(ti_status.to_run.values())
ti_status.to_run.clear()
# check executor state
self._manage_executor_state(ti_status.running)
# update the task counters
self._update_counters(ti_status=ti_status)
# update dag run state
_dag_runs = ti_status.active_runs[:]
for run in _dag_runs:
run.update_state(session=session)
if run.state in State.finished():
ti_status.finished_runs += 1
ti_status.active_runs.remove(run)
executed_run_dates.append(run.execution_date)
self._log_progress(ti_status)
# return updated status
return executed_run_dates
@provide_session
def _collect_errors(self, ti_status, session=None):
err = ''
if ti_status.failed:
err += (
"---------------------------------------------------\n"
"Some task instances failed:\n{}\n".format(ti_status.failed))
if ti_status.deadlocked:
err += (
'---------------------------------------------------\n'
'BackfillJob is deadlocked.')
deadlocked_depends_on_past = any(
t.are_dependencies_met(
dep_context=DepContext(ignore_depends_on_past=False),
session=session,
verbose=self.verbose) !=
t.are_dependencies_met(
dep_context=DepContext(ignore_depends_on_past=True),
session=session,
verbose=self.verbose)
for t in ti_status.deadlocked)
if deadlocked_depends_on_past:
err += (
'Some of the deadlocked tasks were unable to run because '
'of "depends_on_past" relationships. Try running the '
'backfill with the option '
'"ignore_first_depends_on_past=True" or passing "-I" at '
'the command line.')
err += ' These tasks have succeeded:\n{}\n'.format(ti_status.succeeded)
err += ' These tasks are running:\n{}\n'.format(ti_status.running)
err += ' These tasks have failed:\n{}\n'.format(ti_status.failed)
err += ' These tasks are skipped:\n{}\n'.format(ti_status.skipped)
err += ' These tasks are deadlocked:\n{}\n'.format(ti_status.deadlocked)
return err
@provide_session
def _execute_for_run_dates(self, run_dates, ti_status, executor, pickle_id,
start_date, session=None):
"""
Computes the dag runs and their respective task instances for
the given run dates and executes the task instances.
Returns a list of execution dates of the dag runs that were executed.
:param run_dates: Execution dates for dag runs
:type run_dates: list
:param ti_status: internal BackfillJob status structure to tis track progress
:type ti_status: BackfillJob._DagRunTaskStatus
:param executor: the executor to use, it must be previously started
:type executor: BaseExecutor
:param pickle_id: numeric id of the pickled dag, None if not pickled
:type pickle_id: int
:param start_date: backfill start date
:type start_date: datetime.datetime
:param session: the current session object
:type session: sqlalchemy.orm.session.Session
"""
for next_run_date in run_dates:
for dag in [self.dag] + self.dag.subdags:
dag_run = self._get_dag_run(next_run_date, dag, session=session)
tis_map = self._task_instances_for_dag_run(dag_run,
session=session)
if dag_run is None:
continue
ti_status.active_runs.append(dag_run)
ti_status.to_run.update(tis_map or {})
processed_dag_run_dates = self._process_backfill_task_instances(
ti_status=ti_status,
executor=executor,
pickle_id=pickle_id,
start_date=start_date,
session=session)
ti_status.executed_dag_run_dates.update(processed_dag_run_dates)
@provide_session
def _set_unfinished_dag_runs_to_failed(self, dag_runs, session=None):
"""
Go through the dag_runs and update the state based on the task_instance state.
Then set DAG runs that are not finished to failed.
:param dag_runs: DAG runs
:param session: session
:return: None
"""
for dag_run in dag_runs:
dag_run.update_state()
if dag_run.state not in State.finished():
dag_run.set_state(State.FAILED)
session.merge(dag_run)
@provide_session
def _execute(self, session=None):
"""
Initializes all components required to run a dag for a specified date range and
calls helper method to execute the tasks.
"""
ti_status = BackfillJob._DagRunTaskStatus()
start_date = self.bf_start_date
# Get intervals between the start/end dates, which will turn into dag runs
run_dates = self.dag.get_run_dates(start_date=start_date,
end_date=self.bf_end_date)
if self.run_backwards:
tasks_that_depend_on_past = [t.task_id for t in self.dag.task_dict.values() if t.depends_on_past]
if tasks_that_depend_on_past:
raise AirflowException(
'You cannot backfill backwards because one or more tasks depend_on_past: {}'.format(
",".join(tasks_that_depend_on_past)))
run_dates = run_dates[::-1]
if len(run_dates) == 0:
self.log.info("No run dates were found for the given dates and dag interval.")
return
# picklin'
pickle_id = None
if not self.donot_pickle and self.executor.__class__ not in (
executors.LocalExecutor, executors.SequentialExecutor):
pickle = DagPickle(self.dag)
session.add(pickle)
session.commit()
pickle_id = pickle.id
executor = self.executor
executor.start()
ti_status.total_runs = len(run_dates) # total dag runs in backfill
try:
remaining_dates = ti_status.total_runs
while remaining_dates > 0:
dates_to_process = [run_date for run_date in run_dates
if run_date not in ti_status.executed_dag_run_dates]
self._execute_for_run_dates(run_dates=dates_to_process,
ti_status=ti_status,
executor=executor,
pickle_id=pickle_id,
start_date=start_date,
session=session)
remaining_dates = (
ti_status.total_runs - len(ti_status.executed_dag_run_dates)
)
err = self._collect_errors(ti_status=ti_status, session=session)
if err:
raise AirflowException(err)
if remaining_dates > 0:
|
except (KeyboardInterrupt, SystemExit):
self.log.warning("Backfill terminated by user.")
# TODO: we will need to terminate running task instances and set the
# state to failed.
self._set_unfinished_dag_runs_to_failed(ti_status.active_runs)
finally:
session.commit()
executor.end()
self.log.info("Backfill done. Exiting.")
| self.log.info(
"max_active_runs limit for dag %s has been reached "
" - waiting for other dag runs to finish",
self.dag_id
)
time.sleep(self.delay_on_limit_secs) |
range_test.go | package stats
import "testing"
func | (t *testing.T) {
data := Data{1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 0, 6, 5, 4, 43, 53, 4, 3, 43}
r, _ := Range(data)
if r != 53 {
t.Errorf("Range(data) is block")
}
}
| TestRange |
scalar_field.rs | use crate::{
ast,
types::{DefaultAttribute, FieldWithArgs, OperatorClassStore, ScalarField, ScalarType, SortOrder},
walkers::{EnumWalker, ModelWalker, Walker},
OperatorClass, ParserDatabase, ScalarFieldType,
};
use diagnostics::Span;
use either::Either;
use super::IndexFieldWalker;
/// A scalar field, as part of a model.
#[derive(Debug, Copy, Clone)]
pub struct ScalarFieldWalker<'db> {
pub(crate) model_id: ast::ModelId,
pub(crate) field_id: ast::FieldId,
pub(crate) db: &'db ParserDatabase,
pub(crate) scalar_field: &'db ScalarField,
}
impl<'db> PartialEq for ScalarFieldWalker<'db> {
fn eq(&self, other: &Self) -> bool {
self.model_id == other.model_id && self.field_id == other.field_id
}
}
impl<'db> Eq for ScalarFieldWalker<'db> {}
impl<'db> ScalarFieldWalker<'db> {
/// The ID of the field node in the AST.
pub fn field_id(self) -> ast::FieldId {
self.field_id
}
/// The field node in the AST.
pub fn ast_field(self) -> &'db ast::Field {
&self.db.ast[self.model_id][self.field_id]
}
/// The name of the field.
pub fn name(self) -> &'db str {
self.ast_field().name()
}
/// The `@default()` AST attribute on the field, if any.
pub fn default_attribute(self) -> Option<&'db ast::Attribute> {
self.scalar_field
.default
.as_ref()
.map(|d| d.default_attribute)
.map(|id| &self.db.ast[id])
}
/// The final database name of the field. See crate docs for explanations on database names.
pub fn database_name(self) -> &'db str {
self.attributes()
.mapped_name
.map(|id| &self.db[id])
.unwrap_or_else(|| self.name())
}
/// Does the field have an `@default(autoincrement())` attribute?
pub fn is_autoincrement(self) -> bool {
self.default_value().map(|dv| dv.is_autoincrement()).unwrap_or(false)
}
/// Does the field define a primary key by its own.
pub fn is_single_pk(self) -> bool {
self.model().field_is_single_pk(self.field_id)
}
/// Is the field part of a compound primary key.
pub fn is_part_of_a_compound_pk(self) -> bool {
self.model().field_is_part_of_a_compound_pk(self.field_id)
}
/// Is there an `@ignore` attribute on the field?
pub fn is_ignored(self) -> bool {
self.attributes().is_ignored
}
/// Is the field optional / nullable?
pub fn is_optional(self) -> bool {
self.ast_field().arity.is_optional()
}
/// Is there an `@updateAt` attribute on the field?
pub fn is_updated_at(self) -> bool {
self.attributes().is_updated_at
}
fn attributes(self) -> &'db ScalarField {
self.scalar_field
}
/// Is this field's type an enum? If yes, walk the enum.
pub fn field_type_as_enum(self) -> Option<EnumWalker<'db>> {
match self.scalar_field_type() {
ScalarFieldType::Enum(enum_id) => Some(Walker {
db: self.db,
id: enum_id,
}),
_ => None,
}
}
/// The name in the `@map(<name>)` attribute.
pub fn mapped_name(self) -> Option<&'db str> {
self.attributes().mapped_name.map(|id| &self.db[id])
}
/// The model that contains the field.
pub fn model(self) -> ModelWalker<'db> {
ModelWalker {
model_id: self.model_id,
db: self.db,
model_attributes: &self.db.types.model_attributes[&self.model_id],
}
}
/// (attribute scope, native type name, arguments, span)
///
/// For example: `@db.Text` would translate to ("db", "Text", &[], <the span>)
pub fn raw_native_type(self) -> Option<(&'db str, &'db str, &'db [String], Span)> {
let db = self.db;
self.attributes()
.native_type
.as_ref()
.map(move |(datasource_name, name, args, span)| (&db[*datasource_name], &db[*name], args.as_slice(), *span))
}
/// Is the type of the field `Unsupported("...")`?
pub fn is_unsupported(self) -> bool {
matches!(self.ast_field().field_type, ast::FieldType::Unsupported(_, _))
}
/// The `@default()` attribute of the field, if any.
pub fn default_value(self) -> Option<DefaultValueWalker<'db>> {
self.attributes().default.as_ref().map(|default| DefaultValueWalker {
model_id: self.model_id,
field_id: self.field_id,
db: self.db,
default,
})
}
/// The type of the field.
pub fn scalar_field_type(self) -> ScalarFieldType {
self.attributes().r#type
}
/// The type of the field in case it is a scalar type (not an enum, not a composite type).
pub fn scalar_type(self) -> Option<ScalarType> {
match &self.scalar_field.r#type {
ScalarFieldType::BuiltInScalar(scalar) => Some(*scalar),
_ => None,
}
}
}
/// An `@default()` attribute on a field.
#[derive(Clone, Copy)]
pub struct DefaultValueWalker<'db> {
pub(super) model_id: ast::ModelId,
pub(super) field_id: ast::FieldId,
pub(super) db: &'db ParserDatabase,
pub(super) default: &'db DefaultAttribute,
}
impl<'db> DefaultValueWalker<'db> {
/// The AST node of the attribute.
pub fn | (self) -> &'db ast::Attribute {
&self.db.ast[self.default.default_attribute]
}
/// The value expression in the `@default` attribute.
///
/// ```ignore
/// score Int @default(0)
/// ^
/// ```
pub fn value(self) -> &'db ast::Expression {
&self.ast_attribute().arguments.arguments[self.default.argument_idx].value
}
/// Is this an `@default(autoincrement())`?
pub fn is_autoincrement(self) -> bool {
matches!(self.value(), ast::Expression::Function(name, _, _) if name == "autoincrement")
}
/// Is this an `@default(cuid())`?
pub fn is_cuid(self) -> bool {
matches!(self.value(), ast::Expression::Function(name, _, _) if name == "cuid")
}
/// Is this an `@default(dbgenerated())`?
pub fn is_dbgenerated(self) -> bool {
matches!(self.value(), ast::Expression::Function(name, _, _) if name == "dbgenerated")
}
/// Is this an `@default(auto())`?
pub fn is_auto(self) -> bool {
matches!(self.value(), ast::Expression::Function(name, _, _) if name == "auto")
}
/// Is this an `@default(now())`?
pub fn is_now(self) -> bool {
matches!(self.value(), ast::Expression::Function(name, _, _) if name == "now")
}
/// Is this an `@default(sequence())`?
pub fn is_sequence(self) -> bool {
matches!(self.value(), ast::Expression::Function(name, _, _) if name == "sequence")
}
/// Is this an `@default(uuid())`?
pub fn is_uuid(self) -> bool {
matches!(self.value(), ast::Expression::Function(name, _, _) if name == "uuid")
}
/// The mapped name of the default value. Not applicable to all connectors. See crate docs for
/// details on mapped names.
///
/// ```ignore
/// name String @default("george", map: "name_default_to_george")
/// ^^^^^^^^^^^^^^^^^^^^^^^^
/// ```
pub fn mapped_name(self) -> Option<&'db str> {
self.default.mapped_name.map(|id| &self.db[id])
}
/// The field carrying the default attribute.
///
/// ```ignore
/// name String @default("george")
/// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
/// ```
pub fn field(self) -> ScalarFieldWalker<'db> {
ScalarFieldWalker {
model_id: self.model_id,
field_id: self.field_id,
db: self.db,
scalar_field: &self.db.types.scalar_fields[&(self.model_id, self.field_id)],
}
}
}
/// An operator class defines the operators allowed in an index. Mostly
/// a PostgreSQL thing.
#[derive(Copy, Clone)]
pub struct OperatorClassWalker<'db> {
pub(crate) class: &'db OperatorClassStore,
pub(crate) db: &'db ParserDatabase,
}
impl<'db> OperatorClassWalker<'db> {
/// Gets the operator class of the indexed field.
///
/// ```ignore
/// @@index(name(ops: InetOps))
/// // ^ Either::Left(InetOps)
/// @@index(name(ops: raw("tsvector_ops")))
/// // ^ Either::Right("tsvector_ops")
pub fn get(self) -> Either<OperatorClass, &'db str> {
match self.class.inner {
Either::Left(class) => Either::Left(class),
Either::Right(id) => Either::Right(&self.db[id]),
}
}
}
/// A scalar field as referenced in a key specification (id, index or unique).
#[derive(Copy, Clone)]
pub struct ScalarFieldAttributeWalker<'db> {
pub(crate) model_id: ast::ModelId,
pub(crate) fields: &'db [FieldWithArgs],
pub(crate) db: &'db ParserDatabase,
pub(crate) field_arg_id: usize,
}
impl<'db> ScalarFieldAttributeWalker<'db> {
fn args(self) -> &'db FieldWithArgs {
&self.fields[self.field_arg_id]
}
/// The length argument on the field.
///
/// ```ignore
/// @@index(name(length: 10))
/// ^^
/// ```
pub fn length(self) -> Option<u32> {
self.args().length
}
/// A custom operator class to control the operators catched by the index.
///
/// ```ignore
/// @@index([name(ops: InetOps)], type: Gist)
/// ^^^^^^^
/// ```
pub fn operator_class(self) -> Option<OperatorClassWalker<'db>> {
self.args()
.operator_class
.as_ref()
.map(|class| OperatorClassWalker { class, db: self.db })
}
/// The underlying field.
///
/// ```ignore
/// // either this
/// model Test {
/// id Int @id
/// name String
/// ^^^^^^^^^^^^^^^^^^
/// kind Int
///
/// @@index([name])
/// }
///
/// // or this
/// type A {
/// field String
/// ^^^^^^^^^^^^
/// }
///
/// model Test {
/// id Int @id
/// a A
///
/// @@index([a.field])
/// }
/// ```
pub fn as_index_field(self) -> IndexFieldWalker<'db> {
let path = &self.args().path;
let field_id = path.field_in_index();
match path.type_holding_the_indexed_field() {
None => {
let field_id = path.field_in_index();
let walker = self.db.walk_model(self.model_id).scalar_field(field_id);
IndexFieldWalker::new(walker)
}
Some(ctid) => {
let walker = self.db.walk_composite_type(ctid).field(field_id);
IndexFieldWalker::new(walker)
}
}
}
/// Gives the full path from the current model to the field included in the index.
/// For example, if the field is through two composite types:
///
/// ```ignore
/// type A {
/// field Int
/// }
///
/// type B {
/// a A
/// }
///
/// model C {
/// id Int @id
/// b B
///
/// @@index([b.a.field])
/// }
/// ```
///
/// The method would return a vector from model to the final field:
///
/// ```ignore
/// vec![("b", None), ("a", Some("B")), ("field", Some("A"))];
/// ```
///
/// The first part of the tuple is the name of the field, the second part is
/// the name of the composite type.
///
/// This method prefers the prisma side naming, and should not be used when
/// writing to the database.
pub fn as_path_to_indexed_field(self) -> Vec<(&'db str, Option<&'db str>)> {
let path = &self.args().path;
let root = self.db.ast[self.model_id][path.root()].name.name.as_str();
let mut result = vec![(root, None)];
for (ctid, field_id) in path.path() {
let ct = &self.db.ast[*ctid];
let field = ct[*field_id].name.name.as_str();
result.push((field, Some(ct.name.name.as_str())));
}
result
}
/// Similar to the method [`as_path_to_indexed_field`], but prefers the
/// mapped names and is to be used when defining indices in the database.
///
/// [`as_path_to_indexed_field`]: struct.ScalarFieldAttributeWalker
pub fn as_mapped_path_to_indexed_field(self) -> Vec<(&'db str, Option<&'db str>)> {
let path = &self.args().path;
let root = {
let mapped = &self.db.types.scalar_fields[&(self.model_id, path.root())].mapped_name;
mapped
.and_then(|id| self.db.interner.get(id))
.unwrap_or_else(|| self.db.ast[self.model_id][path.root()].name.name.as_str())
};
let mut result = vec![(root, None)];
for (ctid, field_id) in path.path() {
let ct = &self.db.ast[*ctid];
let field = &self.db.types.composite_type_fields[&(*ctid, *field_id)]
.mapped_name
.and_then(|id| self.db.interner.get(id))
.unwrap_or_else(|| ct[*field_id].name.name.as_str());
result.push((field, Some(ct.name.name.as_str())));
}
result
}
/// The sort order (asc or desc) on the field.
///
/// ```ignore
/// @@index(name(sort: Desc))
/// ^^^^
/// ```
pub fn sort_order(&self) -> Option<SortOrder> {
self.args().sort_order
}
}
| ast_attribute |
canonical_serialization_test.rs | // Copyright (c) The Libra Core Contributors
// SPDX-License-Identifier: Apache-2.0
//https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
//disable it in test so that we can use variable names such as 'foo' and 'bar'
#![allow(clippy::blacklisted_name)]
#![allow(clippy::many_single_char_names)]
use super::*;
use byteorder::WriteBytesExt;
use failure::Result;
use std::u32;
// Do not change the test vectors. Please read the comment below.
const TEST_VECTOR_1: &str = "ffffffffffffffff060000006463584d4237640000000000000009000000000102\
03040506070805050505050505050505050505050505050505050505050505050505\
05050505630000000103000000010000000103000000161543030000000038150300\
0000160a05040000001415596903000000c9175a";
// Why do we need test vectors?
//
// 1. Sometimes it helps to catch common bugs between serialization and
// deserialization functions that would have been missed by a simple round trip test.
// For example, if there's a bug in a shared procedure that serializes and
// deserialize both calls then roundtrip might miss it.
//
// 2. It helps to catch code changes that inadvertently introduce breaking changes
// in the serialization format that is incompatible with what generated in the
// past which would be missed by roundtrip tests, or changes that are not backward
// compatible in the sense that it may fail to deserialize bytes generated in the past.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Addr(pub [u8; 32]);
impl Addr {
fn new(bytes: [u8; 32]) -> Self {
Addr(bytes)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct Foo {
a: u64,
b: Vec<u8>,
c: Bar,
d: bool,
e: BTreeMap<Vec<u8>, Vec<u8>>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct | {
a: u64,
b: Vec<u8>,
c: Addr,
d: u32,
}
impl CanonicalSerialize for Foo {
fn serialize(&self, serializer: &mut impl CanonicalSerializer) -> Result<()> {
serializer
.encode_u64(self.a)?
.encode_variable_length_bytes(&self.b)?
.encode_struct(&self.c)?
.encode_bool(self.d)?
.encode_btreemap(&self.e)?;
Ok(())
}
}
impl CanonicalSerialize for Bar {
fn serialize(&self, serializer: &mut impl CanonicalSerializer) -> Result<()> {
serializer
.encode_u64(self.a)?
.encode_variable_length_bytes(&self.b)?
.encode_raw_bytes(&self.c.0)?
.encode_u32(self.d)?;
Ok(())
}
}
impl CanonicalDeserialize for Foo {
fn deserialize(deserializer: &mut impl CanonicalDeserializer) -> Result<Self> {
let a = deserializer.decode_u64()?;
let b = deserializer.decode_variable_length_bytes()?;
let c: Bar = deserializer.decode_struct::<Bar>()?;
let d: bool = deserializer.decode_bool()?;
let e: BTreeMap<Vec<u8>, Vec<u8>> = deserializer.decode_btreemap()?;
Ok(Foo { a, b, c, d, e })
}
}
impl CanonicalDeserialize for Bar {
fn deserialize(deserializer: &mut impl CanonicalDeserializer) -> Result<Self> {
let a = deserializer.decode_u64()?;
let b = deserializer.decode_variable_length_bytes()?;
let c = deserializer.decode_bytes_with_len(32)?;
let mut cc: [u8; 32] = [0; 32];
cc.copy_from_slice(c.as_slice());
let d = deserializer.decode_u32()?;
Ok(Bar {
a,
b,
c: Addr::new(cc),
d,
})
}
}
#[test]
fn test_btreemap_encode() {
let mut map = BTreeMap::new();
let value = vec![54, 20, 21, 200];
let key1 = vec![0]; // after serialization: [1, 0]
let key2 = vec![0, 6]; // after serialization: [2, 0, 6]
let key3 = vec![1]; // after serialization: [1, 1]
let key4 = vec![2]; // after serialization: [1, 2]
map.insert(key1.clone(), value.clone());
map.insert(key2.clone(), value.clone());
map.insert(key3.clone(), value.clone());
map.insert(key4.clone(), value.clone());
let serialized_bytes = SimpleSerializer::<Vec<u8>>::serialize(&map).unwrap();
let mut deserializer = SimpleDeserializer::new(&serialized_bytes);
// ensure the order was encoded in lexicographic order
assert_eq!(deserializer.raw_bytes.read_u32::<Endianness>().unwrap(), 4);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), key1);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), value);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), key3);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), value);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), key4);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), value);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), key2);
assert_eq!(deserializer.decode_variable_length_bytes().unwrap(), value);
}
#[test]
fn test_serialization_roundtrip() {
let bar = Bar {
a: 50,
b: vec![10u8; 100],
c: Addr::new([3u8; 32]),
d: 12,
};
let mut map = BTreeMap::new();
map.insert(vec![0, 56, 21], vec![22, 10, 5]);
map.insert(vec![1], vec![22, 21, 67]);
map.insert(vec![20, 21, 89, 105], vec![201, 23, 90]);
let foo = Foo {
a: 1,
b: vec![32, 41, 190, 200, 2, 5, 90, 100, 123, 234, 159, 159, 101],
c: bar,
d: false,
e: map,
};
let mut serializer = SimpleSerializer::<Vec<u8>>::new();
foo.serialize(&mut serializer).unwrap();
let serialized_bytes = serializer.get_output();
let mut deserializer = SimpleDeserializer::new(&serialized_bytes);
let deserialized_foo = Foo::deserialize(&mut deserializer).unwrap();
assert_eq!(foo, deserialized_foo);
assert_eq!(
deserializer.raw_bytes.position(),
deserializer.raw_bytes.get_ref().len() as u64
);
}
#[test]
fn test_encode_vec() {
let bar1 = Bar {
a: 55,
b: vec![10u8; 100],
c: Addr::new([3u8; 32]),
d: 77,
};
let bar2 = Bar {
a: 123,
b: vec![1, 5, 20],
c: Addr::new([8u8; 32]),
d: 127,
};
let mut vec = Vec::new();
vec.push(bar1.clone());
vec.push(bar2.clone());
let mut serializer = SimpleSerializer::<Vec<u8>>::new();
serializer.encode_vec(&vec).unwrap();
let serialized_bytes = serializer.get_output();
let de_vec: Vec<Bar> = SimpleDeserializer::deserialize(&serialized_bytes).unwrap();
assert_eq!(2, de_vec.len());
assert_eq!(bar1, de_vec[0]);
assert_eq!(bar2, de_vec[1]);
// test Vec<T> implementation
let mut serializer = SimpleSerializer::<Vec<u8>>::new();
serializer.encode_struct(&vec).unwrap();
let serialized_bytes = serializer.get_output();
let de_vec: Vec<Bar> = SimpleDeserializer::deserialize(&serialized_bytes).unwrap();
assert_eq!(2, de_vec.len());
assert_eq!(bar1, de_vec[0]);
assert_eq!(bar2, de_vec[1]);
}
#[test]
fn test_vec_impl() {
let mut vec: Vec<i32> = Vec::new();
vec.push(std::i32::MIN);
vec.push(std::i32::MAX);
vec.push(100);
let mut serializer = SimpleSerializer::<Vec<u8>>::new();
serializer.encode_struct(&vec).unwrap();
let serialized_bytes = serializer.get_output();
let de_vec: Vec<i32> = SimpleDeserializer::deserialize(&serialized_bytes).unwrap();
assert_eq!(vec, de_vec);
}
#[test]
fn test_vectors_1() {
let bar = Bar {
a: 100,
b: vec![0, 1, 2, 3, 4, 5, 6, 7, 8],
c: Addr::new([5u8; 32]),
d: 99,
};
let mut map = BTreeMap::new();
map.insert(vec![0, 56, 21], vec![22, 10, 5]);
map.insert(vec![1], vec![22, 21, 67]);
map.insert(vec![20, 21, 89, 105], vec![201, 23, 90]);
let foo = Foo {
a: u64::max_value(),
b: vec![100, 99, 88, 77, 66, 55],
c: bar,
d: true,
e: map,
};
let mut serializer = SimpleSerializer::<Vec<u8>>::new();
foo.serialize(&mut serializer).unwrap();
let serialized_bytes = serializer.get_output();
// make sure we serialize into exact same bytes as before
assert_eq!(TEST_VECTOR_1, hex::encode(serialized_bytes));
// make sure we can deserialize the test vector into expected struct
let test_vector_bytes = hex::decode(TEST_VECTOR_1).unwrap();
let deserialized_foo: Foo = SimpleDeserializer::deserialize(&test_vector_bytes).unwrap();
assert_eq!(foo, deserialized_foo);
}
#[test]
fn test_serialization_failure_cases() {
// a vec longer than representable range should result in failure
let bar = Bar {
a: 100,
b: vec![0; i32::max_value() as usize + 1],
c: Addr::new([0u8; 32]),
d: 222,
};
let mut serializer = SimpleSerializer::<Vec<u8>>::new();
assert!(bar.serialize(&mut serializer).is_err());
}
#[test]
fn test_deserialization_failure_cases() {
// invalid length prefix should fail on all decoding methods
let bytes_len_2 = vec![0; 2];
let mut deserializer = SimpleDeserializer::new(&bytes_len_2);
assert!(deserializer.clone().decode_u64().is_err());
assert!(deserializer.clone().decode_bytes_with_len(32).is_err());
assert!(deserializer.clone().decode_variable_length_bytes().is_err());
assert!(deserializer.clone().decode_struct::<Foo>().is_err());
assert!(Foo::deserialize(&mut deserializer.clone()).is_err());
// a length prefix longer than maximum allowed should fail
let mut long_bytes = Vec::new();
long_bytes
.write_u32::<Endianness>(ARRAY_MAX_LENGTH as u32 + 1)
.unwrap();
deserializer = SimpleDeserializer::new(&long_bytes);
assert!(deserializer.clone().decode_variable_length_bytes().is_err());
// vec not long enough should fail
let mut bytes_len_10 = Vec::new();
bytes_len_10.write_u32::<Endianness>(32).unwrap();
deserializer = SimpleDeserializer::new(&bytes_len_10);
assert!(deserializer.clone().decode_variable_length_bytes().is_err());
assert!(deserializer.clone().decode_bytes_with_len(32).is_err());
// malformed struct should fail
let mut some_bytes = Vec::new();
some_bytes.write_u64::<Endianness>(10).unwrap();
some_bytes.write_u32::<Endianness>(50).unwrap();
deserializer = SimpleDeserializer::new(&some_bytes);
assert!(deserializer.clone().decode_struct::<Foo>().is_err());
// malformed encoded bytes with length prefix larger than real
let mut evil_bytes = Vec::new();
evil_bytes.write_u32::<Endianness>(500).unwrap();
evil_bytes.resize_with(4 + 499, Default::default);
deserializer = SimpleDeserializer::new(&evil_bytes);
assert!(deserializer.clone().decode_variable_length_bytes().is_err());
// malformed encoded bool with value not 0 or 1
let mut bool_bytes = Vec::new();
bool_bytes.write_u8(2).unwrap();
deserializer = SimpleDeserializer::new(&bool_bytes);
assert!(deserializer.clone().decode_bool().is_err());
}
| Bar |
main.ts | $(document).on('ready', () => { | //write javascript code here
}); |
|
test_regexp_basics_is_it_ipv4_address.py | import unittest
from katas.kyu_6.regexp_basics_is_it_ipv4_address import ipv4_address
class IPV4AddressTestCase(unittest.TestCase):
def test_true(self):
self.assertTrue(ipv4_address('127.0.0.1'))
def test_true_2(self):
self.assertTrue(ipv4_address('0.0.0.0'))
def test_true_3(self):
self.assertTrue(ipv4_address('255.255.255.255'))
def test_true_4(self):
self.assertTrue(ipv4_address('10.20.30.40'))
def | (self):
self.assertFalse(ipv4_address(''))
def test_false_2(self):
self.assertFalse(ipv4_address('10.256.30.40'))
def test_false_3(self):
self.assertFalse(ipv4_address('10.20.030.40'))
def test_false_4(self):
self.assertFalse(ipv4_address('127.0.1'))
def test_false_5(self):
self.assertFalse(ipv4_address('127.0.0.0.1'))
def test_false_6(self):
self.assertFalse(ipv4_address('..255.255'))
def test_false_7(self):
self.assertFalse(ipv4_address('127.0.0.1\n'))
def test_false_8(self):
self.assertFalse(ipv4_address('\n127.0.0.1'))
def test_false_9(self):
self.assertFalse(ipv4_address(' 127.0.0.1'))
def test_false_10(self):
self.assertFalse(ipv4_address('127.0.0.1 '))
def test_false_11(self):
self.assertFalse(ipv4_address(' 127.0.0.1 '))
| test_false |
OptimizeSumDets.py | import scipy
import time
try:
import SloppyCell.Plotting as Plotting
except ImportError:
pass
def C(p, origMatrix, weightsRDP=0.,weights2D=0.,weightsLS=0.,weightPR=0.,weightPriors=0.,*args,**kwargs):
"""
p is list {a_{ij}, i: 1..n, j: i+1..n}
n is size of total matrix
"""
n = origMatrix.shape[0]
OrthMatrix = ProcessHalfMatrix(p)
newMat = transformMatrix(origMatrix,OrthMatrix)
cost=0.
if weightsRDP > 0.:
cost += weightsRDP*sumRowDotProdsOLD(newMat)
if weights2D > 0.:
cost += weights2D*sum2Determinants(newMat)
if weightsLS > 0.:
cost += weightsLS*sumLogSpacings(newMat)
if weightPR>0.:
cost += weightPR/(ParticipationRatio(OrthMatrix)**2.)
## cost += weightPR*(1.-ParticipationRatio(OrthMatrix)/n)
if weightPriors>0.:
cost +=weightPR*calcPriors(p)
return cost
def calcPriors(paramsList, pOpt=0.,pSigma=10.):
priorCost=0.
for param in paramsList:
priorCost += ((param-pOpt)/pSigma)**2.
return priorCost
def sumRowDotProdsOLD(origMatrix):
"""
Makes more sense to use on Jacobian than on Hessian.
"""
rowNormalized = normRows(origMatrix)
n = origMatrix.shape[0]
## sumDotProds = sum([abs((scipy.dot(rowNormalized[i],rowNormalized[i+1])))**(1./2.) for i in range(n-1)])
sumDotProds = sum([1.-(scipy.dot(rowNormalized[i],rowNormalized[i+1]))**2. for i in range(n-1)])
return sumDotProds
def sumRowDotProdsNEW(origMatrix):
"""
Makes more sense to use on Jacobian than on Hessian.
"""
rowNormalized = normRows(origMatrix)
n = rowNormalized.shape[0]
sumDotProds = sumAllDotProds(rowNormalized[0:n/2]) + sumAllDotProds(rowNormalized[n/2:n])
return sumDotProds
def sumAllDotProds(origMatrix):
n = origMatrix.shape[0]
sumDotProds=0.
for ii in range(n):
for jj in range(ii+1,n):
sumDotProds += 1.-scipy.dot(origMatrix[ii],origMatrix[jj])**2.
return sumDotProds
def sum2Determinants(matrixToSum):
n = matrixToSum.shape[0]/2
det1 = scipy.linalg.det(matrixToSum[0:n,0:n])
det2 = scipy.linalg.det(matrixToSum[n:n*2,n:n*2])
return scipy.absolute(det1)+scipy.absolute(det2)
def sumLogSpacings(matrixToSum):
n = matrixToSum.shape[0]/2
sv1 = scipy.linalg.svdvals(matrixToSum[0:n,0:n])
sv2 = scipy.linalg.svdvals(matrixToSum[n:n*2,n:n*2])
return sum(sv1[1:n]/sv1[0:n-1])+sum(sv2[1:n]/sv2[0:n-1])
def ParticipationRatio(origMatrix):
return scipy.sum(scipy.sum(origMatrix**4))
def ProcessFullMatrix(p):
"""
this is used if parameters define all elements of a matrix
"""
n = scipy.sqrt(len(p)).__int__()
pMat = scipy.reshape(p,(n,n))
orthMat = scipy.linalg.orth(pMat)
return orthMat
def ProcessHalfMatrix(p):
"""
this is used if parameters define upper right triangular portion of
skew-symmetric matrix.
Then performs a Cayley transformation of this skew-symmetric matrix.
"""
l = scipy.size(p)
n = scipy.round(((1.+scipy.sqrt(1+8.*l))/2.)).__int__()
Mfull = scipy.zeros((n,n),'d')
placeCounter=0
for i in range(n-1):
Mfull[i,(i+1):n] = p[placeCounter:(placeCounter+n-i-1)]
placeCounter += n-i-1
Mfull = Mfull - scipy.transpose(Mfull)
IMat = scipy.eye(n,'d')
return scipy.dot((IMat-Mfull),scipy.linalg.inv(IMat+Mfull))
## return scipy.linalg.expm(Mfull)
def ProcessQuarterMatrix(p):
"""
this is used if parameters define just upper right and lower left
quadrants of antisymmetric matrix.
"""
n= scipy.sqrt(scipy.size(p))
Mu = scipy.resize(p, (n,n))
Mfull = scipy.bmat([[scipy.zeros((n,n)),Mu],[-scipy.transpose(Mu),scipy.zeros((n,n))]])
return scipy.linalg.expm(Mfull)
def BestMatrix(origMatrix, p=None, weightsRDP=1., weights2D=0., weightsLS=0., weightPR=0., weightPriors=0., seed=None, *args, **kwargs):
if seed is not None:
scipy.random.seed(seed)
n = origMatrix.shape[0]
if p is None:
p = (scipy.random.random(n*(n-1)/2)-0.5)
pOpt = scipy.optimize.fmin(C, p, args=(origMatrix,weightsRDP, weights2D, weightsLS, weightPR, weightPriors), *args, **kwargs)
return C(pOpt, origMatrix, weightsRDP, weights2D, weightsLS, weightPR, weightPriors), pOpt
def ManyBest(origMatrix, numberTries=10, p=None,numOpts=10,weightsRDP=1., weights2D=0., weightsLS=0., weightPR=0., weightPriors=0., seed=None, *args, **kwargs):
return [OptimizeManyTimes(origMatrix,p,numOpts,weightsRDP, weights2D, weightsLS, weightPR, weightPriors, seed, *args, **kwargs) for i in range(numberTries)]
def OptimizeManyTimes(origMatrix,p=None,numOpts=10,weightsRDP=1., weights2D=0., weightsLS=0., weightPR=0., weightPriors=0., seed=None, *args, **kwargs):
C,pOpt = BestMatrix(origMatrix,p,weightsRDP,weights2D,weightsLS,weightPR,weightPriors,seed,*args,**kwargs)
for i in range(numOpts-1):
C,pOpt = BestMatrix(origMatrix,pOpt,weightsRDP,weights2D,weightsLS,weightPR,weightPriors,seed,*args,**kwargs)
return C, pOpt
def getGammas(numExps,distWidth=1.):
epsilons = scipy.random.random(numExps)-0.5
gammas = 1.+epsilons
return gammas
def getAmounts(numExps,distWidth=1.):
# amounts=scipy.ones(numExps,'d')
amounts = scipy.random.random(numExps)-0.5
amounts = 1.+amounts
return amounts
def netRadiation(gammas,amounts,time):
|
def getHessFull(gammas=None,amounts=None,numExps=3):
if gammas is None:
gammas = getGammas(numExps)
if amounts is None:
amounts = getAmounts(numExps)
numExps=scipy.size(gammas)
hessgg = getHessGG(gammas)
hessAA = getHessAA(amounts,gammas)
numerAg1 = -scipy.outer(amounts,amounts*gammas)
denomAg1 = scipy.outer(scipy.ones(numExps),gammas)
denomAg2 = scipy.transpose(denomAg1)+denomAg1
denomAg3 = denomAg2*denomAg2
hessAg = numerAg1/denomAg3
numergA1 = -scipy.outer(amounts*gammas,amounts)
denomgA1 = scipy.outer(gammas,scipy.ones(numExps))
denomgA2 = scipy.transpose(denomgA1)+denomgA1
denomgA3 = denomgA2*denomgA2
hessgA = numergA1/denomgA3
hessFull = scipy.bmat([[hessAA,hessAg],[hessgA,hessgg]])
return hessFull
def getHessFullLogTime(gammas=None,amounts=None,numExps=3):
"""use this routine for new paper"""
if gammas is None:
gammas = getGammas(numExps)
if amounts is None:
amounts = getAmounts(numExps)
numExps=scipy.size(gammas)
amountsLess1 = amounts[0:-1]
gammasLess1 = gammas[0:-1]
hessgg = getHessGGLogTime(gammas=gammas,amounts=amounts)
hessAA = getHessAALogTime(amounts=amounts,gammas=gammas)
numerAg1 = scipy.array(-2.*scipy.outer(amountsLess1,amounts*gammas))
denomAg1 = scipy.array(scipy.outer(gammasLess1,scipy.ones(numExps)))
denomAg2 = scipy.array(scipy.outer(scipy.ones(numExps-1),gammas))
denomAg3 = scipy.array(denomAg1+denomAg2)
denomAg4 = denomAg2+gammas[-1]
hessAg = scipy.array(numerAg1/denomAg3)-scipy.array(numerAg1/denomAg4)
hessgA = scipy.transpose(hessAg)
hessFull = scipy.array(scipy.bmat([[hessAA,hessAg],[hessgA,hessgg]]))
return hessFull
def getHessGG(gammas=None,numExps=3):
if gammas is None:
numExps=6
gammas = scipy.array([1.,1.2,1.4,1001.,1005.,997.])
numExps = scipy.size(gammas)
numergg1 = 2.*scipy.outer(gammas, gammas)
denomgg1 = scipy.outer(scipy.ones(numExps),gammas)
denomgg2 = scipy.transpose(denomgg1)+denomgg1
denomgg3 = denomgg2*denomgg2*denomgg2
hessgg = numergg1/denomgg3
return hessgg
def getHessGGLogTime(gammas=None,amounts=None,numExps=3):
"""use this routine for the new paper"""
if gammas is None:
numExps=6
gammas = scipy.array([1.,1.2,1.4,1001.,1005.,997.])
if amounts is None:
amounts = scipy.ones(numExps,'d')
numExps = scipy.size(gammas)
numergg1 = scipy.array(2.*scipy.outer(gammas*amounts, gammas*amounts))
denomgg1 = scipy.array(scipy.outer(scipy.ones(numExps),gammas))
denomgg2 = scipy.array(scipy.transpose(denomgg1)+denomgg1)
denomgg3 = scipy.array(denomgg2*denomgg2)
hessgg = scipy.array(numergg1/denomgg3)
return hessgg
def getHessAA(amounts=None,gammas=None,numExps=3):
if amounts is None:
amounts = getAmounts(numExps)
if gammas is None:
gammas = getGammas(numExps)
numExps = scipy.size(amounts)
numerAA1 = scipy.outer(amounts,amounts)
denomAA1 = scipy.outer(scipy.ones(numExps),gammas)
denomAA2 = scipy.transpose(denomAA1)+denomAA1
hessAA = numerAA1/denomAA2
return hessAA
def getHessAALogTime(amounts=None,gammas=None,numExps=3):
"""use this routine for the new paper"""
if amounts is None:
amounts = getAmounts(numExps)
if gammas is None:
gammas = getGammas(numExps)
numExps = scipy.size(amounts)
amountsLess1 = amounts[0:-1]
gammasLess1 = gammas[0:-1]
numerAA1 = scipy.array(scipy.outer(amountsLess1,amountsLess1))
numerAA2 = scipy.array(scipy.outer(gammasLess1+gammas[-1],scipy.ones(numExps-1)))
numerAA3 = scipy.array(scipy.outer(scipy.ones(numExps-1),gammasLess1+gammas[-1]))
denomAA1 = scipy.array(scipy.outer(scipy.ones(numExps-1),2*gammas[-1]*gammasLess1))
denomAA2 = scipy.array(scipy.transpose(denomAA1)+denomAA1)
hessAA = 2.*scipy.array(numerAA1*scipy.log(numerAA2*numerAA3/denomAA2))
return hessAA
def getJacobian(times, amounts=None, gammas=None):
numGammas=0
numAmounts=0
if gammas is not None:
numGammas = scipy.size(gammas)
if amounts is not None:
numAmounts = scipy.size(amounts)
Jacobian = scipy.zeros((numGammas+numAmounts,scipy.size(times)),'d')
if numAmounts > 0:
Jacobian[0:numAmounts] = getJacobianA(times,amounts,gammas)
if numGammas > 0:
Jacobian[numAmounts:numAmounts+numGammas] = getJacobianG(times,gammas,amounts)
return Jacobian
def getJacobianLogTime(times, amounts=None, gammas=None):
numGammas=0
numAmounts=0
if gammas is not None:
numGammas = scipy.size(gammas)
if amounts is not None:
numAmounts = scipy.size(amounts)
JacobianLogTime = scipy.zeros((numGammas+numAmounts,scipy.size(times)),'d')
if numAmounts > 0:
JacobianLogTime[0:numAmounts] = getJacobianALogTime(times,amounts,gammas)
if numGammas > 0:
JacobianLogTime[numAmounts:numAmounts+numGammas] = getJacobianGLogTime(times,gammas,amounts)
return JacobianLogTime
def getJacobianLog(times,gammas,amounts=None):
"""This is the routine to use for new paper (with times exponentially
distributed."""
numExps = scipy.size(gammas)
if amounts is None:
amounts = scipy.ones(numExps,'d')
jacG = getJacobianLogG(times,gammas,amounts)
jacA = getJacobianLogA(times,gammas,amounts)
return scipy.transpose(scipy.array(scipy.bmat([[jacA],[jacG]])))
def getJacobianLogG(times,gammas,amounts=None):
"""This is the routine to use for new paper (with times exponentially
distributed."""
numExps = scipy.size(gammas)
if amounts is None:
amounts = scipy.ones(numExps,'d')
JacobianLogG = scipy.array([gammas[j]*amounts[j]*(-times)*scipy.exp(-gammas[j]*times) for j in range(numExps)])
return JacobianLogG
def getJacobianLogA(times,gammas,amounts):
"""This is the routine to use for new paper (with times exponentially
distributed."""
numExps = scipy.size(gammas)
JacobianLogA = scipy.array([amounts[j]*(scipy.exp(-gammas[j]*times)-scipy.exp(-gammas[-1]*times)) for j in range(numExps-1)])
return JacobianLogA
def getJacobianG(times,gammas,amounts=None):
numGammas = scipy.size(gammas)
if amounts is None:
amounts = scipy.ones(numGammas,'d')
JacobianG = scipy.array([-amounts[i]*gammas[i]*times*scipy.exp(-gammas[i]*times) for i in range(numGammas)])
return JacobianG
def getJacobianGLogTime(times,gammas,amounts=None):
numGammas = scipy.size(gammas)
if amounts is None:
amounts = scipy.ones(numGammas,'d')
JacobianGLogTime = scipy.array([-amounts[i]*gammas[i]*scipy.sqrt(times)*scipy.exp(-gammas[i]*times) for i in range(numGammas)])
return JacobianGLogTime
def getJacobianA(times,amounts,gammas=None):
numAmounts = scipy.size(amounts)
if gammas is None:
gammas = scipy.zeros(numAmounts,'d')
JacobianA = scipy.array([amounts[i]*scipy.exp(-gammas[i]*times) for i in range(numAmounts)])
return JacobianA
def getJacobianALogTime(times,amounts,gammas=None):
numAmounts = scipy.size(amounts)
if gammas is None:
gammas = scipy.zeros(numAmounts,'d')
JacobianALogTime = scipy.array([(amounts[i]/scipy.sqrt(times))*scipy.exp(-gammas[i]*times) for i in range(numAmounts)])
return JacobianALogTime
def normRows(matrixToPlot):
"""
Useful for plotting and otherwise comparing alignment of rows of matrices.
Be careful that if vec[1] is zero, entire row gets zerod.
"""
return scipy.array([scipy.sign(vec[1])*vec/scipy.sqrt(scipy.dot(vec,vec)) for vec in matrixToPlot])
def transformMatrix(origMatrix, transformation):
n, m =origMatrix.shape
if n == m:
newMat = scipy.dot(transformation,scipy.dot(origMatrix,scipy.transpose(transformation)))
else:
newMat = scipy.dot(transformation,origMatrix)
return newMat
def findPermutation(permMat):
"""
In so far as permMat is a permutation matrix, returns the permutation.
"""
maxs = [(vec.tolist().index(max(vec)), max(vec)) for vec in permMat]
mins = [(vec.tolist().index(min(vec)), min(vec)) for vec in permMat]
for ii in range(len(maxs)):
if maxs[ii][1] < -mins[ii][1]:
maxs[ii] = mins[ii]
return maxs
def makePermutationMatrix(permList):
"""
Takes a list defining the permutation and makes the appropriate matrix.
"""
permList = scipy.array(permList)
n = len(permList)
if 0 not in permList:
permList = permList - 1
permMat = scipy.zeros((n,n),'d')
for ii, jj in enumerate(permList):
permMat[ii,jj] = 1.
return permMat
def timeCostEval(mat, p, numEvals=100):
start = time.time()
for ii in range(numEvals):
Cost = C(p,mat)
stop = time.time()
print "time per eval:", (stop-start)/numEvals
return (stop-start)/numEvals
def timeGammas(listNumGammas, numEvals=1000):
timesToCalc = []
for numGammas in listNumGammas:
gammas = getGammas(numGammas)
jac = getJacobianG(gammas=gammas,times=scipy.arange(500.))
p = scipy.random.random(numGammas*(numGammas-1)/2)-0.5
timePerEval = timeCostEval(jac,p,numEvals)
timesToCalc.append(timePerEval)
return timesToCalc
def plotLevels(levels,offset=0):
xs = [offset+0.6,offset+1.4]
for lvl in levels:
Plotting.semilogy(xs,[lvl,lvl],'k')
return
def eVec(k,n):
eVec = scipy.zeros(n,'d')
eVec[k] = 1.
return eVec
def sLSAlongP(origMatrix,params,k,deltaP):
sLSList = [sumLogSpacings(transformMatrix(origMatrix,ProcessHalfMatrix(params+x*params[k]*eVec(k,len(params))))) for x in scipy.arange(-deltaP,deltaP,deltaP/1000)]
return sLSList
def PRAlongP(params,k,deltaP):
n = len(params)
PRList = [1./ParticipationRatio(ProcessHalfMatrix(params+x*params[k]*eVec(k,n))) for x in scipy.arange(-deltaP,deltaP,deltaP/1000)]
## PRList = [1./ParticipationRatio(transformMatrix(origMatrix,ProcessHalfMatrix(params+x*params[k]*eVec(k,n)))) for x in scipy.arange(-deltaP,deltaP,deltaP/100)]
## PRList = [1.-ParticipationRatio(transformMatrix(origMatrix,ProcessHalfMatrix(params+x*params[k]*eVec(k,n))))/n for x in scipy.arange(-deltaP,deltaP,deltaP/100)]
return PRList
def CostAlongP(origMatrix,params,k,deltaP,weightsRDP=0.,weights2D=0.,weightsLS=0.,weightPR=0.,weightPriors=0.):
n = len(params)
CostList = [C(params+x*params[k]*eVec(k,n),origMatrix, weightsRDP,weights2D,weightsLS,weightPR,weightPriors) for x in scipy.arange(-deltaP,deltaP,deltaP/100)]
return CostList
| netR = amounts*scipy.exp(-gammas*time)
return scipy.sum(netR) |
cloud_settings_settings_sleep_timeout_cloud_garbage_collection.py | # coding: utf-8
"""
Isilon SDK
Isilon SDK - Language bindings for the OneFS API # noqa: E501
OpenAPI spec version: 9
Contact: [email protected]
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
import pprint
import re # noqa: F401
import six
class CloudSettingsSettingsSleepTimeoutCloudGarbageCollection(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'recovery_with_tasks': 'float',
'recovery_without_tasks': 'float',
'with_tasks': 'float',
'without_tasks': 'float'
} | 'with_tasks': 'with_tasks',
'without_tasks': 'without_tasks'
}
def __init__(self, recovery_with_tasks=None, recovery_without_tasks=None, with_tasks=None, without_tasks=None): # noqa: E501
"""CloudSettingsSettingsSleepTimeoutCloudGarbageCollection - a model defined in Swagger""" # noqa: E501
self._recovery_with_tasks = None
self._recovery_without_tasks = None
self._with_tasks = None
self._without_tasks = None
self.discriminator = None
if recovery_with_tasks is not None:
self.recovery_with_tasks = recovery_with_tasks
if recovery_without_tasks is not None:
self.recovery_without_tasks = recovery_without_tasks
if with_tasks is not None:
self.with_tasks = with_tasks
if without_tasks is not None:
self.without_tasks = without_tasks
@property
def recovery_with_tasks(self):
"""Gets the recovery_with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
Sleep timeout for a recovery thread with pending tasks # noqa: E501
:return: The recovery_with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:rtype: float
"""
return self._recovery_with_tasks
@recovery_with_tasks.setter
def recovery_with_tasks(self, recovery_with_tasks):
"""Sets the recovery_with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection.
Sleep timeout for a recovery thread with pending tasks # noqa: E501
:param recovery_with_tasks: The recovery_with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:type: float
"""
self._recovery_with_tasks = recovery_with_tasks
@property
def recovery_without_tasks(self):
"""Gets the recovery_without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
Sleep timeout for a recovery thread without pending tasks # noqa: E501
:return: The recovery_without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:rtype: float
"""
return self._recovery_without_tasks
@recovery_without_tasks.setter
def recovery_without_tasks(self, recovery_without_tasks):
"""Sets the recovery_without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection.
Sleep timeout for a recovery thread without pending tasks # noqa: E501
:param recovery_without_tasks: The recovery_without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:type: float
"""
self._recovery_without_tasks = recovery_without_tasks
@property
def with_tasks(self):
"""Gets the with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
Sleep timeout for a non-recovery thread with pending tasks # noqa: E501
:return: The with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:rtype: float
"""
return self._with_tasks
@with_tasks.setter
def with_tasks(self, with_tasks):
"""Sets the with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection.
Sleep timeout for a non-recovery thread with pending tasks # noqa: E501
:param with_tasks: The with_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:type: float
"""
self._with_tasks = with_tasks
@property
def without_tasks(self):
"""Gets the without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
Sleep timeout for a non-recovery thread without pending tasks # noqa: E501
:return: The without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:rtype: float
"""
return self._without_tasks
@without_tasks.setter
def without_tasks(self, without_tasks):
"""Sets the without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection.
Sleep timeout for a non-recovery thread without pending tasks # noqa: E501
:param without_tasks: The without_tasks of this CloudSettingsSettingsSleepTimeoutCloudGarbageCollection. # noqa: E501
:type: float
"""
self._without_tasks = without_tasks
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, CloudSettingsSettingsSleepTimeoutCloudGarbageCollection):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other |
attribute_map = {
'recovery_with_tasks': 'recovery_with_tasks',
'recovery_without_tasks': 'recovery_without_tasks', |
live_predict.py | # Unsure majority of time but more correct then wrong when thinking of
# Requires more data for training
from data import *
from tkinter import *
from keras.models import load_model
import numpy as np
import threading
import time
# Time variables
start_wait = 10000
wait = 2100
# Set dimensions | root = Tk()
root.geometry(str(w)+'x'+str(h))
root.title('Predictor')
graphing_area = Canvas(root, width=w, height=h)
graphing_area.pack()
# Import model to be used
saved_model = load_model('model.h5')
# Begin data thread
thread = threading.Thread(target=data_loop, args=[False, False, False, 1, False])
thread.start()
# Predicts the input values and returns predicted letter
def predict(values, model):
processed_data = np.expand_dims(np.array([np.abs(np.fft.rfft(np.array(values)))/85000]), 3)
prediction = model.predict(processed_data)
print(prediction[0][0])
if prediction[0][0] < 0.1:
return 'B'
elif prediction[0][0] > 0.9:
return 'A'
else:
return '?'
def display_prediction(canvas, frame, model):
prediction = predict(last_values[-1500:], model)
canvas.delete('all')
canvas.create_text(w / 2, h / 2, font="Arial " + str(int(round(h / 3, 0))), text='Collecting...', anchor='center')
time.sleep(1)
canvas.delete('all')
canvas.create_text(w / 2, h / 2, font="Arial " + str(int(round(h / 3, 0))), text=prediction, anchor='center')
root.after(wait, display_prediction, canvas, frame, model)
root.after(start_wait, display_prediction, graphing_area, root, saved_model)
root.mainloop() | w = 900
h = 556
|
diff.rs | // Copyright 2022 Nydus Developer. All rights reserved.
//
// SPDX-License-Identifier: Apache-2.0
use std::collections::HashMap;
use std::fs::{self, File, OpenOptions};
use std::io::prelude::*;
use std::io::Write;
use std::path::{Path, PathBuf};
use anyhow::Result;
use nydus_utils::{digest::Algorithm, digest::RafsDigest, exec};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use vmm_sys_util::tempdir::TempDir;
use nydus_rafs::metadata::layout::RAFS_ROOT_INODE;
use nydus_rafs::metadata::{RafsInode, RafsMode, RafsSuper};
use nydus_rafs::RafsIoReader;
use nydus_storage::device::BlobChunkInfo;
#[derive(Serialize, Deserialize, Default, Debug, Clone)]
pub struct BuildOutputBlob {
pub blob_id: String,
pub blob_size: u64,
}
#[derive(Serialize, Deserialize, Default, Debug, Clone)]
pub struct BuildOutputArtifact {
pub bootstrap_name: String,
pub blobs: Vec<BuildOutputBlob>,
}
#[derive(Serialize, Deserialize, Default)]
pub struct OutputSerializer {
version: String,
artifacts: Vec<BuildOutputArtifact>,
blobs: Vec<String>,
trace: serde_json::Map<String, serde_json::Value>,
}
struct Mounter {
mountpoint: PathBuf,
}
impl Mounter {
fn mount(mut layer_paths: Vec<&Path>, target_dir: &Path) -> Self |
}
impl Drop for Mounter {
fn drop(&mut self) {
exec(&format!("umount {:?}", self.mountpoint), true).unwrap();
}
}
fn create_dir(path: &Path) -> PathBuf {
fs::create_dir_all(path).unwrap();
path.to_owned()
}
fn create_file(path: &Path, chunks: &[Vec<u8>]) {
let mut file = File::create(path).unwrap();
for chunk in chunks {
file.write_all(chunk).unwrap();
}
}
fn join_string(paths: Vec<&Path>, sep: &str) -> String {
paths
.iter()
.map(|p| p.to_str().unwrap().to_string())
.collect::<Vec<String>>()
.join(sep)
}
struct Skip {
// for option --diff-skip-layer
diff_skip_layer: usize,
// for option --parent-bootstrap
parent_bootstrap: PathBuf,
}
fn diff_build(
work_dir: &Path,
snapshot_paths: Vec<&Path>,
layer_paths: Vec<&Path>,
with_diff_hint: bool,
chunk_dict_bootstrap: Option<&Path>,
skip: Option<Skip>,
) {
let builder = std::env::var("NYDUS_IMAGE")
.unwrap_or_else(|_| String::from("./target-fusedev/release/nydus-image"));
let output_path = work_dir.join("output.json");
let bootstraps_path = create_dir(&work_dir.join("bootstraps"));
let blobs_path = create_dir(&work_dir.join("blobs"));
let cmd = format!(
"
{} create --log-level warn \
--output-json {} \
--compressor none \
--chunk-size 0x1000 {} {} \
--diff-bootstrap-dir {} \
--blob-dir {} \
--source-type diff {} {} {}
",
builder,
output_path.to_str().unwrap(),
chunk_dict_bootstrap
.map(|p| format!("--chunk-dict {}", p.to_str().unwrap()))
.unwrap_or_default(),
if let Some(skip) = skip {
format!(
"--diff-skip-layer {} --parent-bootstrap {}",
skip.diff_skip_layer,
skip.parent_bootstrap.to_str().unwrap(),
)
} else {
String::new()
},
bootstraps_path.to_str().unwrap(),
blobs_path.to_str().unwrap(),
if with_diff_hint {
"--diff-overlay-hint"
} else {
""
},
join_string(snapshot_paths, " "),
if with_diff_hint {
join_string(layer_paths, " ")
} else {
String::new()
},
);
exec(&cmd, false).unwrap();
}
fn generate_chunks(num: usize) -> (Vec<Vec<u8>>, Vec<String>) {
let mut chunks = Vec::new();
let mut digests = Vec::new();
for _ in 0..num {
let chunk = (0..0x1000)
.map(|_| rand::random::<u8>())
.collect::<Vec<u8>>();
let digest = RafsDigest::from_buf(&chunk, Algorithm::Blake3);
chunks.push(chunk);
digests.push(format!("{}", digest));
}
(chunks, digests)
}
fn calc_blob_id(data: &[Vec<u8>]) -> String {
let mut digest = Sha256::new();
for d in data {
digest.update(d);
}
format!("{:x}", digest.finalize())
}
#[test]
fn integration_test_diff_build_with_chunk_dict() {
let tmp_dir_prefix =
std::env::var("TEST_WORKDIR_PREFIX").expect("Please specify `TEST_WORKDIR_PREFIX` env");
let tmp_dir = TempDir::new_with_prefix(format!("{}/", tmp_dir_prefix)).unwrap();
let mut mounts = Vec::new();
// ---------------------------------------------------
// Diff build to chunk-dict bootstrap
// Create layer 1
let layer_dir_1 = create_dir(&tmp_dir.as_path().join("layer-1"));
let (layer_1_chunks_1, layer_1_chunk_digests_1) = generate_chunks(2);
create_file(&layer_dir_1.join("file-1"), &layer_1_chunks_1);
let (layer_1_chunks_2, layer_1_chunk_digests_2) = generate_chunks(1);
create_file(&layer_dir_1.join("file-2"), &layer_1_chunks_2);
let blob_layer_1_digest =
calc_blob_id(&[layer_1_chunks_1.clone(), layer_1_chunks_2.clone()].concat());
// Create snapshot 1
// Equals with layer-1, so nothing to do
let snapshot_dir_1 = layer_dir_1.clone();
// Create layer 2 (dump same blob with layer 1)
let layer_dir_2 = create_dir(&tmp_dir.as_path().join("layer-2"));
create_file(&layer_dir_2.join("file-3"), &layer_1_chunks_1);
create_file(&layer_dir_2.join("file-4"), &layer_1_chunks_2);
// Create snapshot 2
let snapshot_dir_2 = create_dir(&tmp_dir.as_path().join("snapshot-2"));
mounts.push(Mounter::mount(
vec![&layer_dir_1, &layer_dir_2],
&snapshot_dir_2,
));
// Create layer 3 (dump part of the same chunk with layer 1)
let layer_dir_3 = create_dir(&tmp_dir.as_path().join("layer-3"));
create_file(&layer_dir_3.join("file-5"), &[layer_1_chunks_1[1].clone()]);
let (layer_3_chunks_1, layer_3_chunk_digests_1) = generate_chunks(1);
create_file(&layer_dir_3.join("file-6"), &layer_3_chunks_1);
let blob_layer_3_digest =
calc_blob_id(&[vec![layer_1_chunks_1[1].clone()], layer_3_chunks_1.clone()].concat());
// Create snapshot 3
let snapshot_dir_3 = create_dir(&tmp_dir.as_path().join("snapshot-3"));
mounts.push(Mounter::mount(
vec![&layer_dir_1, &layer_dir_2, &layer_dir_3],
&snapshot_dir_3,
));
// Create layer 4 (dump empty blob)
let layer_dir_4 = create_dir(&tmp_dir.as_path().join("layer-4"));
create_file(&layer_dir_4.join("file-7"), &Vec::new());
// Create snapshot 4
let snapshot_dir_4 = create_dir(&tmp_dir.as_path().join("snapshot-4"));
mounts.push(Mounter::mount(
vec![&layer_dir_1, &layer_dir_2, &layer_dir_3, &layer_dir_4],
&snapshot_dir_4,
));
let expected_chunk_dict_bootstrap = [
(PathBuf::from("/"), vec![]),
(
PathBuf::from("/file-1"),
vec![
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[0].clone(),
),
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[1].clone(),
),
],
),
(
PathBuf::from("/file-2"),
vec![(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_2[0].clone(),
)],
),
(
PathBuf::from("/file-3"),
vec![
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[0].clone(),
),
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[1].clone(),
),
],
),
(
PathBuf::from("/file-4"),
vec![(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_2[0].clone(),
)],
),
(
PathBuf::from("/file-5"),
vec![(
1,
blob_layer_3_digest.to_string(),
layer_1_chunk_digests_1[1].clone(),
)],
),
(
PathBuf::from("/file-6"),
vec![(
1,
blob_layer_3_digest.to_string(),
layer_3_chunk_digests_1[0].clone(),
)],
),
(PathBuf::from("/file-7"), vec![]),
]
.iter()
.cloned()
.collect();
// Diff build to a chunk-dict bootstrap
let work_dir_1 = create_dir(&tmp_dir.as_path().join("workdir-1"));
diff_build(
&work_dir_1,
vec![
&snapshot_dir_1,
&snapshot_dir_2,
&snapshot_dir_3,
&snapshot_dir_4,
],
vec![&layer_dir_1, &layer_dir_2, &layer_dir_3, &layer_dir_4],
true,
None,
None,
);
// Check metadata for chunk-dict bootstrap
let file = OpenOptions::new()
.read(true)
.write(false)
.open(work_dir_1.join("bootstraps/bootstrap-3"))
.unwrap();
let mut rs = RafsSuper {
mode: RafsMode::Direct,
validate_digest: true,
..Default::default()
};
let mut reader = Box::new(file) as RafsIoReader;
rs.load(&mut reader).unwrap();
let mut actual = HashMap::new();
let blobs = rs.superblock.get_blob_infos();
rs.walk_dir(RAFS_ROOT_INODE, None, &mut |inode: &dyn RafsInode,
path: &Path|
-> Result<()> {
let mut chunks = Vec::new();
if inode.is_reg() {
inode
.walk_chunks(&mut |chunk: &dyn BlobChunkInfo| -> Result<()> {
chunks.push((
chunk.blob_index(),
blobs[chunk.blob_index() as usize].blob_id().to_string(),
format!("{}", chunk.chunk_id()),
));
Ok(())
})
.unwrap();
}
actual.insert(path.to_path_buf(), chunks);
Ok(())
})
.unwrap();
// Verify chunk-dict bootstrap
assert_eq!(actual, expected_chunk_dict_bootstrap);
let mut file = File::open(&work_dir_1.join("output.json")).unwrap();
let mut contents = String::new();
file.read_to_string(&mut contents).unwrap();
let output: OutputSerializer = serde_json::from_str(&contents).unwrap();
assert_eq!(output.artifacts.len(), 4);
assert_eq!(output.artifacts[3].bootstrap_name, "bootstrap-3");
assert_eq!(output.artifacts[3].blobs[0].blob_id, blob_layer_1_digest);
assert_eq!(output.artifacts[3].blobs[1].blob_id, blob_layer_3_digest);
// ---------------------------------------------------
// Diff build based on a chunk dict bootstrap
// Create layer 5 (includes some chunks in chunk-dict)
let layer_dir_5 = create_dir(&tmp_dir.as_path().join("layer-5"));
create_file(
&layer_dir_5.join("file-8"),
&[layer_1_chunks_1[1].clone(), layer_1_chunks_2[0].clone()],
);
let (layer_5_chunks_1, layer_5_chunk_digests_1) = generate_chunks(2);
create_file(&layer_dir_5.join("file-9"), &layer_5_chunks_1);
let blob_layer_5_digest = calc_blob_id(&layer_5_chunks_1);
// Create snapshot 5
// Equals with layer-5, so nothing to do
let snapshot_dir_5 = layer_dir_5.clone();
// Create layer 6 (includes some chunks in chunk-dict)
let layer_dir_6 = create_dir(&tmp_dir.as_path().join("layer-6"));
let (layer_6_chunks_1, layer_6_chunk_digests_1) = generate_chunks(1);
let blob_layer_6_digest = calc_blob_id(&layer_6_chunks_1);
create_file(
&layer_dir_6.join("file-10"),
&[layer_6_chunks_1[0].clone(), layer_3_chunks_1[0].clone()],
);
// Create snapshot 6
let snapshot_dir_6 = create_dir(&tmp_dir.as_path().join("snapshot-6"));
mounts.push(Mounter::mount(
vec![&layer_dir_5, &layer_dir_6],
&snapshot_dir_6,
));
let expected_bootstrap = [
(PathBuf::from("/"), vec![]),
(
PathBuf::from("/file-8"),
vec![
(
2,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[1].clone(),
),
(
2,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_2[0].clone(),
),
],
),
(
PathBuf::from("/file-9"),
vec![
(
3,
blob_layer_5_digest.to_string(),
layer_5_chunk_digests_1[0].clone(),
),
(
3,
blob_layer_5_digest.to_string(),
layer_5_chunk_digests_1[1].clone(),
),
],
),
(
PathBuf::from("/file-10"),
vec![
(
0,
blob_layer_6_digest.to_string(),
layer_6_chunk_digests_1[0].clone(),
),
(
1,
blob_layer_3_digest.to_string(),
layer_3_chunk_digests_1[0].clone(),
),
],
),
]
.iter()
.cloned()
.collect();
// Diff build based on a chunk dict bootstrap
let chunk_dict_bootstrap_path = &work_dir_1.join("bootstraps/bootstrap-3");
let work_dir_2 = create_dir(&tmp_dir.as_path().join("workdir-2"));
diff_build(
&work_dir_2,
vec![&snapshot_dir_5, &snapshot_dir_6],
vec![&layer_dir_5, &layer_dir_6],
true,
Some(chunk_dict_bootstrap_path),
None,
);
// Check metadata for bootstrap
let file = OpenOptions::new()
.read(true)
.write(false)
.open(work_dir_2.join("bootstraps/bootstrap-1"))
.unwrap();
let mut rs = RafsSuper {
mode: RafsMode::Direct,
validate_digest: true,
..Default::default()
};
let mut reader = Box::new(file) as RafsIoReader;
rs.load(&mut reader).unwrap();
let mut actual = HashMap::new();
let blobs = rs.superblock.get_blob_infos();
rs.walk_dir(RAFS_ROOT_INODE, None, &mut |inode: &dyn RafsInode,
path: &Path|
-> Result<()> {
let mut chunks = Vec::new();
if inode.is_reg() {
inode
.walk_chunks(&mut |chunk: &dyn BlobChunkInfo| -> Result<()> {
chunks.push((
chunk.blob_index(),
blobs[chunk.blob_index() as usize].blob_id().to_string(),
format!("{}", chunk.chunk_id()),
));
Ok(())
})
.unwrap();
}
actual.insert(path.to_path_buf(), chunks);
Ok(())
})
.unwrap();
// Verify bootstrap
assert_eq!(actual, expected_bootstrap);
let mut file = File::open(&work_dir_2.join("output.json")).unwrap();
let mut contents = String::new();
file.read_to_string(&mut contents).unwrap();
let output: OutputSerializer = serde_json::from_str(&contents).unwrap();
assert_eq!(output.artifacts.len(), 2);
assert_eq!(output.artifacts[1].bootstrap_name, "bootstrap-1");
assert_eq!(output.artifacts[1].blobs[0].blob_id, blob_layer_6_digest);
assert_eq!(output.artifacts[1].blobs[1].blob_id, blob_layer_3_digest);
assert_eq!(output.artifacts[1].blobs[2].blob_id, blob_layer_1_digest);
assert_eq!(output.artifacts[1].blobs[3].blob_id, blob_layer_5_digest);
// ---------------------------------------------------
// Diff build based on a build-cache + chunk-dict bootstrap
// Create layer 7
let layer_dir_7 = create_dir(&tmp_dir.as_path().join("layer-7"));
let (layer_7_chunks_1, layer_7_chunk_digests_1) = generate_chunks(2);
create_file(&layer_dir_7.join("file-11"), &layer_7_chunks_1);
let blob_layer_7_digest = calc_blob_id(&layer_7_chunks_1);
// Create layer 8 (includes some chunks in chunk-dict)
let layer_dir_8 = create_dir(&tmp_dir.as_path().join("layer-8"));
let (layer_8_chunks_1, layer_8_chunk_digests_1) = generate_chunks(1);
create_file(
&layer_dir_8.join("file-12"),
&[layer_8_chunks_1[0].clone(), layer_1_chunks_2[0].clone()],
);
let blob_layer_8_digest = calc_blob_id(&[layer_8_chunks_1[0].clone()]);
// Create snapshot 7
let snapshot_dir_7 = create_dir(&tmp_dir.as_path().join("snapshot-7"));
mounts.push(Mounter::mount(
vec![
&layer_dir_1,
&layer_dir_2,
&layer_dir_3,
&layer_dir_4,
&layer_dir_7,
],
&snapshot_dir_7,
));
// Create snapshot 8
let snapshot_dir_8 = create_dir(&tmp_dir.as_path().join("snapshot-8"));
mounts.push(Mounter::mount(
vec![
&layer_dir_1,
&layer_dir_2,
&layer_dir_3,
&layer_dir_4,
&layer_dir_7,
&layer_dir_8,
],
&snapshot_dir_8,
));
let expected_bootstrap = [
(PathBuf::from("/"), vec![]),
(
PathBuf::from("/file-1"),
vec![
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[0].clone(),
),
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[1].clone(),
),
],
),
(
PathBuf::from("/file-2"),
vec![(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_2[0].clone(),
)],
),
(
PathBuf::from("/file-3"),
vec![
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[0].clone(),
),
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_1[1].clone(),
),
],
),
(
PathBuf::from("/file-4"),
vec![(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_2[0].clone(),
)],
),
(
PathBuf::from("/file-5"),
vec![(
3,
blob_layer_3_digest.to_string(),
layer_1_chunk_digests_1[1].clone(),
)],
),
(
PathBuf::from("/file-6"),
vec![(
3,
blob_layer_3_digest.to_string(),
layer_3_chunk_digests_1[0].clone(),
)],
),
(PathBuf::from("/file-7"), vec![]),
(
PathBuf::from("/file-11"),
vec![
(
1,
blob_layer_7_digest.to_string(),
layer_7_chunk_digests_1[0].clone(),
),
(
1,
blob_layer_7_digest.to_string(),
layer_7_chunk_digests_1[1].clone(),
),
],
),
(
PathBuf::from("/file-12"),
vec![
(
2,
blob_layer_8_digest.to_string(),
layer_8_chunk_digests_1[0].clone(),
),
(
0,
blob_layer_1_digest.to_string(),
layer_1_chunk_digests_2[0].clone(),
),
],
),
]
.iter()
.cloned()
.collect();
// Diff build based on a build-cache + chunk-dict bootstrap
let chunk_dict_bootstrap_path = &work_dir_1.join("bootstraps/bootstrap-3");
let work_dir_3 = create_dir(&tmp_dir.as_path().join("workdir-3"));
diff_build(
&work_dir_3,
vec![
&snapshot_dir_1,
&snapshot_dir_2,
&snapshot_dir_3,
&snapshot_dir_4,
&snapshot_dir_7,
&snapshot_dir_8,
],
vec![
&layer_dir_1,
&layer_dir_2,
&layer_dir_3,
&layer_dir_4,
&layer_dir_7,
&layer_dir_8,
],
true,
Some(chunk_dict_bootstrap_path),
Some(Skip {
diff_skip_layer: 3,
parent_bootstrap: work_dir_1.join("bootstraps/bootstrap-3"),
}),
);
// Check metadata for bootstrap
let file = OpenOptions::new()
.read(true)
.write(false)
.open(work_dir_3.join("bootstraps/bootstrap-5"))
.unwrap();
let mut rs = RafsSuper {
mode: RafsMode::Direct,
validate_digest: true,
..Default::default()
};
let mut reader = Box::new(file) as RafsIoReader;
rs.load(&mut reader).unwrap();
let mut actual = HashMap::new();
let blobs = rs.superblock.get_blob_infos();
rs.walk_dir(RAFS_ROOT_INODE, None, &mut |inode: &dyn RafsInode,
path: &Path|
-> Result<()> {
let mut chunks = Vec::new();
if inode.is_reg() {
inode
.walk_chunks(&mut |chunk: &dyn BlobChunkInfo| -> Result<()> {
chunks.push((
chunk.blob_index(),
blobs[chunk.blob_index() as usize].blob_id().to_string(),
format!("{}", chunk.chunk_id()),
));
Ok(())
})
.unwrap();
}
actual.insert(path.to_path_buf(), chunks);
Ok(())
})
.unwrap();
// Verify bootstrap
assert_eq!(actual, expected_bootstrap);
let mut file = File::open(&work_dir_3.join("output.json")).unwrap();
let mut contents = String::new();
file.read_to_string(&mut contents).unwrap();
let output: OutputSerializer = serde_json::from_str(&contents).unwrap();
assert_eq!(output.artifacts.len(), 2);
assert_eq!(output.artifacts[0].bootstrap_name, "bootstrap-4");
assert_eq!(output.artifacts[1].bootstrap_name, "bootstrap-5");
assert_eq!(output.artifacts[1].blobs[0].blob_id, blob_layer_1_digest);
assert_eq!(output.artifacts[1].blobs[1].blob_id, blob_layer_7_digest);
assert_eq!(output.artifacts[1].blobs[2].blob_id, blob_layer_8_digest);
assert_eq!(output.artifacts[1].blobs[3].blob_id, blob_layer_3_digest);
}
| {
layer_paths.reverse();
exec(
&format!(
"mount -t overlay -o lowerdir={} overlay {}",
join_string(layer_paths, ":"),
target_dir.to_str().unwrap(),
),
false,
)
.unwrap();
Self {
mountpoint: target_dir.to_path_buf(),
}
} |
client.go | package redisearch
import (
"errors"
"log"
"reflect"
"strconv"
"strings"
"github.com/gomodule/redigo/redis"
)
// Client is an interface to redisearch's redis commands
type Client struct {
pool ConnPool
name string
}
var maxConns = 500
// NewClient creates a new client connecting to the redis host, and using the given name as key prefix.
// Addr can be a single host:port pair, or a comma separated list of host:port,host:port...
// In the case of multiple hosts we create a multi-pool and select connections at random
func NewClient(addr, name string) *Client {
addrs := strings.Split(addr, ",")
var pool ConnPool
if len(addrs) == 1 {
pool = NewSingleHostPool(addrs[0])
} else {
pool = NewMultiHostPool(addrs)
}
ret := &Client{
pool: pool,
name: name,
}
return ret
}
// NewClientFromPool creates a new Client with the given pool and index name
func NewClientFromPool(pool *redis.Pool, name string) *Client {
ret := &Client{
pool: pool,
name: name,
}
return ret
}
// CreateIndex configures the index and creates it on redis
func (i *Client) CreateIndex(schema *Schema) (err error) {
return i.indexWithDefinition(i.name, schema, nil)
}
// CreateIndexWithIndexDefinition configures the index and creates it on redis
// IndexDefinition is used to define a index definition for automatic indexing on Hash update
func (i *Client) CreateIndexWithIndexDefinition(schema *Schema, definition *IndexDefinition) (err error) {
return i.indexWithDefinition(i.name, schema, definition)
}
// internal method
func (i *Client) indexWithDefinition(indexName string, schema *Schema, definition *IndexDefinition) (err error) {
args := redis.Args{indexName}
if definition != nil {
args = definition.Serialize(args)
}
// Set flags based on options
args, err = SerializeSchema(schema, args)
if err != nil {
return
}
conn := i.pool.Get()
defer conn.Close()
_, err = conn.Do("FT.CREATE", args...)
return
}
// AddField Adds a new field to the index.
func (i *Client) AddField(f Field) error {
args := redis.Args{i.name}
args = append(args, "SCHEMA", "ADD")
args, err := serializeField(f, args)
if err != nil {
return err
}
conn := i.pool.Get()
defer conn.Close()
_, err = conn.Do("FT.ALTER", args...)
return err
}
// Index indexes a list of documents with the default options
func (i *Client) Index(docs ...Document) error {
return i.IndexOptions(DefaultIndexingOptions, docs...)
}
// Search searches the index for the given query, and returns documents,
// the total number of results, or an error if something went wrong
func (i *Client) Search(q *Query) (docs []Document, total int, err error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{i.name}
args = append(args, q.serialize()...)
res, err := redis.Values(conn.Do("FT.SEARCH", args...))
if err != nil {
return
}
if total, err = redis.Int(res[0], nil); err != nil {
return
}
docs = make([]Document, 0, len(res)-1)
skip := 1
scoreIdx := -1
fieldsIdx := -1
payloadIdx := -1
if q.Flags&QueryWithScores != 0 {
scoreIdx = 1
skip++
}
if q.Flags&QueryWithPayloads != 0 {
payloadIdx = skip
skip++
}
if q.Flags&QueryNoContent == 0 {
fieldsIdx = skip
skip++
}
if len(res) > skip {
for i := 1; i < len(res); i += skip {
if d, e := loadDocument(res, i, scoreIdx, payloadIdx, fieldsIdx); e == nil {
docs = append(docs, d)
} else {
log.Print("Error parsing doc: ", e)
}
}
}
return
}
// AliasAdd adds an alias to an index.
// Indexes can have more than one alias, though an alias cannot refer to another alias.
func (i *Client) AliasAdd(name string) (err error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{name}.Add(i.name)
_, err = redis.String(conn.Do("FT.ALIASADD", args...))
return
}
// AliasDel deletes an alias from index.
func (i *Client) AliasDel(name string) (err error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{name}
_, err = redis.String(conn.Do("FT.ALIASDEL", args...))
return
}
// AliasUpdate differs from the AliasAdd in that it will remove the alias association with
// a previous index, if any. AliasAdd will fail, on the other hand, if the alias is already
// associated with another index.
func (i *Client) AliasUpdate(name string) (err error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{name}.Add(i.name)
_, err = redis.String(conn.Do("FT.ALIASUPDATE", args...))
return
}
// DictAdd adds terms to a dictionary.
func (i *Client) DictAdd(dictionaryName string, terms []string) (newTerms int, err error) {
conn := i.pool.Get()
defer conn.Close()
newTerms = 0
args := redis.Args{dictionaryName}.AddFlat(terms)
newTerms, err = redis.Int(conn.Do("FT.DICTADD", args...))
return
}
// DictDel deletes terms from a dictionary
func (i *Client) DictDel(dictionaryName string, terms []string) (deletedTerms int, err error) {
conn := i.pool.Get()
defer conn.Close()
deletedTerms = 0
args := redis.Args{dictionaryName}.AddFlat(terms)
deletedTerms, err = redis.Int(conn.Do("FT.DICTDEL", args...))
return
}
// DictDump dumps all terms in the given dictionary.
func (i *Client) DictDump(dictionaryName string) (terms []string, err error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{dictionaryName}
terms, err = redis.Strings(conn.Do("FT.DICTDUMP", args...))
return
}
// SpellCheck performs spelling correction on a query, returning suggestions for misspelled terms,
// the total number of results, or an error if something went wrong
func (i *Client) SpellCheck(q *Query, s *SpellCheckOptions) (suggs []MisspelledTerm, total int, err error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{i.name}
args = append(args, q.serialize()...)
args = append(args, s.serialize()...)
res, err := redis.Values(conn.Do("FT.SPELLCHECK", args...))
if err != nil {
return
}
total = 0
suggs = make([]MisspelledTerm, 0)
// Each misspelled term, in turn, is a 3-element array consisting of
// - the constant string "TERM" ( 3-element position 0 -- we dont use it )
// - the term itself ( 3-element position 1 )
// - an array of suggestions for spelling corrections ( 3-element position 2 )
termIdx := 1
suggIdx := 2
for i := 0; i < len(res); i++ {
var termArray []interface{} = nil
termArray, err = redis.Values(res[i], nil)
if err != nil {
return
}
if d, e := loadMisspelledTerm(termArray, termIdx, suggIdx); e == nil {
suggs = append(suggs, d)
if d.Len() > 0 {
total++
}
} else {
log.Print("Error parsing misspelled suggestion: ", e)
}
}
return
}
// Deprecated: Use AggregateQuery() instead.
func (i *Client) Aggregate(q *AggregateQuery) (aggregateReply [][]string, total int, err error) {
res, err := i.aggregate(q)
// has no cursor
if !q.WithCursor {
total, aggregateReply, err = processAggReply(res)
// has cursor
} else {
var partialResults, err = redis.Values(res[0], nil)
if err != nil {
return aggregateReply, total, err
}
q.Cursor.Id, err = redis.Int(res[1], nil)
if err != nil {
return aggregateReply, total, err
}
total, aggregateReply, err = processAggReply(partialResults)
}
return
}
// AggregateQuery replaces the Aggregate() function. The reply is slice of maps, with values of either string or []string.
func (i *Client) AggregateQuery(q *AggregateQuery) (total int, aggregateReply []map[string]interface{}, err error) {
res, err := i.aggregate(q)
// has no cursor
if !q.WithCursor {
total, aggregateReply, err = processAggQueryReply(res)
// has cursor
} else {
var partialResults, err = redis.Values(res[0], nil)
if err != nil {
return total, aggregateReply, err
}
q.Cursor.Id, err = redis.Int(res[1], nil)
if err != nil {
return total, aggregateReply, err
}
total, aggregateReply, err = processAggQueryReply(partialResults)
}
return
}
func (i *Client) aggregate(q *AggregateQuery) (res []interface{}, err error) {
conn := i.pool.Get()
defer conn.Close()
validCursor := q.CursorHasResults()
if !validCursor {
args := redis.Args{i.name}
args = append(args, q.Serialize()...)
res, err = redis.Values(conn.Do("FT.AGGREGATE", args...))
} else {
args := redis.Args{"READ", i.name, q.Cursor.Id}
res, err = redis.Values(conn.Do("FT.CURSOR", args...))
}
if err != nil {
return
}
return
}
// Get - Returns the full contents of a document
func (i *Client) Get(docId string) (doc *Document, err error) {
doc = nil
conn := i.pool.Get()
defer conn.Close()
var reply interface{}
args := redis.Args{i.name, docId}
reply, err = conn.Do("FT.GET", args...)
if reply != nil {
var array_reply []interface{}
array_reply, err = redis.Values(reply, err)
if err != nil {
return
}
if len(array_reply) > 0 {
document := NewDocument(docId, 1)
document.loadFields(array_reply)
doc = &document
}
}
return
}
// MultiGet - Returns the full contents of multiple documents.
// Returns an array with exactly the same number of elements as the number of keys sent to the command.
// Each element in it is either an Document or nil if it was not found.
func (i *Client) MultiGet(documentIds []string) (docs []*Document, err error) {
docs = make([]*Document, len(documentIds))
conn := i.pool.Get()
defer conn.Close()
var reply interface{}
args := redis.Args{i.name}.AddFlat(documentIds)
reply, err = conn.Do("FT.MGET", args...)
if reply != nil {
var array_reply []interface{}
array_reply, err = redis.Values(reply, err)
if err != nil {
return
}
for i := 0; i < len(array_reply); i++ {
if array_reply[i] != nil {
var innerArray []interface{}
innerArray, err = redis.Values(array_reply[i], nil)
if err != nil {
return
}
if len(array_reply) > 0 {
document := NewDocument(documentIds[i], 1)
document.loadFields(innerArray)
docs[i] = &document
}
} else {
docs[i] = nil
}
}
}
return
}
// Explain Return a textual string explaining the query (execution plan)
func (i *Client) Explain(q *Query) (string, error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{i.name}
args = append(args, q.serialize()...)
return redis.String(conn.Do("FT.EXPLAIN", args...))
}
// Drop deletes the index and all the keys associated with it.
func (i *Client) Drop() error {
conn := i.pool.Get()
defer conn.Close()
_, err := conn.Do("FT.DROP", i.name)
return err
}
// Deletes the secondary index and optionally the associated hashes
//
// Available since RediSearch 2.0.
//
// By default, DropIndex() which is a wrapper for RediSearch FT.DROPINDEX does not delete the document
// hashes associated with the index. Setting the argument deleteDocuments to true deletes the hashes as well.
func (i *Client) DropIndex(deleteDocuments bool) error {
conn := i.pool.Get()
defer conn.Close()
var err error = nil
if deleteDocuments {
_, err = conn.Do("FT.DROPINDEX", i.name, "DD")
} else {
_, err = conn.Do("FT.DROPINDEX", i.name)
}
return err
}
// Delete the document from the index, optionally delete the actual document
// WARNING: As of RediSearch 2.0 and above, FT.DEL always deletes the underlying document.
// Deprecated: This function is deprecated on RediSearch 2.0 and above, use DeleteDocument() instead
func (i *Client) Delete(docId string, deleteDocument bool) (err error) {
return i.delDoc(docId, deleteDocument)
}
// DeleteDocument delete the document from the index and also delete the HASH key in which the document is stored
func (i *Client) DeleteDocument(docId string) (err error) {
return i.delDoc(docId, true)
}
// Internal method to be used by Delete() and DeleteDocument()
func (i *Client) delDoc(docId string, deleteDocument bool) (err error) {
conn := i.pool.Get()
defer conn.Close()
if deleteDocument {
_, err = conn.Do("FT.DEL", i.name, docId, "DD")
} else {
_, err = conn.Do("FT.DEL", i.name, docId)
}
return
}
// Internal method to be used by Info()
func (info *IndexInfo) setTarget(key string, value interface{}) error {
v := reflect.ValueOf(info).Elem()
for i := 0; i < v.NumField(); i++ {
tag := v.Type().Field(i).Tag.Get("redis")
if tag == key {
targetInfo := v.Field(i)
switch targetInfo.Kind() {
case reflect.String:
s, _ := redis.String(value, nil)
targetInfo.SetString(s)
case reflect.Uint64:
u, _ := redis.Uint64(value, nil)
targetInfo.SetUint(u)
case reflect.Float64:
f, _ := redis.Float64(value, nil)
targetInfo.SetFloat(f)
case reflect.Bool:
f, _ := redis.Uint64(value, nil)
if f == 0 {
targetInfo.SetBool(false)
} else {
targetInfo.SetBool(true)
}
default:
panic("Tag set without handler")
}
return nil
}
}
return errors.New("setTarget: No handler defined for :" + key)
}
func sliceIndex(haystack []string, needle string) int {
for pos, elem := range haystack {
if elem == needle {
return pos
}
}
return -1
}
func (info *IndexInfo) loadSchema(values []interface{}, options []string) {
// Values are a list of fields
scOptions := Options{}
for _, opt := range options {
switch strings.ToUpper(opt) {
case "NOFIELDS":
scOptions.NoFieldFlags = true
case "NOFREQS":
scOptions.NoFrequencies = true
case "NOOFFSETS":
scOptions.NoOffsetVectors = true
}
}
sc := NewSchema(scOptions)
for _, specTmp := range values {
// spec, isArr := specTmp.([]string)
// if !isArr {
// panic("Value is not an array of strings!")
// }
rawSpec, err := redis.Values(specTmp, nil)
if err != nil {
log.Printf("Warning: Couldn't read schema. %s\n", err.Error())
continue
}
spec := make([]string, 0)
// Convert all to string, if not already string
for _, elem := range rawSpec {
s, isString := elem.(string)
if !isString {
s, err = redis.String(elem, err)
if err != nil {
log.Printf("Warning: Couldn't read schema. %s\n", err.Error())
continue
}
}
spec = append(spec, s)
}
// Name, Type,
if len(spec) < 3 {
log.Printf("Invalid spec")
continue
}
var options []string
if len(spec) > 3 {
options = spec[3:]
} else {
options = []string{}
}
f := Field{Name: spec[sliceIndex(spec, "identifier")+1]}
switch strings.ToUpper(spec[sliceIndex(spec, "type")+1]) {
case "TAG":
f.Type = TagField
tfOptions := TagFieldOptions{}
if wIdx := sliceIndex(options, "SEPARATOR"); wIdx != -1 {
tfOptions.Separator = options[wIdx+1][0]
}
f.Options = tfOptions
case "GEO":
f.Type = GeoField
case "NUMERIC":
f.Type = NumericField
nfOptions := NumericFieldOptions{}
if sliceIndex(options, "SORTABLE") != -1 {
nfOptions.Sortable = true
}
f.Options = nfOptions
case "TEXT":
f.Type = TextField
tfOptions := TextFieldOptions{}
if sliceIndex(options, "SORTABLE") != -1 {
tfOptions.Sortable = true
}
if wIdx := sliceIndex(options, "WEIGHT"); wIdx != -1 && wIdx+1 != len(spec) {
weightString := options[wIdx+1]
weight64, _ := strconv.ParseFloat(weightString, 32)
tfOptions.Weight = float32(weight64)
}
f.Options = tfOptions
case "VECTOR":
f.Type = VectorField
f.Options = VectorFieldOptions{}
}
sc = sc.AddField(f)
}
info.Schema = *sc
}
// Info - Get information about the index. This can also be used to check if the
// index exists
func (i *Client) Info() (*IndexInfo, error) {
conn := i.pool.Get()
defer conn.Close()
res, err := redis.Values(conn.Do("FT.INFO", i.name))
if err != nil {
return nil, err
}
ret := IndexInfo{}
var schemaAttributes []interface{}
var indexOptions []string
// Iterate over the values
for ii := 0; ii < len(res); ii += 2 {
key, _ := redis.String(res[ii], nil)
if err := ret.setTarget(key, res[ii+1]); err == nil {
continue
}
switch key {
case "index_options":
indexOptions, _ = redis.Strings(res[ii+1], nil)
case "fields":
schemaAttributes, _ = redis.Values(res[ii+1], nil)
case "attributes":
for _, attr := range res[ii+1].([]interface{}) {
l := len(attr.([]interface{}))
schemaAttributes = append(schemaAttributes, attr.([]interface{})[3:l])
}
}
}
if schemaAttributes != nil {
ret.loadSchema(schemaAttributes, indexOptions)
}
return &ret, nil
}
// Set runtime configuration option
func (i *Client) SetConfig(option string, value string) (string, error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{"SET", option, value}
return redis.String(conn.Do("FT.CONFIG", args...))
}
// Get runtime configuration option value
func (i *Client) GetConfig(option string) (map[string]string, error) { | args := redis.Args{"GET", option}
values, err := redis.Values(conn.Do("FT.CONFIG", args...))
if err != nil {
return nil, err
}
m := make(map[string]string)
valLen := len(values)
for i := 0; i < valLen; i++ {
kvs, _ := redis.Strings(values[i], nil)
if kvs != nil && len(kvs) == 2 {
m[kvs[0]] = kvs[1]
}
}
return m, nil
}
// Get the distinct tags indexed in a Tag field
func (i *Client) GetTagVals(index string, filedName string) ([]string, error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{index, filedName}
return redis.Strings(conn.Do("FT.TAGVALS", args...))
}
// SynAdd adds a synonym group.
// Deprecated: This function is not longer supported on RediSearch 2.0 and above, use SynUpdate instead
func (i *Client) SynAdd(indexName string, terms []string) (int64, error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{indexName}.AddFlat(terms)
return redis.Int64(conn.Do("FT.SYNADD", args...))
}
// SynUpdate updates a synonym group, with additional terms.
func (i *Client) SynUpdate(indexName string, synonymGroupId int64, terms []string) (string, error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{indexName, synonymGroupId}.AddFlat(terms)
return redis.String(conn.Do("FT.SYNUPDATE", args...))
}
// SynDump dumps the contents of a synonym group.
func (i *Client) SynDump(indexName string) (map[string][]int64, error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{indexName}
values, err := redis.Values(conn.Do("FT.SYNDUMP", args...))
if err != nil {
return nil, err
}
valLen := len(values)
if valLen%2 != 0 {
return nil, errors.New("SynDump: expects even number of values result")
}
m := make(map[string][]int64, valLen/2)
for i := 0; i < valLen; i += 2 {
key := values[i].([]byte)
gids, err := redis.Int64s(values[i+1], nil)
if err != nil {
return nil, err
}
m[string(key)] = gids
}
return m, nil
}
// Adds a document to the index from an existing HASH key in Redis.
// Deprecated: This function is not longer supported on RediSearch 2.0 and above, use HSET instead
// See the example ExampleClient_CreateIndexWithIndexDefinition for a deeper understanding on how to move towards using hashes on your application
func (i *Client) AddHash(docId string, score float32, language string, replace bool) (string, error) {
conn := i.pool.Get()
defer conn.Close()
args := redis.Args{i.name, docId, score}
if language != "" {
args = args.Add("LANGUAGE", language)
}
if replace {
args = args.Add("REPLACE")
}
return redis.String(conn.Do("FT.ADDHASH", args...))
}
// Returns a list of all existing indexes.
func (i *Client) List() ([]string, error) {
conn := i.pool.Get()
defer conn.Close()
res, err := redis.Values(conn.Do("FT._LIST"))
if err != nil {
return nil, err
}
var indexes []string
// Iterate over the values
for ii := 0; ii < len(res); ii += 1 {
key, _ := redis.String(res[ii], nil)
indexes = append(indexes, key)
}
return indexes, nil
} | conn := i.pool.Get()
defer conn.Close()
|
User.ts | import { model, Schema } from "mongoose";
const UserSchema = new Schema({
Name: {
type: String,
required: true
},
Birthday: {
type: Date,
required: true
},
Gender: {
type: String,
required: false
},
Lists: [{
type: Schema.Types.ObjectId,
required: true | type: String,
required: true,
unique: true
},
Password: {
type: String,
required: true
},
}, {
versionKey: false, // You should be aware of the outcome after set to false
});
module.exports = model("User", UserSchema); | }],
Username: { |
users_analysis.rs | #[derive(Queryable, Serialize, Deserialize, Debug)]
pub struct | {
pub count_answers: i64,
pub count_is_best_answers: i64,
pub count_questions: i64,
}
| UserAnalysis |
test_data_source_rule.py | import pytest
import json
import os
from lkmltools.linter.rules.filerules.data_source_rule import DataSourceRule
from conftest import get_lookml_from_raw_lookml
def test_run1():
raw_lookml = """
view: aview {
sql_table_name: bqdw.engagement_score ;;
}
"""
lookml = get_lookml_from_raw_lookml(raw_lookml, "aview.view")
relevant, passed = DataSourceRule().run(lookml)
assert relevant
assert passed
if os.path.exists(lookml.infilepath):
os.remove(lookml.infilepath)
def test_run2():
raw_lookml = """
view: aview {
dimension: memberID {
type: string
}
}
"""
lookml = get_lookml_from_raw_lookml(raw_lookml, "aview.view")
relevant, passed = DataSourceRule().run(lookml)
assert relevant
assert not passed
if os.path.exists(lookml.infilepath):
os.remove(lookml.infilepath)
def test_run3():
raw_lookml = """
view: aview {
derived_table: {
sql: SELECT * from table ;;
}
dimension: memberID {
type: string
}
}
"""
lookml = get_lookml_from_raw_lookml(raw_lookml, "aview.view")
relevant, passed = DataSourceRule().run(lookml)
assert relevant
assert passed
if os.path.exists(lookml.infilepath):
os.remove(lookml.infilepath)
def | ():
raw_lookml = """
connection: "datawarehouse"
include: "*.view.lkml"
explore: an_explore {
}
"""
lookml = get_lookml_from_raw_lookml(raw_lookml, "amodel.model")
relevant, passed = DataSourceRule().run(lookml)
assert not relevant
assert not passed
if os.path.exists(lookml.infilepath):
os.remove(lookml.infilepath)
| test_run4 |
useNonNullableContext.ts | import { Context } from 'react'
import { useContext } from 'react'
export function useNonNullableContext<T>(context: Context<T | null>) {
const store = useContext(context) | }
return store
} | if (store === null) {
throw new Error('Store cannot be null, please add a context provider') |
errors.rs | //! Errors for this crate.
use crate::parser;
use std::error;
use std::fmt;
/// An error type for this crate.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum Error<'input> {
/// An error ocurred while parsing.
Parser(parser::Error<'input>),
/// Received more input than expected.
MoreInput,
}
impl<'input> fmt::Display for Error<'input> {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
use self::Error::*;
match *self {
Parser(ref p) => write!(fmt, "parser error: {}", p),
MoreInput => write!(fmt, "more input"),
}
}
}
impl<'input> error::Error for Error<'input> {
fn | (&self) -> &str {
use self::Error::*;
match *self {
Parser(ref p) => p.description(),
MoreInput => "more input",
}
}
}
impl<'input> From<parser::Error<'input>> for Error<'input> {
fn from(value: parser::Error<'input>) -> Self {
Error::Parser(value)
}
}
| description |
utils.go | package vault
import (
"os"
"regexp"
"runtime"
"strings"
)
// ParsePath splits the given path string into its respective secret path
// and contained key parts
func ParsePath(path string) (secret, key string) {
secret = path
if idx := strings.LastIndex(path, ":"); idx >= 0 {
secret = path[:idx]
key = path[idx+1:]
}
secret = Canonicalize(secret)
return
}
// PathHasKey returns true if the given path has a key specified in its syntax.
// False otherwise.
func | (path string) bool {
_, key := ParsePath(path)
return key != ""
}
func Canonicalize(p string) string {
p = strings.TrimSuffix(p, "/")
p = strings.TrimPrefix(p, "/")
re := regexp.MustCompile("//+")
p = re.ReplaceAllString(p, "/")
return p
}
func userHomeDir() string {
if runtime.GOOS == "windows" {
home := os.Getenv("USERPROFILE")
if home == "" {
home = os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
}
return home
}
return os.Getenv("HOME")
}
| PathHasKey |
0059_auto_20190314_1744.py | # Generated by Django 2.1.7 on 2019-03-14 17:44
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("api", "0058_auto_20190312_1716")]
operations = [
migrations.AlterField(
model_name="channel",
name="kind",
field=models.CharField(
choices=[
("email", "Email"), | ("slack", "Slack"),
("pd", "PagerDuty"),
("pagertree", "PagerTree"),
("pagerteam", "Pager Team"),
("po", "Pushover"),
("pushbullet", "Pushbullet"),
("opsgenie", "OpsGenie"),
("victorops", "VictorOps"),
("discord", "Discord"),
("telegram", "Telegram"),
("sms", "SMS"),
("zendesk", "Zendesk"),
("trello", "Trello"),
("matrix", "Matrix"),
],
max_length=20,
),
)
] | ("webhook", "Webhook"),
("hipchat", "HipChat"), |
cri_stats_provider_test.go | /*
Copyright 2017 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 stats
import (
"math/rand"
"os"
"path/filepath"
"runtime"
"testing"
"time"
gomock "github.com/golang/mock/gomock"
cadvisorfs "github.com/google/cadvisor/fs"
cadvisorapiv2 "github.com/google/cadvisor/info/v2"
"github.com/stretchr/testify/assert"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/uuid"
runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1alpha2"
critest "k8s.io/cri-api/pkg/apis/testing"
statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing"
"k8s.io/kubernetes/pkg/kubelet/cm"
kubecontainertest "k8s.io/kubernetes/pkg/kubelet/container/testing"
"k8s.io/kubernetes/pkg/kubelet/kuberuntime"
"k8s.io/kubernetes/pkg/kubelet/leaky"
kubepodtest "k8s.io/kubernetes/pkg/kubelet/pod/testing"
serverstats "k8s.io/kubernetes/pkg/kubelet/server/stats"
"k8s.io/kubernetes/pkg/volume"
)
const (
offsetInodeUsage = iota
offsetUsage
)
const (
seedRoot = 0
seedKubelet = 200
seedMisc = 300
seedSandbox0 = 1000
seedContainer0 = 2000
seedSandbox1 = 3000
seedContainer1 = 4000
seedContainer2 = 5000
seedSandbox2 = 6000
seedContainer3 = 7000
seedSandbox3 = 8000
)
const (
pName0 = "pod0"
pName1 = "pod1"
pName2 = "pod2"
)
const (
cName0 = "container0-name"
cName1 = "container1-name"
cName2 = "container2-name"
cName3 = "container3-name"
cName5 = "container5-name"
cName6 = "container6-name"
cName7 = "container7-name"
cName8 = "container8-name"
)
func TestCRIListPodStats(t *testing.T) {
var (
imageFsMountpoint = "/test/mount/point"
unknownMountpoint = "/unknown/mount/point"
imageFsInfo = getTestFsInfo(2000)
rootFsInfo = getTestFsInfo(1000)
sandbox0 = makeFakePodSandbox("sandbox0-name", "sandbox0-uid", "sandbox0-ns", false)
sandbox0Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox0.PodSandboxStatus.Metadata.Uid))
container0 = makeFakeContainer(sandbox0, cName0, 0, false)
containerStats0 = makeFakeContainerStats(container0, imageFsMountpoint)
containerLogStats0 = makeFakeLogStats(1000)
container1 = makeFakeContainer(sandbox0, cName1, 0, false)
containerStats1 = makeFakeContainerStats(container1, unknownMountpoint)
containerLogStats1 = makeFakeLogStats(2000)
sandbox1 = makeFakePodSandbox("sandbox1-name", "sandbox1-uid", "sandbox1-ns", false)
sandbox1Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox1.PodSandboxStatus.Metadata.Uid))
container2 = makeFakeContainer(sandbox1, cName2, 0, false)
containerStats2 = makeFakeContainerStats(container2, imageFsMountpoint)
containerLogStats2 = makeFakeLogStats(3000)
sandbox2 = makeFakePodSandbox("sandbox2-name", "sandbox2-uid", "sandbox2-ns", false)
sandbox2Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox2.PodSandboxStatus.Metadata.Uid))
container3 = makeFakeContainer(sandbox2, cName3, 0, true)
containerStats3 = makeFakeContainerStats(container3, imageFsMountpoint)
container4 = makeFakeContainer(sandbox2, cName3, 1, false)
containerStats4 = makeFakeContainerStats(container4, imageFsMountpoint)
containerLogStats4 = makeFakeLogStats(4000)
// Running pod with a terminated container and a running container
sandbox3 = makeFakePodSandbox("sandbox3-name", "sandbox3-uid", "sandbox3-ns", false)
sandbox3Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox3.PodSandboxStatus.Metadata.Uid))
container5 = makeFakeContainer(sandbox3, cName5, 0, true)
containerStats5 = makeFakeContainerStats(container5, imageFsMountpoint)
containerLogStats5 = makeFakeLogStats(5000)
container8 = makeFakeContainer(sandbox3, cName8, 0, false)
containerStats8 = makeFakeContainerStats(container8, imageFsMountpoint)
containerLogStats8 = makeFakeLogStats(6000)
// Terminated pod sandbox
sandbox4 = makeFakePodSandbox("sandbox1-name", "sandbox1-uid", "sandbox1-ns", true)
container6 = makeFakeContainer(sandbox4, cName6, 0, true)
containerStats6 = makeFakeContainerStats(container6, imageFsMountpoint)
// Terminated pod
sandbox5 = makeFakePodSandbox("sandbox1-name", "sandbox5-uid", "sandbox1-ns", true)
container7 = makeFakeContainer(sandbox5, cName7, 0, true)
containerStats7 = makeFakeContainerStats(container7, imageFsMountpoint)
podLogName0 = "pod-log-0"
podLogName1 = "pod-log-1"
podLogStats0 = makeFakeLogStats(5000)
podLogStats1 = makeFakeLogStats(6000)
)
var (
mockCadvisor = new(cadvisortest.Mock)
mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
mockPodManager = new(kubepodtest.MockManager)
resourceAnalyzer = new(fakeResourceAnalyzer)
fakeRuntimeService = critest.NewFakeRuntimeService()
fakeImageService = critest.NewFakeImageService()
)
infos := map[string]cadvisorapiv2.ContainerInfo{
"/": getTestContainerInfo(seedRoot, "", "", ""),
"/kubelet": getTestContainerInfo(seedKubelet, "", "", ""),
"/system": getTestContainerInfo(seedMisc, "", "", ""),
sandbox0.PodSandboxStatus.Id: getTestContainerInfo(seedSandbox0, pName0, sandbox0.PodSandboxStatus.Metadata.Namespace, leaky.PodInfraContainerName),
sandbox0Cgroup: getTestContainerInfo(seedSandbox0, "", "", ""),
container0.ContainerStatus.Id: getTestContainerInfo(seedContainer0, pName0, sandbox0.PodSandboxStatus.Metadata.Namespace, cName0),
container1.ContainerStatus.Id: getTestContainerInfo(seedContainer1, pName0, sandbox0.PodSandboxStatus.Metadata.Namespace, cName1),
sandbox1.PodSandboxStatus.Id: getTestContainerInfo(seedSandbox1, pName1, sandbox1.PodSandboxStatus.Metadata.Namespace, leaky.PodInfraContainerName),
sandbox1Cgroup: getTestContainerInfo(seedSandbox1, "", "", ""),
container2.ContainerStatus.Id: getTestContainerInfo(seedContainer2, pName1, sandbox1.PodSandboxStatus.Metadata.Namespace, cName2),
sandbox2.PodSandboxStatus.Id: getTestContainerInfo(seedSandbox2, pName2, sandbox2.PodSandboxStatus.Metadata.Namespace, leaky.PodInfraContainerName),
sandbox2Cgroup: getTestContainerInfo(seedSandbox2, "", "", ""),
container4.ContainerStatus.Id: getTestContainerInfo(seedContainer3, pName2, sandbox2.PodSandboxStatus.Metadata.Namespace, cName3),
sandbox3Cgroup: getTestContainerInfo(seedSandbox3, "", "", ""),
}
options := cadvisorapiv2.RequestOptions{
IdType: cadvisorapiv2.TypeName,
Count: 2,
Recursive: true,
}
mockCadvisor.
On("ContainerInfoV2", "/", options).Return(infos, nil).
On("RootFsInfo").Return(rootFsInfo, nil).
On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil).
On("GetDirFsInfo", unknownMountpoint).Return(cadvisorapiv2.FsInfo{}, cadvisorfs.ErrNoSuchDevice)
fakeRuntimeService.SetFakeSandboxes([]*critest.FakePodSandbox{
sandbox0, sandbox1, sandbox2, sandbox3, sandbox4, sandbox5,
})
fakeRuntimeService.SetFakeContainers([]*critest.FakeContainer{
container0, container1, container2, container3, container4, container5, container6, container7, container8,
})
fakeRuntimeService.SetFakeContainerStats([]*runtimeapi.ContainerStats{
containerStats0, containerStats1, containerStats2, containerStats3, containerStats4, containerStats5, containerStats6, containerStats7, containerStats8,
})
ephemeralVolumes := makeFakeVolumeStats([]string{"ephVolume1, ephVolumes2"})
persistentVolumes := makeFakeVolumeStats([]string{"persisVolume1, persisVolumes2"})
resourceAnalyzer.podVolumeStats = serverstats.PodVolumeStats{
EphemeralVolumes: ephemeralVolumes,
PersistentVolumes: persistentVolumes,
}
fakeLogStats := map[string]*volume.Metrics{
kuberuntime.BuildContainerLogsDirectory("sandbox0-ns", "sandbox0-name", types.UID("sandbox0-uid"), cName0): containerLogStats0,
kuberuntime.BuildContainerLogsDirectory("sandbox0-ns", "sandbox0-name", types.UID("sandbox0-uid"), cName1): containerLogStats1,
kuberuntime.BuildContainerLogsDirectory("sandbox1-ns", "sandbox1-name", types.UID("sandbox1-uid"), cName2): containerLogStats2,
kuberuntime.BuildContainerLogsDirectory("sandbox2-ns", "sandbox2-name", types.UID("sandbox2-uid"), cName3): containerLogStats4,
kuberuntime.BuildContainerLogsDirectory("sandbox3-ns", "sandbox3-name", types.UID("sandbox3-uid"), cName5): containerLogStats5,
kuberuntime.BuildContainerLogsDirectory("sandbox3-ns", "sandbox3-name", types.UID("sandbox3-uid"), cName8): containerLogStats8,
filepath.Join(kuberuntime.BuildPodLogsDirectory("sandbox0-ns", "sandbox0-name", types.UID("sandbox0-uid")), podLogName0): podLogStats0,
filepath.Join(kuberuntime.BuildPodLogsDirectory("sandbox1-ns", "sandbox1-name", types.UID("sandbox1-uid")), podLogName1): podLogStats1,
}
fakeLogStatsProvider := NewFakeLogMetricsService(fakeLogStats)
ctrl := gomock.NewController(t)
defer ctrl.Finish()
fakeOS := &kubecontainertest.FakeOS{}
fakeOS.ReadDirFn = func(path string) ([]os.FileInfo, error) {
var fileInfos []os.FileInfo
mockFI := kubecontainertest.NewMockFileInfo(ctrl)
switch path {
case kuberuntime.BuildPodLogsDirectory("sandbox0-ns", "sandbox0-name", types.UID("sandbox0-uid")):
mockFI.EXPECT().Name().Return(podLogName0)
case kuberuntime.BuildPodLogsDirectory("sandbox1-ns", "sandbox1-name", types.UID("sandbox1-uid")):
mockFI.EXPECT().Name().Return(podLogName1)
default:
return nil, nil
}
mockFI.EXPECT().IsDir().Return(false)
fileInfos = append(fileInfos, mockFI)
return fileInfos, nil
}
provider := NewCRIStatsProvider(
mockCadvisor,
resourceAnalyzer,
mockPodManager,
mockRuntimeCache,
fakeRuntimeService,
fakeImageService,
fakeLogStatsProvider,
fakeOS,
)
stats, err := provider.ListPodStats()
assert := assert.New(t)
assert.NoError(err)
assert.Equal(4, len(stats))
podStatsMap := make(map[statsapi.PodReference]statsapi.PodStats)
for _, s := range stats {
podStatsMap[s.PodRef] = s
}
p0 := podStatsMap[statsapi.PodReference{Name: "sandbox0-name", UID: "sandbox0-uid", Namespace: "sandbox0-ns"}]
assert.Equal(sandbox0.CreatedAt, p0.StartTime.UnixNano())
assert.Equal(2, len(p0.Containers))
checkEphemeralStorageStats(assert, p0, ephemeralVolumes, []*runtimeapi.ContainerStats{containerStats0, containerStats1},
[]*volume.Metrics{containerLogStats0, containerLogStats1}, podLogStats0)
containerStatsMap := make(map[string]statsapi.ContainerStats)
for _, s := range p0.Containers {
containerStatsMap[s.Name] = s
}
c0 := containerStatsMap[cName0]
assert.Equal(container0.CreatedAt, c0.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c0, infos[container0.ContainerStatus.Id].Stats[0])
checkCRIRootfsStats(assert, c0, containerStats0, &imageFsInfo)
checkCRILogsStats(assert, c0, &rootFsInfo, containerLogStats0)
c1 := containerStatsMap[cName1]
assert.Equal(container1.CreatedAt, c1.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c1, infos[container1.ContainerStatus.Id].Stats[0])
checkCRIRootfsStats(assert, c1, containerStats1, nil)
checkCRILogsStats(assert, c1, &rootFsInfo, containerLogStats1)
checkCRINetworkStats(assert, p0.Network, infos[sandbox0.PodSandboxStatus.Id].Stats[0].Network)
checkCRIPodCPUAndMemoryStats(assert, p0, infos[sandbox0Cgroup].Stats[0])
p1 := podStatsMap[statsapi.PodReference{Name: "sandbox1-name", UID: "sandbox1-uid", Namespace: "sandbox1-ns"}]
assert.Equal(sandbox1.CreatedAt, p1.StartTime.UnixNano())
assert.Equal(1, len(p1.Containers))
checkEphemeralStorageStats(assert, p1, ephemeralVolumes, []*runtimeapi.ContainerStats{containerStats2},
[]*volume.Metrics{containerLogStats2}, podLogStats1)
c2 := p1.Containers[0]
assert.Equal(cName2, c2.Name)
assert.Equal(container2.CreatedAt, c2.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c2, infos[container2.ContainerStatus.Id].Stats[0])
checkCRIRootfsStats(assert, c2, containerStats2, &imageFsInfo)
checkCRILogsStats(assert, c2, &rootFsInfo, containerLogStats2)
checkCRINetworkStats(assert, p1.Network, infos[sandbox1.PodSandboxStatus.Id].Stats[0].Network)
checkCRIPodCPUAndMemoryStats(assert, p1, infos[sandbox1Cgroup].Stats[0])
p2 := podStatsMap[statsapi.PodReference{Name: "sandbox2-name", UID: "sandbox2-uid", Namespace: "sandbox2-ns"}]
assert.Equal(sandbox2.CreatedAt, p2.StartTime.UnixNano())
assert.Equal(1, len(p2.Containers))
checkEphemeralStorageStats(assert, p2, ephemeralVolumes, []*runtimeapi.ContainerStats{containerStats4},
[]*volume.Metrics{containerLogStats4}, nil)
c3 := p2.Containers[0]
assert.Equal(cName3, c3.Name)
assert.Equal(container4.CreatedAt, c3.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c3, infos[container4.ContainerStatus.Id].Stats[0])
checkCRIRootfsStats(assert, c3, containerStats4, &imageFsInfo)
checkCRILogsStats(assert, c3, &rootFsInfo, containerLogStats4)
checkCRINetworkStats(assert, p2.Network, infos[sandbox2.PodSandboxStatus.Id].Stats[0].Network)
checkCRIPodCPUAndMemoryStats(assert, p2, infos[sandbox2Cgroup].Stats[0])
p3 := podStatsMap[statsapi.PodReference{Name: "sandbox3-name", UID: "sandbox3-uid", Namespace: "sandbox3-ns"}]
assert.Equal(sandbox3.CreatedAt, p3.StartTime.UnixNano())
assert.Equal(1, len(p3.Containers))
c8 := p3.Containers[0]
assert.Equal(cName8, c8.Name)
assert.Equal(container8.CreatedAt, c8.StartTime.UnixNano())
assert.NotNil(c8.CPU.Time)
assert.NotNil(c8.Memory.Time)
checkCRIPodCPUAndMemoryStats(assert, p3, infos[sandbox3Cgroup].Stats[0])
mockCadvisor.AssertExpectations(t)
}
func TestCRIListPodCPUAndMemoryStats(t *testing.T) {
var (
imageFsMountpoint = "/test/mount/point"
unknownMountpoint = "/unknown/mount/point"
sandbox0 = makeFakePodSandbox("sandbox0-name", "sandbox0-uid", "sandbox0-ns", false)
sandbox0Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox0.PodSandboxStatus.Metadata.Uid))
container0 = makeFakeContainer(sandbox0, cName0, 0, false)
containerStats0 = makeFakeContainerStats(container0, imageFsMountpoint)
container1 = makeFakeContainer(sandbox0, cName1, 0, false)
containerStats1 = makeFakeContainerStats(container1, unknownMountpoint)
sandbox1 = makeFakePodSandbox("sandbox1-name", "sandbox1-uid", "sandbox1-ns", false)
sandbox1Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox1.PodSandboxStatus.Metadata.Uid))
container2 = makeFakeContainer(sandbox1, cName2, 0, false)
containerStats2 = makeFakeContainerStats(container2, imageFsMountpoint)
sandbox2 = makeFakePodSandbox("sandbox2-name", "sandbox2-uid", "sandbox2-ns", false)
sandbox2Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox2.PodSandboxStatus.Metadata.Uid))
container3 = makeFakeContainer(sandbox2, cName3, 0, true)
containerStats3 = makeFakeContainerStats(container3, imageFsMountpoint)
container4 = makeFakeContainer(sandbox2, cName3, 1, false)
containerStats4 = makeFakeContainerStats(container4, imageFsMountpoint)
// Running pod with a terminated container and a running container
sandbox3 = makeFakePodSandbox("sandbox3-name", "sandbox3-uid", "sandbox3-ns", false)
sandbox3Cgroup = "/" + cm.GetPodCgroupNameSuffix(types.UID(sandbox3.PodSandboxStatus.Metadata.Uid))
container5 = makeFakeContainer(sandbox3, cName5, 0, true)
containerStats5 = makeFakeContainerStats(container5, imageFsMountpoint)
container8 = makeFakeContainer(sandbox3, cName8, 0, false)
containerStats8 = makeFakeContainerStats(container8, imageFsMountpoint)
// Terminated pod sandbox
sandbox4 = makeFakePodSandbox("sandbox1-name", "sandbox1-uid", "sandbox1-ns", true)
container6 = makeFakeContainer(sandbox4, cName6, 0, true)
containerStats6 = makeFakeContainerStats(container6, imageFsMountpoint)
// Terminated pod
sandbox5 = makeFakePodSandbox("sandbox1-name", "sandbox5-uid", "sandbox1-ns", true)
container7 = makeFakeContainer(sandbox5, cName7, 0, true)
containerStats7 = makeFakeContainerStats(container7, imageFsMountpoint)
)
var (
mockCadvisor = new(cadvisortest.Mock)
mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
mockPodManager = new(kubepodtest.MockManager)
resourceAnalyzer = new(fakeResourceAnalyzer)
fakeRuntimeService = critest.NewFakeRuntimeService()
)
infos := map[string]cadvisorapiv2.ContainerInfo{
"/": getTestContainerInfo(seedRoot, "", "", ""),
"/kubelet": getTestContainerInfo(seedKubelet, "", "", ""),
"/system": getTestContainerInfo(seedMisc, "", "", ""),
sandbox0.PodSandboxStatus.Id: getTestContainerInfo(seedSandbox0, pName0, sandbox0.PodSandboxStatus.Metadata.Namespace, leaky.PodInfraContainerName),
sandbox0Cgroup: getTestContainerInfo(seedSandbox0, "", "", ""),
container0.ContainerStatus.Id: getTestContainerInfo(seedContainer0, pName0, sandbox0.PodSandboxStatus.Metadata.Namespace, cName0),
container1.ContainerStatus.Id: getTestContainerInfo(seedContainer1, pName0, sandbox0.PodSandboxStatus.Metadata.Namespace, cName1),
sandbox1.PodSandboxStatus.Id: getTestContainerInfo(seedSandbox1, pName1, sandbox1.PodSandboxStatus.Metadata.Namespace, leaky.PodInfraContainerName),
sandbox1Cgroup: getTestContainerInfo(seedSandbox1, "", "", ""),
container2.ContainerStatus.Id: getTestContainerInfo(seedContainer2, pName1, sandbox1.PodSandboxStatus.Metadata.Namespace, cName2),
sandbox2.PodSandboxStatus.Id: getTestContainerInfo(seedSandbox2, pName2, sandbox2.PodSandboxStatus.Metadata.Namespace, leaky.PodInfraContainerName),
sandbox2Cgroup: getTestContainerInfo(seedSandbox2, "", "", ""),
container4.ContainerStatus.Id: getTestContainerInfo(seedContainer3, pName2, sandbox2.PodSandboxStatus.Metadata.Namespace, cName3),
sandbox3Cgroup: getTestContainerInfo(seedSandbox3, "", "", ""),
}
options := cadvisorapiv2.RequestOptions{
IdType: cadvisorapiv2.TypeName,
Count: 2,
Recursive: true,
}
mockCadvisor.
On("ContainerInfoV2", "/", options).Return(infos, nil)
fakeRuntimeService.SetFakeSandboxes([]*critest.FakePodSandbox{
sandbox0, sandbox1, sandbox2, sandbox3, sandbox4, sandbox5,
})
fakeRuntimeService.SetFakeContainers([]*critest.FakeContainer{
container0, container1, container2, container3, container4, container5, container6, container7, container8,
})
fakeRuntimeService.SetFakeContainerStats([]*runtimeapi.ContainerStats{
containerStats0, containerStats1, containerStats2, containerStats3, containerStats4, containerStats5, containerStats6, containerStats7, containerStats8,
})
ephemeralVolumes := makeFakeVolumeStats([]string{"ephVolume1, ephVolumes2"})
persistentVolumes := makeFakeVolumeStats([]string{"persisVolume1, persisVolumes2"})
resourceAnalyzer.podVolumeStats = serverstats.PodVolumeStats{
EphemeralVolumes: ephemeralVolumes,
PersistentVolumes: persistentVolumes,
}
provider := NewCRIStatsProvider(
mockCadvisor,
resourceAnalyzer,
mockPodManager,
mockRuntimeCache,
fakeRuntimeService,
nil,
nil,
&kubecontainertest.FakeOS{},
)
stats, err := provider.ListPodCPUAndMemoryStats()
assert := assert.New(t)
assert.NoError(err)
assert.Equal(4, len(stats))
podStatsMap := make(map[statsapi.PodReference]statsapi.PodStats)
for _, s := range stats {
podStatsMap[s.PodRef] = s
}
p0 := podStatsMap[statsapi.PodReference{Name: "sandbox0-name", UID: "sandbox0-uid", Namespace: "sandbox0-ns"}]
assert.Equal(sandbox0.CreatedAt, p0.StartTime.UnixNano())
assert.Equal(2, len(p0.Containers))
assert.Nil(p0.EphemeralStorage)
assert.Nil(p0.VolumeStats)
assert.Nil(p0.Network)
checkCRIPodCPUAndMemoryStats(assert, p0, infos[sandbox0Cgroup].Stats[0])
containerStatsMap := make(map[string]statsapi.ContainerStats)
for _, s := range p0.Containers {
containerStatsMap[s.Name] = s
}
c0 := containerStatsMap[cName0]
assert.Equal(container0.CreatedAt, c0.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c0, infos[container0.ContainerStatus.Id].Stats[0])
assert.Nil(c0.Rootfs)
assert.Nil(c0.Logs)
assert.Nil(c0.Accelerators)
assert.Nil(c0.UserDefinedMetrics)
c1 := containerStatsMap[cName1]
assert.Equal(container1.CreatedAt, c1.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c1, infos[container1.ContainerStatus.Id].Stats[0])
assert.Nil(c1.Rootfs)
assert.Nil(c1.Logs)
assert.Nil(c1.Accelerators)
assert.Nil(c1.UserDefinedMetrics)
p1 := podStatsMap[statsapi.PodReference{Name: "sandbox1-name", UID: "sandbox1-uid", Namespace: "sandbox1-ns"}]
assert.Equal(sandbox1.CreatedAt, p1.StartTime.UnixNano())
assert.Equal(1, len(p1.Containers))
assert.Nil(p1.EphemeralStorage)
assert.Nil(p1.VolumeStats)
assert.Nil(p1.Network)
checkCRIPodCPUAndMemoryStats(assert, p1, infos[sandbox1Cgroup].Stats[0])
c2 := p1.Containers[0]
assert.Equal(cName2, c2.Name)
assert.Equal(container2.CreatedAt, c2.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c2, infos[container2.ContainerStatus.Id].Stats[0])
assert.Nil(c2.Rootfs)
assert.Nil(c2.Logs)
assert.Nil(c2.Accelerators)
assert.Nil(c2.UserDefinedMetrics)
p2 := podStatsMap[statsapi.PodReference{Name: "sandbox2-name", UID: "sandbox2-uid", Namespace: "sandbox2-ns"}]
assert.Equal(sandbox2.CreatedAt, p2.StartTime.UnixNano())
assert.Equal(1, len(p2.Containers))
assert.Nil(p2.EphemeralStorage)
assert.Nil(p2.VolumeStats)
assert.Nil(p2.Network)
checkCRIPodCPUAndMemoryStats(assert, p2, infos[sandbox2Cgroup].Stats[0])
c3 := p2.Containers[0]
assert.Equal(cName3, c3.Name)
assert.Equal(container4.CreatedAt, c3.StartTime.UnixNano())
checkCRICPUAndMemoryStats(assert, c3, infos[container4.ContainerStatus.Id].Stats[0])
assert.Nil(c2.Rootfs)
assert.Nil(c2.Logs)
assert.Nil(c2.Accelerators)
assert.Nil(c2.UserDefinedMetrics)
p3 := podStatsMap[statsapi.PodReference{Name: "sandbox3-name", UID: "sandbox3-uid", Namespace: "sandbox3-ns"}]
assert.Equal(sandbox3.CreatedAt, p3.StartTime.UnixNano())
assert.Equal(1, len(p3.Containers))
c8 := p3.Containers[0]
assert.Equal(cName8, c8.Name)
assert.Equal(container8.CreatedAt, c8.StartTime.UnixNano())
assert.NotNil(c8.CPU.Time)
assert.NotNil(c8.Memory.Time)
checkCRIPodCPUAndMemoryStats(assert, p3, infos[sandbox3Cgroup].Stats[0])
mockCadvisor.AssertExpectations(t)
}
func TestCRIImagesFsStats(t *testing.T) {
var (
imageFsMountpoint = "/test/mount/point"
imageFsInfo = getTestFsInfo(2000)
imageFsUsage = makeFakeImageFsUsage(imageFsMountpoint)
)
var (
mockCadvisor = new(cadvisortest.Mock)
mockRuntimeCache = new(kubecontainertest.MockRuntimeCache)
mockPodManager = new(kubepodtest.MockManager)
resourceAnalyzer = new(fakeResourceAnalyzer)
fakeRuntimeService = critest.NewFakeRuntimeService()
fakeImageService = critest.NewFakeImageService()
fakeLogStatsProvider = NewFakeLogMetricsService(nil)
)
mockCadvisor.On("GetDirFsInfo", imageFsMountpoint).Return(imageFsInfo, nil)
fakeImageService.SetFakeFilesystemUsage([]*runtimeapi.FilesystemUsage{
imageFsUsage,
})
provider := NewCRIStatsProvider(
mockCadvisor,
resourceAnalyzer,
mockPodManager,
mockRuntimeCache,
fakeRuntimeService,
fakeImageService,
fakeLogStatsProvider,
&kubecontainertest.FakeOS{},
)
stats, err := provider.ImageFsStats()
assert := assert.New(t)
assert.NoError(err)
assert.Equal(imageFsUsage.Timestamp, stats.Time.UnixNano())
assert.Equal(imageFsInfo.Available, *stats.AvailableBytes)
assert.Equal(imageFsInfo.Capacity, *stats.CapacityBytes)
assert.Equal(imageFsInfo.InodesFree, stats.InodesFree)
assert.Equal(imageFsInfo.Inodes, stats.Inodes)
assert.Equal(imageFsUsage.UsedBytes.Value, *stats.UsedBytes)
assert.Equal(imageFsUsage.InodesUsed.Value, *stats.InodesUsed)
mockCadvisor.AssertExpectations(t)
}
func makeFakePodSandbox(name, uid, namespace string, terminated bool) *critest.FakePodSandbox {
p := &critest.FakePodSandbox{
PodSandboxStatus: runtimeapi.PodSandboxStatus{
Metadata: &runtimeapi.PodSandboxMetadata{
Name: name,
Uid: uid,
Namespace: namespace,
},
State: runtimeapi.PodSandboxState_SANDBOX_READY,
CreatedAt: time.Now().UnixNano(),
},
}
if terminated {
p.PodSandboxStatus.State = runtimeapi.PodSandboxState_SANDBOX_NOTREADY
}
p.PodSandboxStatus.Id = string(uuid.NewUUID())
return p
}
func | (sandbox *critest.FakePodSandbox, name string, attempt uint32, terminated bool) *critest.FakeContainer {
sandboxID := sandbox.PodSandboxStatus.Id
c := &critest.FakeContainer{
SandboxID: sandboxID,
ContainerStatus: runtimeapi.ContainerStatus{
Metadata: &runtimeapi.ContainerMetadata{Name: name, Attempt: attempt},
Image: &runtimeapi.ImageSpec{},
ImageRef: "fake-image-ref",
CreatedAt: time.Now().UnixNano(),
},
}
c.ContainerStatus.Labels = map[string]string{
"io.kubernetes.pod.name": sandbox.Metadata.Name,
"io.kubernetes.pod.uid": sandbox.Metadata.Uid,
"io.kubernetes.pod.namespace": sandbox.Metadata.Namespace,
"io.kubernetes.container.name": name,
}
if terminated {
c.ContainerStatus.State = runtimeapi.ContainerState_CONTAINER_EXITED
} else {
c.ContainerStatus.State = runtimeapi.ContainerState_CONTAINER_RUNNING
}
c.ContainerStatus.Id = string(uuid.NewUUID())
return c
}
func makeFakeContainerStats(container *critest.FakeContainer, imageFsMountpoint string) *runtimeapi.ContainerStats {
containerStats := &runtimeapi.ContainerStats{
Attributes: &runtimeapi.ContainerAttributes{
Id: container.ContainerStatus.Id,
Metadata: container.ContainerStatus.Metadata,
},
WritableLayer: &runtimeapi.FilesystemUsage{
Timestamp: time.Now().UnixNano(),
FsId: &runtimeapi.FilesystemIdentifier{Mountpoint: imageFsMountpoint},
UsedBytes: &runtimeapi.UInt64Value{Value: rand.Uint64() / 100},
InodesUsed: &runtimeapi.UInt64Value{Value: rand.Uint64() / 100},
},
}
if container.State == runtimeapi.ContainerState_CONTAINER_EXITED {
containerStats.Cpu = nil
containerStats.Memory = nil
} else {
containerStats.Cpu = &runtimeapi.CpuUsage{
Timestamp: time.Now().UnixNano(),
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{Value: rand.Uint64()},
}
containerStats.Memory = &runtimeapi.MemoryUsage{
Timestamp: time.Now().UnixNano(),
WorkingSetBytes: &runtimeapi.UInt64Value{Value: rand.Uint64()},
}
}
return containerStats
}
func makeFakeImageFsUsage(fsMountpoint string) *runtimeapi.FilesystemUsage {
return &runtimeapi.FilesystemUsage{
Timestamp: time.Now().UnixNano(),
FsId: &runtimeapi.FilesystemIdentifier{Mountpoint: fsMountpoint},
UsedBytes: &runtimeapi.UInt64Value{Value: rand.Uint64()},
InodesUsed: &runtimeapi.UInt64Value{Value: rand.Uint64()},
}
}
func makeFakeVolumeStats(volumeNames []string) []statsapi.VolumeStats {
volumes := make([]statsapi.VolumeStats, len(volumeNames))
availableBytes := rand.Uint64()
capacityBytes := rand.Uint64()
usedBytes := rand.Uint64() / 100
inodes := rand.Uint64()
inodesFree := rand.Uint64()
inodesUsed := rand.Uint64() / 100
for i, name := range volumeNames {
fsStats := statsapi.FsStats{
Time: metav1.NewTime(time.Now()),
AvailableBytes: &availableBytes,
CapacityBytes: &capacityBytes,
UsedBytes: &usedBytes,
Inodes: &inodes,
InodesFree: &inodesFree,
InodesUsed: &inodesUsed,
}
volumes[i] = statsapi.VolumeStats{
FsStats: fsStats,
Name: name,
}
}
return volumes
}
func checkCRICPUAndMemoryStats(assert *assert.Assertions, actual statsapi.ContainerStats, cs *cadvisorapiv2.ContainerStats) {
assert.Equal(cs.Timestamp.UnixNano(), actual.CPU.Time.UnixNano())
assert.Equal(cs.Cpu.Usage.Total, *actual.CPU.UsageCoreNanoSeconds)
assert.Equal(cs.CpuInst.Usage.Total, *actual.CPU.UsageNanoCores)
assert.Equal(cs.Memory.Usage, *actual.Memory.UsageBytes)
assert.Equal(cs.Memory.WorkingSet, *actual.Memory.WorkingSetBytes)
assert.Equal(cs.Memory.RSS, *actual.Memory.RSSBytes)
assert.Equal(cs.Memory.ContainerData.Pgfault, *actual.Memory.PageFaults)
assert.Equal(cs.Memory.ContainerData.Pgmajfault, *actual.Memory.MajorPageFaults)
}
func checkCRIRootfsStats(assert *assert.Assertions, actual statsapi.ContainerStats, cs *runtimeapi.ContainerStats, imageFsInfo *cadvisorapiv2.FsInfo) {
assert.Equal(cs.WritableLayer.Timestamp, actual.Rootfs.Time.UnixNano())
if imageFsInfo != nil {
assert.Equal(imageFsInfo.Available, *actual.Rootfs.AvailableBytes)
assert.Equal(imageFsInfo.Capacity, *actual.Rootfs.CapacityBytes)
assert.Equal(*imageFsInfo.InodesFree, *actual.Rootfs.InodesFree)
assert.Equal(*imageFsInfo.Inodes, *actual.Rootfs.Inodes)
} else {
assert.Nil(actual.Rootfs.AvailableBytes)
assert.Nil(actual.Rootfs.CapacityBytes)
assert.Nil(actual.Rootfs.InodesFree)
assert.Nil(actual.Rootfs.Inodes)
}
assert.Equal(cs.WritableLayer.UsedBytes.Value, *actual.Rootfs.UsedBytes)
assert.Equal(cs.WritableLayer.InodesUsed.Value, *actual.Rootfs.InodesUsed)
}
func checkCRILogsStats(assert *assert.Assertions, actual statsapi.ContainerStats, rootFsInfo *cadvisorapiv2.FsInfo, logStats *volume.Metrics) {
assert.Equal(rootFsInfo.Timestamp, actual.Logs.Time.Time)
assert.Equal(rootFsInfo.Available, *actual.Logs.AvailableBytes)
assert.Equal(rootFsInfo.Capacity, *actual.Logs.CapacityBytes)
assert.Equal(*rootFsInfo.InodesFree, *actual.Logs.InodesFree)
assert.Equal(*rootFsInfo.Inodes, *actual.Logs.Inodes)
assert.Equal(uint64(logStats.Used.Value()), *actual.Logs.UsedBytes)
assert.Equal(uint64(logStats.InodesUsed.Value()), *actual.Logs.InodesUsed)
}
func checkEphemeralStorageStats(assert *assert.Assertions,
actual statsapi.PodStats,
volumes []statsapi.VolumeStats,
containers []*runtimeapi.ContainerStats,
containerLogStats []*volume.Metrics,
podLogStats *volume.Metrics) {
var totalUsed, inodesUsed uint64
for _, container := range containers {
totalUsed = totalUsed + container.WritableLayer.UsedBytes.Value
inodesUsed = inodesUsed + container.WritableLayer.InodesUsed.Value
}
for _, volume := range volumes {
totalUsed = totalUsed + *volume.FsStats.UsedBytes
inodesUsed = inodesUsed + *volume.FsStats.InodesUsed
}
for _, logStats := range containerLogStats {
totalUsed = totalUsed + uint64(logStats.Used.Value())
inodesUsed = inodesUsed + uint64(logStats.InodesUsed.Value())
}
if podLogStats != nil {
totalUsed = totalUsed + uint64(podLogStats.Used.Value())
inodesUsed = inodesUsed + uint64(podLogStats.InodesUsed.Value())
}
assert.Equal(int(totalUsed), int(*actual.EphemeralStorage.UsedBytes))
assert.Equal(int(inodesUsed), int(*actual.EphemeralStorage.InodesUsed))
}
func checkCRINetworkStats(assert *assert.Assertions, actual *statsapi.NetworkStats, expected *cadvisorapiv2.NetworkStats) {
assert.Equal(expected.Interfaces[0].RxBytes, *actual.RxBytes)
assert.Equal(expected.Interfaces[0].RxErrors, *actual.RxErrors)
assert.Equal(expected.Interfaces[0].TxBytes, *actual.TxBytes)
assert.Equal(expected.Interfaces[0].TxErrors, *actual.TxErrors)
}
func checkCRIPodCPUAndMemoryStats(assert *assert.Assertions, actual statsapi.PodStats, cs *cadvisorapiv2.ContainerStats) {
if runtime.GOOS != "linux" {
return
}
assert.Equal(cs.Timestamp.UnixNano(), actual.CPU.Time.UnixNano())
assert.Equal(cs.Cpu.Usage.Total, *actual.CPU.UsageCoreNanoSeconds)
assert.Equal(cs.CpuInst.Usage.Total, *actual.CPU.UsageNanoCores)
assert.Equal(cs.Memory.Usage, *actual.Memory.UsageBytes)
assert.Equal(cs.Memory.WorkingSet, *actual.Memory.WorkingSetBytes)
assert.Equal(cs.Memory.RSS, *actual.Memory.RSSBytes)
assert.Equal(cs.Memory.ContainerData.Pgfault, *actual.Memory.PageFaults)
assert.Equal(cs.Memory.ContainerData.Pgmajfault, *actual.Memory.MajorPageFaults)
}
func makeFakeLogStats(seed int) *volume.Metrics {
m := &volume.Metrics{}
m.Used = resource.NewQuantity(int64(seed+offsetUsage), resource.BinarySI)
m.InodesUsed = resource.NewQuantity(int64(seed+offsetInodeUsage), resource.BinarySI)
return m
}
func TestGetContainerUsageNanoCores(t *testing.T) {
var value0 uint64
var value1 uint64 = 10000000000
// Test with a large container of 100+ CPUs
var value2 uint64 = 188427786383
tests := []struct {
desc string
cpuUsageCache map[string]*cpuUsageRecord
stats *runtimeapi.ContainerStats
expected *uint64
}{
{
desc: "should return nil if stats is nil",
cpuUsageCache: map[string]*cpuUsageRecord{},
},
{
desc: "should return nil if cpu stats is nil",
cpuUsageCache: map[string]*cpuUsageRecord{},
stats: &runtimeapi.ContainerStats{
Attributes: &runtimeapi.ContainerAttributes{
Id: "1",
},
Cpu: nil,
},
},
{
desc: "should return nil if usageCoreNanoSeconds is nil",
cpuUsageCache: map[string]*cpuUsageRecord{},
stats: &runtimeapi.ContainerStats{
Attributes: &runtimeapi.ContainerAttributes{
Id: "1",
},
Cpu: &runtimeapi.CpuUsage{
Timestamp: 1,
UsageCoreNanoSeconds: nil,
},
},
},
{
desc: "should return nil if cpu stats is not cached yet",
cpuUsageCache: map[string]*cpuUsageRecord{},
stats: &runtimeapi.ContainerStats{
Attributes: &runtimeapi.ContainerAttributes{
Id: "1",
},
Cpu: &runtimeapi.CpuUsage{
Timestamp: 1,
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{
Value: 10000000000,
},
},
},
},
{
desc: "should return zero value if cached cpu stats is equal to current value",
stats: &runtimeapi.ContainerStats{
Attributes: &runtimeapi.ContainerAttributes{
Id: "1",
},
Cpu: &runtimeapi.CpuUsage{
Timestamp: 1,
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{
Value: 10000000000,
},
},
},
cpuUsageCache: map[string]*cpuUsageRecord{
"1": {
stats: &runtimeapi.CpuUsage{
Timestamp: 0,
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{
Value: 10000000000,
},
},
},
},
expected: &value0,
},
{
desc: "should return correct value if cached cpu stats is not equal to current value",
stats: &runtimeapi.ContainerStats{
Attributes: &runtimeapi.ContainerAttributes{
Id: "1",
},
Cpu: &runtimeapi.CpuUsage{
Timestamp: int64(time.Second / time.Nanosecond),
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{
Value: 20000000000,
},
},
},
cpuUsageCache: map[string]*cpuUsageRecord{
"1": {
stats: &runtimeapi.CpuUsage{
Timestamp: 0,
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{
Value: 10000000000,
},
},
},
},
expected: &value1,
},
{
desc: "should return correct value if elapsed UsageCoreNanoSeconds exceeds 18446744073",
stats: &runtimeapi.ContainerStats{
Attributes: &runtimeapi.ContainerAttributes{
Id: "1",
},
Cpu: &runtimeapi.CpuUsage{
Timestamp: int64(time.Second / time.Nanosecond),
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{
Value: 68172016162105,
},
},
},
cpuUsageCache: map[string]*cpuUsageRecord{
"1": {
stats: &runtimeapi.CpuUsage{
Timestamp: 0,
UsageCoreNanoSeconds: &runtimeapi.UInt64Value{
Value: 67983588375722,
},
},
},
},
expected: &value2,
},
}
for _, test := range tests {
provider := &criStatsProvider{cpuUsageCache: test.cpuUsageCache}
// Before the update, the cached value should be nil
cached := provider.getContainerUsageNanoCores(test.stats)
assert.Nil(t, cached)
// Update the cache and get the latest value.
real := provider.getAndUpdateContainerUsageNanoCores(test.stats)
assert.Equal(t, test.expected, real, test.desc)
// After the update, the cached value should be up-to-date
cached = provider.getContainerUsageNanoCores(test.stats)
assert.Equal(t, test.expected, cached, test.desc)
}
}
| makeFakeContainer |
sdk_driver.go | package test
import (
"os"
"os/exec"
"path/filepath"
"testing"
"github.com/pulumi/pulumi/pkg/v3/codegen"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type ThenFunc func(t *testing.T, testDir string)
type sdkTest struct {
Directory string
Description string
Skip codegen.StringSet
Then map[string]ThenFunc
}
var sdkTests = []sdkTest{
{
Directory: "input-collision",
Description: "Schema with types that could potentially produce collisions (go).",
},
{
Directory: "dash-named-schema",
Description: "Simple schema with a two part name (foo-bar)",
},
{
Directory: "external-resource-schema",
Description: "External resource schema",
},
{
Directory: "nested-module",
Description: "Nested module",
},
{
Directory: "nested-module-thirdparty",
Description: "Third-party nested module",
},
{
Directory: "plain-schema-gh6957",
Description: "Repro for #6957",
},
{
Directory: "resource-args-python",
Description: "Resource args with same named resource and type",
Then: map[string]ThenFunc{
"go": func(t *testing.T, testDir string) {
cmd := exec.Command("go", "test", "./...")
cmd.Dir = filepath.Join(testDir, "go-program")
out, err := cmd.CombinedOutput()
if !assert.NoError(t, err) {
t.Logf("output: %v", string(out))
}
},
},
},
{
Directory: "simple-enum-schema",
Description: "Simple schema with enum types",
},
{
Directory: "simple-plain-schema",
Description: "Simple schema with plain properties",
},
{
Directory: "simple-plain-schema-with-root-package",
Description: "Simple schema with root package set", | Directory: "simple-resource-schema",
Description: "Simple schema with local resource properties",
},
{
Directory: "simple-resource-schema-custom-pypackage-name",
Description: "Simple schema with local resource properties and custom Python package name",
},
{
Directory: "simple-methods-schema",
Description: "Simple schema with methods",
},
{
Directory: "simple-yaml-schema",
Description: "Simple schema encoded using YAML",
},
{
Directory: "provider-config-schema",
Description: "Simple provider config schema",
},
{
Directory: "replace-on-change",
Description: "Simple use of replaceOnChange in schema",
},
}
// TestSDKCodegen runs the complete set of SDK code generation tests against a particular language's code generator.
//
// An SDK code generation test consists of a schema and a set of expected outputs for each language. Each test is
// structured as a directory that contains that information:
//
// test-directory/
// schema.(json|yaml)
// language-0
// ...
// language-n
//
// The schema is the only piece that must be manually authored. Once the schema has been written, the expected outputs
// can be generated by running `PULUMI_ACCEPT=true go test ./..." from the `pkg/codegen` directory.
func TestSDKCodegen(t *testing.T, language string, genPackage GenPkgSignature) {
testDir := filepath.Join("..", "internal", "test", "testdata")
for _, tt := range sdkTests {
t.Run(tt.Description, func(t *testing.T) {
if tt.Skip.Has(language) {
t.Skip()
return
}
dirPath := filepath.Join(testDir, filepath.FromSlash(tt.Directory))
schemaPath := filepath.Join(dirPath, "schema.json")
if _, err := os.Stat(schemaPath); err != nil && os.IsNotExist(err) {
schemaPath = filepath.Join(dirPath, "schema.yaml")
}
files, err := GeneratePackageFilesFromSchema(schemaPath, genPackage)
require.NoError(t, err)
if !RewriteFilesWhenPulumiAccept(t, dirPath, language, files) {
expectedFiles, err := LoadBaseline(dirPath, language)
require.NoError(t, err)
if !ValidateFileEquality(t, files, expectedFiles) {
return
}
}
if then, ok := tt.Then[language]; ok {
then(t, dirPath)
}
})
}
} | },
{ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.