file_name
large_stringlengths 4
140
| prefix
large_stringlengths 0
12.1k
| suffix
large_stringlengths 0
12k
| middle
large_stringlengths 0
7.51k
| fim_type
large_stringclasses 4
values |
|---|---|---|---|---|
infer_lst.py | Enhance
import torchvision.transforms as T
import numpy as np
import torch
from torch.utils.data import DataLoader
import datasets
import util.misc as utils
from util import box_ops
import datasets.samplers as samplers
from datasets import build_dataset, get_coco_api_from_dataset
from engine import evaluate, train_one_epoch
from models import build_model
import time
import os
def get_args_parser():
parser = argparse.ArgumentParser('Deformable DETR Detector', add_help=False)
parser.add_argument('--lr', default=2e-4, type=float)
parser.add_argument('--lr_backbone_names', default=["backbone.0"], type=str, nargs='+')
parser.add_argument('--lr_backbone', default=2e-5, type=float)
parser.add_argument('--lr_linear_proj_names', default=['reference_points', 'sampling_offsets'], type=str, nargs='+')
parser.add_argument('--lr_linear_proj_mult', default=0.1, type=float)
parser.add_argument('--batch_size', default=2, type=int)
parser.add_argument('--weight_decay', default=1e-4, type=float)
parser.add_argument('--epochs', default=50, type=int)
parser.add_argument('--lr_drop', default=40, type=int)
parser.add_argument('--lr_drop_epochs', default=None, type=int, nargs='+')
parser.add_argument('--clip_max_norm', default=0.1, type=float,
help='gradient clipping max norm')
parser.add_argument('--sgd', action='store_true')
# Variants of Deformable DETR
parser.add_argument('--with_box_refine', default=False, action='store_true')
parser.add_argument('--two_stage', default=False, action='store_true')
# Model parameters
parser.add_argument('--frozen_weights', type=str, default=None,
help="Path to the pretrained model. If set, only the mask head will be trained")
# * Backbone
parser.add_argument('--backbone', default='resnet50', type=str,
help="Name of the convolutional backbone to use")
parser.add_argument('--dilation', action='store_true',
help="If true, we replace stride with dilation in the last convolutional block (DC5)")
parser.add_argument('--position_embedding', default='sine', type=str, choices=('sine', 'learned'),
help="Type of positional embedding to use on top of the image features")
parser.add_argument('--position_embedding_scale', default=2 * np.pi, type=float,
help="position / size * scale")
parser.add_argument('--num_feature_levels', default=4, type=int, help='number of feature levels')
# * Transformer
parser.add_argument('--enc_layers', default=6, type=int,
help="Number of encoding layers in the transformer")
parser.add_argument('--dec_layers', default=6, type=int,
help="Number of decoding layers in the transformer")
parser.add_argument('--dim_feedforward', default=1024, type=int,
help="Intermediate size of the feedforward layers in the transformer blocks")
parser.add_argument('--hidden_dim', default=256, type=int,
help="Size of the embeddings (dimension of the transformer)")
parser.add_argument('--dropout', default=0.1, type=float,
help="Dropout applied in the transformer")
parser.add_argument('--nheads', default=8, type=int,
help="Number of attention heads inside the transformer's attentions")
parser.add_argument('--num_queries', default=300, type=int,
help="Number of query slots")
parser.add_argument('--dec_n_points', default=4, type=int)
parser.add_argument('--enc_n_points', default=4, type=int)
# * Segmentation
parser.add_argument('--masks', action='store_true',
help="Train segmentation head if the flag is provided")
# Loss
parser.add_argument('--no_aux_loss', dest='aux_loss', action='store_false',
help="Disables auxiliary decoding losses (loss at each layer)")
# * Matcher
parser.add_argument('--set_cost_class', default=2, type=float,
help="Class coefficient in the matching cost")
parser.add_argument('--set_cost_bbox', default=5, type=float,
help="L1 box coefficient in the matching cost")
parser.add_argument('--set_cost_giou', default=2, type=float,
help="giou box coefficient in the matching cost")
# * Loss coefficients
parser.add_argument('--mask_loss_coef', default=1, type=float)
parser.add_argument('--dice_loss_coef', default=1, type=float)
parser.add_argument('--cls_loss_coef', default=2, type=float)
parser.add_argument('--bbox_loss_coef', default=5, type=float)
parser.add_argument('--giou_loss_coef', default=2, type=float)
parser.add_argument('--focal_alpha', default=0.25, type=float)
# dataset parameters
parser.add_argument('--dataset_file', default='ICDAR2013')
parser.add_argument('--coco_path', default='./data/coco', type=str)
parser.add_argument('--coco_panoptic_path', type=str)
parser.add_argument('--remove_difficult', action='store_true')
parser.add_argument('--output_dir', default='',
help='path where to save, empty for no saving')
parser.add_argument('--device', default='cuda',
help='device to use for training / testing')
parser.add_argument('--seed', default=42, type=int)
parser.add_argument('--resume', default='', help='resume from checkpoint')
parser.add_argument('--start_epoch', default=0, type=int, metavar='N',
help='start epoch')
parser.add_argument('--imgs_dir', type=str, help='input images folder for inference')
parser.add_argument('--eval', action='store_true')
parser.add_argument('--num_workers', default=2, type=int)
parser.add_argument('--cache_mode', default=False, action='store_true', help='whether to cache images on memory')
return parser
# standard PyTorch mean-std input image normalization
transform = T.Compose([
T.Resize(800),
T.ToTensor(),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
label_names = ['table', 'figure', 'natural_image', 'logo', 'signature']
colors = ['red', 'blue', 'green', 'yellow', 'black']
def | (args):
utils.init_distributed_mode(args)
print("git:\n {}\n".format(utils.get_sha()))
if args.frozen_weights is not None:
assert args.masks, "Frozen training is meant for segmentation only"
print(args)
device = torch.device(args.device)
# fix the seed for reproducibility
seed = args.seed + utils.get_rank()
torch.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
model, criterion, postprocessors = build_model(args)
model.to(device)
checkpoint = torch.load(args.resume, map_location='cpu')
model.load_state_dict(checkpoint['model'], strict=False)
if torch.cuda.is_available():
model.cuda()
model.eval()
for img_file in os.listdir(args.imgs_dir):
t0 = time.time()
img_path = os.path.join(args.imgs_dir, img_file)
out_imgName = './visualize/'+'out_'+img_file[:-4]+'.png'
im = Image.open(img_path)
# mean-std normalize the input image (batch-size: 1)
img = transform(im).unsqueeze(0)
img=img.cuda()
# propagate through the model
outputs = model(img)
out_logits, out_bbox = outputs['pred_logits'], outputs['pred_boxes']
prob = out_logits.sigmoid()
topk_values, topk_indexes = torch.topk(prob.view(out_logits.shape[0], -1), 100, dim=1)
scores = topk_values
topk_boxes = topk_indexes // out_logits.shape[2]
labels = topk_indexes % out_logits.shape[2]
boxes = box_ops.box_cxcywh_to_xyxy(out_bbox)
boxes = torch.gather(boxes, 1, topk_boxes.unsqueeze(-1).repeat(1,1,4))
keep = scores[0] > 0.2
boxes = boxes[0, keep]
labels = labels[0, keep]
# and from relative [0, 1] to absolute [0, height] coordinates
im_h,im_w = im.size
#print('im_h,im_w',im_h,im_w)
target_sizes =torch.tensor([[im_w,im_h]])
target_sizes =target_sizes.cuda()
img_h, img_w = target_sizes.unbind(1)
scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1)
boxes = boxes * scale_fct[:, None, :]
print(time.time()-t0)
#plot_results
source_img = Image.open(img_path).convert("RGBA")
fnt = ImageFont.truetype("/content/content/Deformable-DETR/font/Aaargh.ttf", 18)
draw = ImageDraw.Draw(source_img)
#print ('label' , labels.tolist())
label | main | identifier_name |
server.rs | // NewService,
// Service,
// };
// use actix_server::{ServerConfig};
// use actix_web::dev::Server
use actix::prelude::*;
// use bytes::{BytesMut, Bytes};
// use futures::{
// future::{
// ok,
// join_all,
// Future,
// },
// Async, Poll,
// };
// use serde_json::to_writer;
// use actix_web::{
// App,
// web,
// middleware,
// Error as AWError,
// HttpResponse,
// HttpRequest,
// HttpServer,
// };
// use actix_web_actors::ws::{Message as WsMessage, CloseCode, CloseReason };
// use askama::Template;
//use actix_redis::{Command, RedisActor, Error as ARError};
use actix_redis::{RedisActor};
// use redis_async::{
// client::{PairedConnection, paired_connect, PubsubConnection, pubsub_connect},
// resp::{RespValue},
// };
use crate::ws::{Close as WsClose, WsSession};
// use super::db::{RedisConnection};
// pub struct App {
// // db: PgConnection,
// db: RedisConnection,
// // db: Arc<PairedConnection>,
// hdr_srv: HeaderValue,
// hdr_ctjson: HeaderValue,
// hdr_cthtml: HeaderValue,
// }
// impl Service for App {
// type Request = Request;
// type Response = Response;
// type Error = Error;
// type Future = Box<dyn Future<Item = Response, Error = Error>>;
// #[inline]
// fn poll_ready(&mut self) -> Poll<(), Self::Error> {
// Ok(Async::Ready(()))
// }
// fn call(&mut self, req: Request) -> Self::Future {
// let path = req.path();
// match path {
// "/db" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_ctjson.clone();
// Box::new(self.db.get("mydomain:one")
// .map(|v:String| {
// let mut body = BytesMut::new();
// serde_json::to_writer(Writer(&mut body), &Message{
// message: &*v
// }).unwrap();
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// })
// )
// }
// "/fortune" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_cthtml.clone();
// // Box::new(self.db.tell_fortune().from_err().map(move |fortunes| {
// Box::new(ok({
// let mut body = BytesMut::with_capacity(2048);
// let mut writer = Writer(&mut body);
// let _ = write!(writer, "{}", HelloTemplate { name : "tester" });//FortunesTemplate { fortunes });
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// }))
// }
// "/json" => {
// Box::new(ok(json()))
// }
// "/plaintext" => {
// Box::new(ok(plaintext()))
// }
// // "/queries" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.get_worlds(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// // "/updates" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.update(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// _ => Box::new(ok(Response::new(StatusCode::NOT_FOUND))),
// }
// }
// }
// #[derive(Clone)]
// pub struct AppFactory;
// impl NewService for AppFactory {
// type Config = ServerConfig;
// type Request = Request;
// type Response = Response;
// type Error = Error;
// type Service = App;
// type InitError = ();
// type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
// fn new_service(&self, _: &ServerConfig) -> Self::Future {
// // const DB_URL: &str =
// // "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
// // Box::new(PgConnection::connect(DB_URL).map(|db| App {
// // db,
// // hdr_srv: HeaderValue::from_static("Actix"),
// // hdr_ctjson: HeaderValue::from_static("application/json"),
// // hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// // }));
// Box::new(
// // paired_connect(&String::from(DB_URL).parse().unwrap())
// RedisConnection::connect(DB_URL)
// .map_err(|_| ())
// .map(|db|{
// let app = App {
// db,
// hdr_srv: HeaderValue::from_static("Actix"),
// hdr_ctjson: HeaderValue::from_static("application/json"),
// hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// };
// app
// })
// // })
// )
// }
// }
// pub fn json() -> HttpResponse {
// let message = Message {
// message: "Hello, World!",
// };
// let mut body = BytesMut::with_capacity(SIZE);
// serde_json::to_writer(Writer(&mut body), &message).unwrap();
// let mut res = HttpResponse::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
// res
// }
// fn plaintext() -> HttpResponse {
// let mut res = HttpResponse::with_body(
// StatusCode::OK,
// Body::Bytes(Bytes::from_static(b"Hello, World!")),
// );
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
// res
// }
// #[derive(Template)]
// #[template(path = "test.html")]
// struct HelloTemplate<'a> {
// name: &'a str,
// }
// pub fn root_handler(
// req: web::HttpRequest
// ) -> impl Future<Item = HttpResponse, Error = ()> {
// let path = req.match_info().query("filename").parse().unwrap();
// HttpResponse::from(
// Ok( NamedFile::open(path).unwrap() )
// )
// // ok( HttpResponse::Ok().body("hi"))
// // Ok(HttpResponse::InternalServerError().finish())
// }
pub struct WsServer {
sessions: Vec<Addr<WsSession>>,
db: Addr<RedisActor>,
}
impl Actor for WsServer {
type Context = Context<Self>;
}
impl WsServer {
pub fn new(db : Addr<RedisActor>) -> WsServer {
let sessions = vec![];
WsServer { sessions, db }
}
}
impl WsServer {
fn close_all(&self) {
// for s in &*self.sessions.lock().unwrap() {
for s in &self.sessions {
// if let Some(v) = s.upgrade(){
if s.connected() {
| // StatusCode,
// },
// Error, Request, Response,
// };
// use actix_service::{ | random_line_split |
|
server.rs | req.path();
// match path {
// "/db" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_ctjson.clone();
// Box::new(self.db.get("mydomain:one")
// .map(|v:String| {
// let mut body = BytesMut::new();
// serde_json::to_writer(Writer(&mut body), &Message{
// message: &*v
// }).unwrap();
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// })
// )
// }
// "/fortune" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_cthtml.clone();
// // Box::new(self.db.tell_fortune().from_err().map(move |fortunes| {
// Box::new(ok({
// let mut body = BytesMut::with_capacity(2048);
// let mut writer = Writer(&mut body);
// let _ = write!(writer, "{}", HelloTemplate { name : "tester" });//FortunesTemplate { fortunes });
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// }))
// }
// "/json" => {
// Box::new(ok(json()))
// }
// "/plaintext" => {
// Box::new(ok(plaintext()))
// }
// // "/queries" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.get_worlds(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// // "/updates" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.update(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// _ => Box::new(ok(Response::new(StatusCode::NOT_FOUND))),
// }
// }
// }
// #[derive(Clone)]
// pub struct AppFactory;
// impl NewService for AppFactory {
// type Config = ServerConfig;
// type Request = Request;
// type Response = Response;
// type Error = Error;
// type Service = App;
// type InitError = ();
// type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
// fn new_service(&self, _: &ServerConfig) -> Self::Future {
// // const DB_URL: &str =
// // "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
// // Box::new(PgConnection::connect(DB_URL).map(|db| App {
// // db,
// // hdr_srv: HeaderValue::from_static("Actix"),
// // hdr_ctjson: HeaderValue::from_static("application/json"),
// // hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// // }));
// Box::new(
// // paired_connect(&String::from(DB_URL).parse().unwrap())
// RedisConnection::connect(DB_URL)
// .map_err(|_| ())
// .map(|db|{
// let app = App {
// db,
// hdr_srv: HeaderValue::from_static("Actix"),
// hdr_ctjson: HeaderValue::from_static("application/json"),
// hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// };
// app
// })
// // })
// )
// }
// }
// pub fn json() -> HttpResponse {
// let message = Message {
// message: "Hello, World!",
// };
// let mut body = BytesMut::with_capacity(SIZE);
// serde_json::to_writer(Writer(&mut body), &message).unwrap();
// let mut res = HttpResponse::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
// res
// }
// fn plaintext() -> HttpResponse {
// let mut res = HttpResponse::with_body(
// StatusCode::OK,
// Body::Bytes(Bytes::from_static(b"Hello, World!")),
// );
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
// res
// }
// #[derive(Template)]
// #[template(path = "test.html")]
// struct HelloTemplate<'a> {
// name: &'a str,
// }
// pub fn root_handler(
// req: web::HttpRequest
// ) -> impl Future<Item = HttpResponse, Error = ()> {
// let path = req.match_info().query("filename").parse().unwrap();
// HttpResponse::from(
// Ok( NamedFile::open(path).unwrap() )
// )
// // ok( HttpResponse::Ok().body("hi"))
// // Ok(HttpResponse::InternalServerError().finish())
// }
pub struct WsServer {
sessions: Vec<Addr<WsSession>>,
db: Addr<RedisActor>,
}
impl Actor for WsServer {
type Context = Context<Self>;
}
impl WsServer {
pub fn new(db : Addr<RedisActor>) -> WsServer {
let sessions = vec![];
WsServer { sessions, db }
}
}
impl WsServer {
fn close_all(&self) {
// for s in &*self.sessions.lock().unwrap() {
for s in &self.sessions {
// if let Some(v) = s.upgrade(){
if s.connected() {
// println!("sending WsClose");
// v.do_send(WsClose);
s.do_send(WsClose);
//WsMessage::Close(Some(CloseReason { code: CloseCode::Restart, description: None })));
}
}
}
}
/// new websocket connection
#[derive(Message)]
pub struct Connect {
pub addr: Addr<WsSession>,
}
// impl Message for Connect {
// type Result = usize;
// }
impl Handler<Connect> for WsServer {
type Result = ();
fn handle(&mut self, msg: Connect, _ctx: &mut Self::Context) -> Self::Result {
// println!("{:?} joined wsserver", msg.addr);
// let mut s = &mut *self.sessions.get_mut().unwrap();
let s = &mut self.sessions;
s.push(msg.addr); //.downgrade());
println!(
"new web socket added to server : {} sockets opened",
s.len()
);
}
}
/// websocket session disconnected
#[derive(Message)]
pub struct Disconnect {
pub addr: Addr<WsSession>,
// pub id : usize,
}
impl Handler<Disconnect> for WsServer {
type Result = ();
fn handle(&mut self, msg: Disconnect, _ctx: &mut Self::Context) -> Self::Result {
println!("a websocket session requested disconnect");
let mut s = 0;
let mut f = false;
// let mut ss = &mut *self.sessions.get_mut().unwrap();
let ss = &mut self.sessions;
for i in 0..ss.len() {
// if let Some(v) = self.sessions[i].upgrade(){
if ss[i] == msg.addr | {
// if ss[i] == msg.addr {
// if v == msg.addr {
s = i;
f = true;
break;
// }
} | conditional_block |
|
server.rs | resp::{RespValue},
// };
use crate::ws::{Close as WsClose, WsSession};
// use super::db::{RedisConnection};
// pub struct App {
// // db: PgConnection,
// db: RedisConnection,
// // db: Arc<PairedConnection>,
// hdr_srv: HeaderValue,
// hdr_ctjson: HeaderValue,
// hdr_cthtml: HeaderValue,
// }
// impl Service for App {
// type Request = Request;
// type Response = Response;
// type Error = Error;
// type Future = Box<dyn Future<Item = Response, Error = Error>>;
// #[inline]
// fn poll_ready(&mut self) -> Poll<(), Self::Error> {
// Ok(Async::Ready(()))
// }
// fn call(&mut self, req: Request) -> Self::Future {
// let path = req.path();
// match path {
// "/db" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_ctjson.clone();
// Box::new(self.db.get("mydomain:one")
// .map(|v:String| {
// let mut body = BytesMut::new();
// serde_json::to_writer(Writer(&mut body), &Message{
// message: &*v
// }).unwrap();
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// })
// )
// }
// "/fortune" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_cthtml.clone();
// // Box::new(self.db.tell_fortune().from_err().map(move |fortunes| {
// Box::new(ok({
// let mut body = BytesMut::with_capacity(2048);
// let mut writer = Writer(&mut body);
// let _ = write!(writer, "{}", HelloTemplate { name : "tester" });//FortunesTemplate { fortunes });
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// }))
// }
// "/json" => {
// Box::new(ok(json()))
// }
// "/plaintext" => {
// Box::new(ok(plaintext()))
// }
// // "/queries" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.get_worlds(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// // "/updates" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.update(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// _ => Box::new(ok(Response::new(StatusCode::NOT_FOUND))),
// }
// }
// }
// #[derive(Clone)]
// pub struct AppFactory;
// impl NewService for AppFactory {
// type Config = ServerConfig;
// type Request = Request;
// type Response = Response;
// type Error = Error;
// type Service = App;
// type InitError = ();
// type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
// fn new_service(&self, _: &ServerConfig) -> Self::Future {
// // const DB_URL: &str =
// // "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
// // Box::new(PgConnection::connect(DB_URL).map(|db| App {
// // db,
// // hdr_srv: HeaderValue::from_static("Actix"),
// // hdr_ctjson: HeaderValue::from_static("application/json"),
// // hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// // }));
// Box::new(
// // paired_connect(&String::from(DB_URL).parse().unwrap())
// RedisConnection::connect(DB_URL)
// .map_err(|_| ())
// .map(|db|{
// let app = App {
// db,
// hdr_srv: HeaderValue::from_static("Actix"),
// hdr_ctjson: HeaderValue::from_static("application/json"),
// hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// };
// app
// })
// // })
// )
// }
// }
// pub fn json() -> HttpResponse {
// let message = Message {
// message: "Hello, World!",
// };
// let mut body = BytesMut::with_capacity(SIZE);
// serde_json::to_writer(Writer(&mut body), &message).unwrap();
// let mut res = HttpResponse::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
// res
// }
// fn plaintext() -> HttpResponse {
// let mut res = HttpResponse::with_body(
// StatusCode::OK,
// Body::Bytes(Bytes::from_static(b"Hello, World!")),
// );
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
// res
// }
// #[derive(Template)]
// #[template(path = "test.html")]
// struct HelloTemplate<'a> {
// name: &'a str,
// }
// pub fn root_handler(
// req: web::HttpRequest
// ) -> impl Future<Item = HttpResponse, Error = ()> {
// let path = req.match_info().query("filename").parse().unwrap();
// HttpResponse::from(
// Ok( NamedFile::open(path).unwrap() )
// )
// // ok( HttpResponse::Ok().body("hi"))
// // Ok(HttpResponse::InternalServerError().finish())
// }
pub struct WsServer {
sessions: Vec<Addr<WsSession>>,
db: Addr<RedisActor>,
}
impl Actor for WsServer {
type Context = Context<Self>;
}
impl WsServer {
pub fn new(db : Addr<RedisActor>) -> WsServer {
let sessions = vec![];
WsServer { sessions, db }
}
}
impl WsServer {
fn close_all(&self) {
// for s in &*self.sessions.lock().unwrap() {
for s in &self.sessions {
// if let Some(v) = s.upgrade(){
if s.connected() {
// println!("sending WsClose");
// v.do_send(WsClose);
s.do_send(WsClose);
//WsMessage::Close(Some(CloseReason { code: CloseCode::Restart, description: None })));
}
}
}
}
/// new websocket connection
#[derive(Message)]
pub struct Connect {
pub addr: Addr<WsSession>,
}
// impl Message for Connect {
// type Result = usize;
// }
impl Handler<Connect> for WsServer {
type Result = ();
fn handle(&mut self, msg: Connect, _ctx: &mut Self::Context) -> Self::Result | {
// println!("{:?} joined wsserver", msg.addr);
// let mut s = &mut *self.sessions.get_mut().unwrap();
let s = &mut self.sessions;
s.push(msg.addr); //.downgrade());
println!(
"new web socket added to server : {} sockets opened",
s.len()
);
} | identifier_body |
|
server.rs | Connection,
// // db: Arc<PairedConnection>,
// hdr_srv: HeaderValue,
// hdr_ctjson: HeaderValue,
// hdr_cthtml: HeaderValue,
// }
// impl Service for App {
// type Request = Request;
// type Response = Response;
// type Error = Error;
// type Future = Box<dyn Future<Item = Response, Error = Error>>;
// #[inline]
// fn poll_ready(&mut self) -> Poll<(), Self::Error> {
// Ok(Async::Ready(()))
// }
// fn call(&mut self, req: Request) -> Self::Future {
// let path = req.path();
// match path {
// "/db" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_ctjson.clone();
// Box::new(self.db.get("mydomain:one")
// .map(|v:String| {
// let mut body = BytesMut::new();
// serde_json::to_writer(Writer(&mut body), &Message{
// message: &*v
// }).unwrap();
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// })
// )
// }
// "/fortune" => {
// let h_srv = self.hdr_srv.clone();
// let h_ct = self.hdr_cthtml.clone();
// // Box::new(self.db.tell_fortune().from_err().map(move |fortunes| {
// Box::new(ok({
// let mut body = BytesMut::with_capacity(2048);
// let mut writer = Writer(&mut body);
// let _ = write!(writer, "{}", HelloTemplate { name : "tester" });//FortunesTemplate { fortunes });
// let mut res = Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// let hdrs = res.headers_mut();
// hdrs.insert(SERVER, h_srv);
// hdrs.insert(CONTENT_TYPE, h_ct);
// res
// }))
// }
// "/json" => {
// Box::new(ok(json()))
// }
// "/plaintext" => {
// Box::new(ok(plaintext()))
// }
// // "/queries" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.get_worlds(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// // "/updates" => {
// // let q = utils::get_query_param(req.uri().query().unwrap_or("")) as usize;
// // let h_srv = self.hdr_srv.clone();
// // let h_ct = self.hdr_ctjson.clone();
// // Box::new(self.db.update(q).from_err().map(move |worlds| {
// // let mut body = BytesMut::with_capacity(35 * worlds.len());
// // to_writer(Writer(&mut body), &worlds).unwrap();
// // let mut res =
// // Response::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// // let hdrs = res.headers_mut();
// // hdrs.insert(SERVER, h_srv);
// // hdrs.insert(CONTENT_TYPE, h_ct);
// // res
// // }))
// // }
// _ => Box::new(ok(Response::new(StatusCode::NOT_FOUND))),
// }
// }
// }
// #[derive(Clone)]
// pub struct AppFactory;
// impl NewService for AppFactory {
// type Config = ServerConfig;
// type Request = Request;
// type Response = Response;
// type Error = Error;
// type Service = App;
// type InitError = ();
// type Future = Box<dyn Future<Item = Self::Service, Error = Self::InitError>>;
// fn new_service(&self, _: &ServerConfig) -> Self::Future {
// // const DB_URL: &str =
// // "postgres://benchmarkdbuser:benchmarkdbpass@tfb-database/hello_world";
// // Box::new(PgConnection::connect(DB_URL).map(|db| App {
// // db,
// // hdr_srv: HeaderValue::from_static("Actix"),
// // hdr_ctjson: HeaderValue::from_static("application/json"),
// // hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// // }));
// Box::new(
// // paired_connect(&String::from(DB_URL).parse().unwrap())
// RedisConnection::connect(DB_URL)
// .map_err(|_| ())
// .map(|db|{
// let app = App {
// db,
// hdr_srv: HeaderValue::from_static("Actix"),
// hdr_ctjson: HeaderValue::from_static("application/json"),
// hdr_cthtml: HeaderValue::from_static("text/html; charset=utf-8"),
// };
// app
// })
// // })
// )
// }
// }
// pub fn json() -> HttpResponse {
// let message = Message {
// message: "Hello, World!",
// };
// let mut body = BytesMut::with_capacity(SIZE);
// serde_json::to_writer(Writer(&mut body), &message).unwrap();
// let mut res = HttpResponse::with_body(StatusCode::OK, Body::Bytes(body.freeze()));
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
// res
// }
// fn plaintext() -> HttpResponse {
// let mut res = HttpResponse::with_body(
// StatusCode::OK,
// Body::Bytes(Bytes::from_static(b"Hello, World!")),
// );
// res.headers_mut()
// .insert(SERVER, HeaderValue::from_static("Actix"));
// res.headers_mut()
// .insert(CONTENT_TYPE, HeaderValue::from_static("text/plain"));
// res
// }
// #[derive(Template)]
// #[template(path = "test.html")]
// struct HelloTemplate<'a> {
// name: &'a str,
// }
// pub fn root_handler(
// req: web::HttpRequest
// ) -> impl Future<Item = HttpResponse, Error = ()> {
// let path = req.match_info().query("filename").parse().unwrap();
// HttpResponse::from(
// Ok( NamedFile::open(path).unwrap() )
// )
// // ok( HttpResponse::Ok().body("hi"))
// // Ok(HttpResponse::InternalServerError().finish())
// }
pub struct WsServer {
sessions: Vec<Addr<WsSession>>,
db: Addr<RedisActor>,
}
impl Actor for WsServer {
type Context = Context<Self>;
}
impl WsServer {
pub fn new(db : Addr<RedisActor>) -> WsServer {
let sessions = vec![];
WsServer { sessions, db }
}
}
impl WsServer {
fn close_all(&self) {
// for s in &*self.sessions.lock().unwrap() {
for s in &self.sessions {
// if let Some(v) = s.upgrade(){
if s.connected() {
// println!("sending WsClose");
// v.do_send(WsClose);
s.do_send(WsClose);
//WsMessage::Close(Some(CloseReason { code: CloseCode::Restart, description: None })));
}
}
}
}
/// new websocket connection
#[derive(Message)]
pub struct Connect {
pub addr: Addr<WsSession>,
}
// impl Message for Connect {
// type Result = usize;
// }
impl Handler<Connect> for WsServer {
type Result = ();
fn handle(&mut self, msg: Connect, _ctx: &mut Self::Context) -> Self::Result {
// println!("{:?} joined wsserver", msg.addr);
// let mut s = &mut *self.sessions.get_mut().unwrap();
let s = &mut self.sessions;
s.push(msg.addr); //.downgrade());
println!(
"new web socket added to server : {} sockets opened",
s.len()
);
}
}
/// websocket session disconnected
#[derive(Message)]
pub struct Disconnect {
pub addr: Addr<WsSession>,
// pub id : usize,
}
impl Handler<Disconnect> for WsServer {
type Result = ();
fn | handle | identifier_name |
|
rt_network_v3_2_x.py | ', 'CurrentThrottle', 'CurrentWheel',
'Distance3D', 'MPH', 'ManualBrake', 'ManualThrottle', 'ManualWheel',
'RangeW', 'RightLaneDist', 'RightLaneType', 'LeftLaneDist', 'LeftLaneType',
'ReactionTime']
raw_df = pd.read_csv(dataset_file, usecols=raw_columns)
raw_df.set_index(['ID'], inplace=True)
pure_df = pd.read_csv(dataset_file)
pure_df.set_index(['ID'], inplace=True)
pure_df
# 5 class using mean & sdev
def create_tot_categories(rt_column):
rt_mean = round(rt_column.mean())
rt_sdev = round(rt_column.std())
bound_1 = rt_mean - rt_sdev
bound_2 = rt_mean - rt_sdev // 2
bound_3 = rt_mean + rt_sdev // 2
bound_4 = rt_mean + rt_sdev
bins = [float('-inf'), bound_1, bound_2, bound_3, bound_4, float('inf')]
labels = np.array(['fast', 'med_fast', 'med', 'med_slow', 'slow'], dtype=object)
return (bins, labels)
# make a copy the raw data
df = raw_df.copy()
# compute 'TOT' categories
tot_bins, tot_labels = create_tot_categories(df.ReactionTime)
n_categories = len(tot_labels)
df.RightLaneType = df.RightLaneType.astype(int)
df.LeftLaneType = df.LeftLaneType.astype(int)
# convert leftlane type and rightlanetype to categorical:
# add the class to the dataframe
df['TOT'] = pd.cut(df.ReactionTime, bins=tot_bins, labels=tot_labels).astype(object)
# # Select a handful of ppl for saving resource
df['Name'] = df['Name'].str.upper()
chunk_users = [[f'{i}'.zfill(3) + f'_M{j}' for j in range(1, 4)] for i in [13, 14]]
chunk_users = [u for l in chunk_users for u in l] | def upsample_minority_TOTs(X_train, y_train, tot_labels, random_state=27):
# contat the training data together.
X = pd.concat([X_train, y_train], axis=1)
# separate majority and minority classes
buckets = {l: X[X.TOT == l] for l in tot_labels}
maj_label, majority = reduce(lambda a,b: b if b[1].shape[0] > a[1].shape[0] else a, buckets.items())
minorities = {k:v for k,v in buckets.items() if k != maj_label}
# upsample the minority classes
for k,v in minorities.items():
buckets[k] = resample(v, replace=True, n_samples=majority.shape[0], random_state=random_state)
upsampled = pd.concat(buckets.values()).sample(frac=1)
# split the upsampled data into X and y
y_train = upsampled['TOT']
X_train = upsampled.drop('TOT', axis=1)
return X_train, y_train
def prepare_inputs(X_train, X_test):
# scales inputs using "standard scaler", and returns 2D numpy array
scaler = StandardScaler().fit(pd.concat([X_train, X_test]))
X_train = scaler.transform(X_train.values)
X_test = scaler.transform(X_test.values)
return X_train, X_test, scaler
def prepare_target(y_train, y_test, categories):
# convert target to categorical, and returns 2D numpy array
y_train = y_train.to_numpy().reshape(-1,1)
y_test = y_test.to_numpy().reshape(-1,1)
onehot = OneHotEncoder(categories=categories)
onehot.fit(np.concatenate([y_train, y_test]))
y_train = onehot.transform(y_train).toarray()
y_test = onehot.transform(y_test).toarray()
return y_train, y_test, onehot
# split features and targets
y = df.TOT
X = df.drop(['Name', 'ReactionTime', 'TOT'], axis=1)
# make results easier to reproduce
random_state = 27
# split train and test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, stratify=y, random_state=random_state)
# upsample the training data
X_train, y_train = upsample_minority_TOTs(X_train, y_train, tot_labels)
# scale the inputs
X_train_enc, X_test_enc, scaler = prepare_inputs(X_train, X_test)
# categorize outputs
y_train_enc, y_test_enc, onehot = prepare_target(y_train, y_test, categories=[tot_labels])
print_heading('TOT Value Counts')
print(y_train.value_counts())
# Prepare data used for extended evaluation and verification (all participants)
# split features and targets
Y_verification = all_users.TOT
X_verification = all_users.drop(['Name', 'ReactionTime', 'TOT'], axis=1)
# upsample minority classes
X_verification, Y_verification = upsample_minority_TOTs(X_verification, Y_verification, tot_labels)
# scale the inputs
X_verification = scaler.transform(X_verification.values)
# categorize outputs
Y_verification = onehot.transform(Y_verification.to_numpy().reshape(-1, 1)).toarray()
def add_adversarial_data(X_train, y_train, adversarial_df):
y_cols = [f'y{y}' for y in range(y_train.shape[1])]
y_adv = adv_df[y_cols].values
X_adv = adv_df.drop(y_cols, axis=1).values
return np.append(X_train, X_adv, axis=0), np.append(y_train, y_adv, axis=0)
# adv_df = pd.read_csv(adv_dataset_file)
# X_train_enc, y_train_enc = add_adversarial_data(X_train_enc, y_train_enc, adv_df)
# save the column names & indexes for use during verification
feature_names = list(X.columns)
# display the feature names
print_heading('Feature Names')
print_message(feature_names)
# print the TOT categories
print_heading('TOT Categories')
print('\n'.join(['%s: %9.2f, %7.2f' % (tot_labels[i].rjust(8), tot_bins[i], tot_bins[i+1]) for i in range(n_categories)]))
def display_processed_data(feature_names, unencoded=True, encoded=True, describe=True):
if unencoded:
print_heading('Unencoded Data')
display(pd.concat([X_train, y_train], axis=1).describe())
if encoded:
enc_tot_labels = onehot.get_feature_names(input_features=['TOT'])
print_heading('Encoded Data')
display(pd.concat([pd.DataFrame(X_train_enc, columns=feature_names),
pd.DataFrame(y_train_enc, columns=enc_tot_labels)],
axis=1).astype({k:int for k in enc_tot_labels}).describe())
display_processed_data(feature_names, unencoded=False)
"""
## Build & Train NN"""
# cleanup the old training logs and models
!rm -rf $tensorboard_logs model-*.h5 $saved_model_dir
!mkdir -p $tensorboard_logs
# training callbacks
mc_file = 'model-best-{epoch:02d}-{val_loss:.2f}.h5'
es_cb = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=20)
mc_cb = ModelCheckpoint(mc_file, monitor='val_accuracy', verbose=1, save_best_only=True)
# tb_cb = TensorBoard(log_dir=tensorboard_logs, histogram_freq=1, write_graph=True, write_images=True)
# v3.2.2
# loss: 0.3316 - accuracy: 0.8707 - val_loss: 0.3212 - val_accuracy: 0.874
# 1) Train: 0.869, 2) Test: 0.847
model = Sequential()
model.add(InputLayer(input_shape=(X_train_enc.shape[1],)))
model.add(Dense(23, activation='relu', kernel_initializer='he_normal'))
model.add(Dense(18, activation='relu'))
model.add(Dense(11, activation='relu'))
model.add(Dense(n_categories, activation='softmax')) # logits layer
optimizer = 'adam'
# optimizer = tf.keras.optimizers.Adam(learning_rate=0.02)
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# fit the keras model on the dataset
history = model.fit(X_train_enc, y_train_enc,
validation_data=(X_test_enc, y_test_enc),
# epochs=30,
epochs=1,
batch_size=16,
callbacks=[es_cb, mc_cb])
# callbacks=[es_cb, mc_cb, tb_cb])
# pick best model file from filesystem
best_model_path = sorted(glob.glob('model-best-*.h5'), key=lambda f: int(re.search(r'\d+', f).group()))[-1]
print_heading('Best Model:')
print_message(best_model_path)
# cleanup old model
!rm -rf $saved_model_dir
# save model in tf and h5 formats
tf_model_path = f'{saved_model_dir}/model'
h5_model_path = f'{saved | all_users = df.copy()
df = df.loc[df['Name'].isin(chunk_users)]
| random_line_split |
rt_network_v3_2_x.py |
# delete sample data
!rm -rf sample_data
# setup nnet tools (for converting model to Stanford's nnet format)
setup_nnet_tools(nnet_tools_path)
# used for conversion to NNet format
from NNet.utils.writeNNet import writeNNet
"""## Download Dataset"""
# GDrive ID of csv file (AllData_ReactionTime.csv)
# https://drive.google.com/file/d/1WNnAd8lYWMT_mQWwiN6dP2KC6NTLFjXn
gdrive_id='1WNnAd8lYWMT_mQWwiN6dP2KC6NTLFjXn'
dataset_file='all_data_rt.csv'
# GDrive ID of adversarial csv
# https://drive.google.com/file/d/1N9QZm0NXXYPCQnBNrJHPzmWHkU9SSkbg
adv_dataset_gdrive_id='1N9QZm0NXXYPCQnBNrJHPzmWHkU9SSkbg'
adv_dataset_file = 'adv_dataset.csv'
# load the dataset from gdrive if it doesn't exist in the runtime's filesystem.
if not os.path.exists(dataset_file):
download_file_from_gdrive(gdrive_id, dataset_file)
if not os.path.exists(adv_dataset_file):
download_file_from_gdrive(adv_dataset_gdrive_id, adv_dataset_file)
"""## Import Dataset"""
raw_columns = ['ID', 'Name', 'FixationDuration', 'FixationStart', 'FixationSeq',
'FixationX', 'FixationY', 'GazeDirectionLeftZ', 'GazeDirectionRightZ',
'PupilLeft', 'PupilRight', 'InterpolatedGazeX', 'InterpolatedGazeY',
'AutoThrottle', 'AutoWheel', 'CurrentThrottle', 'CurrentWheel',
'Distance3D', 'MPH', 'ManualBrake', 'ManualThrottle', 'ManualWheel',
'RangeW', 'RightLaneDist', 'RightLaneType', 'LeftLaneDist', 'LeftLaneType',
'ReactionTime']
raw_df = pd.read_csv(dataset_file, usecols=raw_columns)
raw_df.set_index(['ID'], inplace=True)
pure_df = pd.read_csv(dataset_file)
pure_df.set_index(['ID'], inplace=True)
pure_df
# 5 class using mean & sdev
def create_tot_categories(rt_column):
rt_mean = round(rt_column.mean())
rt_sdev = round(rt_column.std())
bound_1 = rt_mean - rt_sdev
bound_2 = rt_mean - rt_sdev // 2
bound_3 = rt_mean + rt_sdev // 2
bound_4 = rt_mean + rt_sdev
bins = [float('-inf'), bound_1, bound_2, bound_3, bound_4, float('inf')]
labels = np.array(['fast', 'med_fast', 'med', 'med_slow', 'slow'], dtype=object)
return (bins, labels)
# make a copy the raw data
df = raw_df.copy()
# compute 'TOT' categories
tot_bins, tot_labels = create_tot_categories(df.ReactionTime)
n_categories = len(tot_labels)
df.RightLaneType = df.RightLaneType.astype(int)
df.LeftLaneType = df.LeftLaneType.astype(int)
# convert leftlane type and rightlanetype to categorical:
# add the class to the dataframe
df['TOT'] = pd.cut(df.ReactionTime, bins=tot_bins, labels=tot_labels).astype(object)
# # Select a handful of ppl for saving resource
df['Name'] = df['Name'].str.upper()
chunk_users = [[f'{i}'.zfill(3) + f'_M{j}' for j in range(1, 4)] for i in [13, 14]]
chunk_users = [u for l in chunk_users for u in l]
all_users = df.copy()
df = df.loc[df['Name'].isin(chunk_users)]
def upsample_minority_TOTs(X_train, y_train, tot_labels, random_state=27):
# contat the training data together.
X = pd.concat([X_train, y_train], axis=1)
# separate majority and minority classes
buckets = {l: X[X.TOT == l] for l in tot_labels}
maj_label, majority = reduce(lambda a,b: b if b[1].shape[0] > a[1].shape[0] else a, buckets.items())
minorities = {k:v for k,v in buckets.items() if k != maj_label}
# upsample the minority classes
for k,v in minorities.items():
buckets[k] = resample(v, replace=True, n_samples=majority.shape[0], random_state=random_state)
upsampled = pd.concat(buckets.values()).sample(frac=1)
# split the upsampled data into X and y
y_train = upsampled['TOT']
X_train = upsampled.drop('TOT', axis=1)
return X_train, y_train
def prepare_inputs(X_train, X_test):
# scales inputs using "standard scaler", and returns 2D numpy array
scaler = StandardScaler().fit(pd.concat([X_train, X_test]))
X_train = scaler.transform(X_train.values)
X_test = scaler.transform(X_test.values)
return X_train, X_test, scaler
def prepare_target(y_train, y_test, categories):
# convert target to categorical, and returns 2D numpy array
y_train = y_train.to_numpy().reshape(-1,1)
y_test = y_test.to_numpy().reshape(-1,1)
onehot = OneHotEncoder(categories=categories)
onehot.fit(np.concatenate([y_train, y_test]))
y_train = onehot.transform(y_train).toarray()
y_test = onehot.transform(y_test).toarray()
return y_train, y_test, onehot
# split features and targets
y = df.TOT
X = df.drop(['Name', 'ReactionTime', 'TOT'], axis=1)
# make results easier to reproduce
random_state = 27
# split train and test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, stratify=y, random_state=random_state)
# upsample the training data
X_train, y_train = upsample_minority_TOTs(X_train, y_train, tot_labels)
# scale the inputs
X_train_enc, X_test_enc, scaler = prepare_inputs(X_train, X_test)
# categorize outputs
y_train_enc, y_test_enc, onehot = prepare_target(y_train, y_test, categories=[tot_labels])
print_heading('TOT Value Counts')
print(y_train.value_counts())
# Prepare data used for extended evaluation and verification (all participants)
# split features and targets
Y_verification = all_users.TOT
X_verification = all_users.drop(['Name', 'ReactionTime', 'TOT'], axis=1)
# upsample minority classes
X_verification, Y_verification = upsample_minority_TOTs(X_verification, Y_verification, tot_labels)
# scale the inputs
X_verification = scaler.transform(X_verification.values)
# categorize outputs
Y_verification = onehot.transform(Y_verification.to_numpy().reshape(-1, 1)).toarray()
def add_adversarial_data(X_train, y_train, adversarial_df):
y_cols = [f'y{y}' for y in range(y_train.shape[1])]
y_adv = adv_df[y_cols].values
X_adv = adv_df.drop(y_cols, axis=1).values
return np.append(X_train, X_adv, axis=0), np.append(y_train, y_adv, axis=0)
# adv_df = pd.read_csv(adv_dataset_file)
# X_train_enc, y_train_enc = add_adversarial_data(X_train_enc, y_train_enc, adv_df)
# save the column names & indexes for use during verification
feature_names = list(X.columns)
# display the feature names
print_heading('Feature Names')
print_message(feature_names)
# print the TOT categories
print_heading('TOT Categories')
print('\n'.join(['%s: %9.2f, %7.2f' % (tot_labels[i].rjust(8), tot_bins[i], tot_bins[i+1]) for i in range(n_categories)]))
def display_processed_data(feature_names, unencoded=True, encoded=True, describe=True):
if unencoded:
print_heading('Unencoded Data')
display(pd.concat([X_train, y_train], axis=1).describe())
if encoded:
enc_tot_labels = onehot.get_feature_names(input_features=['TOT'])
print_heading('Encoded Data')
display(pd.concat([pd.DataFrame(X_train_enc, columns=feature_names),
pd.DataFrame(y_train_enc, columns=enc_tot_labels)],
axis=1).astype({k:int for k in enc_tot_labels}).describe())
display_processed_data(feature_names, unencoded=False)
"""
## Build & Train NN"""
# cleanup the old training logs and models
!rm -rf $tensorboard_logs model-*.h5 $saved_model_dir
!mkdir -p $tensorboard_logs
# training callbacks
mc_file = 'model-best-{epoch:02d}-{ | if not os.path.exists(nnet_tools_path):
install_nnet_tools(nnet_tools_path)
# add folder to PYTHONPATH & JUPYTER_PATH
update_path_vars([nnet_tools_path]) | identifier_body |
|
rt_network_v3_2_x.py | ))
def display_processed_data(feature_names, unencoded=True, encoded=True, describe=True):
if unencoded:
print_heading('Unencoded Data')
display(pd.concat([X_train, y_train], axis=1).describe())
if encoded:
enc_tot_labels = onehot.get_feature_names(input_features=['TOT'])
print_heading('Encoded Data')
display(pd.concat([pd.DataFrame(X_train_enc, columns=feature_names),
pd.DataFrame(y_train_enc, columns=enc_tot_labels)],
axis=1).astype({k:int for k in enc_tot_labels}).describe())
display_processed_data(feature_names, unencoded=False)
"""
## Build & Train NN"""
# cleanup the old training logs and models
!rm -rf $tensorboard_logs model-*.h5 $saved_model_dir
!mkdir -p $tensorboard_logs
# training callbacks
mc_file = 'model-best-{epoch:02d}-{val_loss:.2f}.h5'
es_cb = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=20)
mc_cb = ModelCheckpoint(mc_file, monitor='val_accuracy', verbose=1, save_best_only=True)
# tb_cb = TensorBoard(log_dir=tensorboard_logs, histogram_freq=1, write_graph=True, write_images=True)
# v3.2.2
# loss: 0.3316 - accuracy: 0.8707 - val_loss: 0.3212 - val_accuracy: 0.874
# 1) Train: 0.869, 2) Test: 0.847
model = Sequential()
model.add(InputLayer(input_shape=(X_train_enc.shape[1],)))
model.add(Dense(23, activation='relu', kernel_initializer='he_normal'))
model.add(Dense(18, activation='relu'))
model.add(Dense(11, activation='relu'))
model.add(Dense(n_categories, activation='softmax')) # logits layer
optimizer = 'adam'
# optimizer = tf.keras.optimizers.Adam(learning_rate=0.02)
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# fit the keras model on the dataset
history = model.fit(X_train_enc, y_train_enc,
validation_data=(X_test_enc, y_test_enc),
# epochs=30,
epochs=1,
batch_size=16,
callbacks=[es_cb, mc_cb])
# callbacks=[es_cb, mc_cb, tb_cb])
# pick best model file from filesystem
best_model_path = sorted(glob.glob('model-best-*.h5'), key=lambda f: int(re.search(r'\d+', f).group()))[-1]
print_heading('Best Model:')
print_message(best_model_path)
# cleanup old model
!rm -rf $saved_model_dir
# save model in tf and h5 formats
tf_model_path = f'{saved_model_dir}/model'
h5_model_path = f'{saved_model_dir}/model.h5'
model.save(tf_model_path) # save_format='tf'
model.save(h5_model_path, save_format='h5')
print_heading(f'Evaluating {best_model_path}')
!mkdir -p images
# load the saved best model
saved_model = load_model(tf_model_path)
# evaluate the model
_, train_acc = saved_model.evaluate(X_train_enc, y_train_enc, verbose=2)
_, test_acc = saved_model.evaluate(X_test_enc, y_test_enc, verbose=1)
print('Accuracy of test: %.2f' % (test_acc*100))
print('Accuracy of the: '+'1) Train: %.3f, 2) Test: %.3f' % (train_acc, test_acc))
# plot training history
plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend(['train', 'test'], loc='upper left')
plt.ylabel('Loss')
plt.savefig('images/training_history.png', dpi=300)
plt.show()
# summarize history for accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig('images/accuracy_history.png', dpi=300)
plt.show()
# summarize history for loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig('images/loss_history.png', dpi=300)
plt.show()
#note in kera model.predict() will return predict probabilities
pred_prob = saved_model.predict(X_test_enc, verbose=0)
fpr, tpr, threshold = metrics.roc_curve(y_test_enc.ravel(), pred_prob.ravel())
roc_auc = metrics.auc(fpr, tpr)
# Compute ROC curve and ROC area for each class
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_categories):
fpr[i], tpr[i], _ = metrics.roc_curve(y_test_enc[:,i], pred_prob[:, i])
roc_auc[i] = metrics.auc(fpr[i], tpr[i])
# Compute micro-average ROC curve and ROC area
fpr['micro'], tpr['micro'], _ = metrics.roc_curve(y_test_enc.ravel(), pred_prob.ravel())
roc_auc['micro'] = metrics.auc(fpr['micro'], tpr['micro'])
# Compute macro-average ROC curve and ROC area
all_fpr = np.unique(np.concatenate([fpr[i] for i in range(3)]))
# Then interpolate all ROC curves at this points
mean_tpr = np.zeros_like(all_fpr)
for i in range(n_categories):
mean_tpr += np.interp(all_fpr, fpr[i], tpr[i])
# Finally average it and compute AUC
mean_tpr /= n_categories
fpr['macro'] = all_fpr
tpr['macro'] = mean_tpr
roc_auc['macro'] = metrics.auc(fpr['macro'], tpr['macro'])
plt.figure(1)
plt.plot(fpr['micro'], tpr['micro'],
label='micro-average ROC curve (area = {0:0.2f})' \
''.format(roc_auc['micro']),
color='deeppink', linestyle=':', linewidth=4)
plt.plot(fpr['macro'], tpr['macro'],
label='macro-average ROC curve (area = {0:0.2f})' \
''.format(roc_auc['macro']),
color='navy', linestyle=':', linewidth=4)
colors = cycle(['aqua', 'darkorange', 'cornflowerblue', 'red', 'blue'])
for i, color in zip(range(n_categories), colors):
plt.plot(fpr[i], tpr[i], color=color, lw=2,
label='ROC curve of class {0} (area = {1:0.2f})' \
''.format(i, roc_auc[i]))
plt.plot([0, 1], [0, 1], 'k--', lw=2)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Result for Receiver operating characteristic to multi-class of Reaction Time')
plt.legend(loc='lower right')
plt.savefig('images/roc.png', dpi=300)
plt.show()
print_heading(f'Extended Evaluation (all participants)')
def extended_evaluation(model_path, X, Y):
# load the saved best model
model = load_model(model_path)
# evaluate the model
_, accuracy = model.evaluate(X, Y, verbose=2)
print('Accuracy: %.2f' % (accuracy * 100))
extended_evaluation(tf_model_path, X_verification, Y_verification)
"""## Create Verification Artifacts
"""
def compute_nnet_params(model_file, df, scaler):
outputs = df['TOT']
inputs = df.drop(['Name', 'TOT', 'ReactionTime'], axis=1)
enc_inputs = pd.DataFrame(scaler.transform(inputs.values), columns=inputs.columns)
# compute sdev, mins, and maxs for inputs
input_sdev = enc_inputs.std().to_numpy()
input_mins = enc_inputs.min().to_numpy()
input_maxs = enc_inputs.max().to_numpy()
# extend input maxs and mins by std dev
input_mins -= input_sdev
input_maxs += input_sdev
# maraboupy only supports normalization (not standardization)
# use mean=0, and range=1 to neutralize maraboupy normalization
means = np.zeros(enc_inputs.shape[1]+1, dtype=int)
ranges = np.ones(enc_inputs.shape[1]+1, dtype=int)
# extract weights and biases from model
model = load_model(model_file)
model_params = model.get_weights()
weights = [w.T for w in model_params[0:len(model_params):2]]
biases = model_params[1:len(model_params):2]
return (weights, biases, input_mins, input_maxs, means, ranges)
def save_nnet(weights, biases, input_mins, input_maxs, means, ranges, output_path):
# write model in nnet format.
writeNNet(weights, biases, input_mins, input_maxs, means, ranges, output_path)
def | save_encoders | identifier_name |
|
rt_network_v3_2_x.py | ', 'CurrentThrottle', 'CurrentWheel',
'Distance3D', 'MPH', 'ManualBrake', 'ManualThrottle', 'ManualWheel',
'RangeW', 'RightLaneDist', 'RightLaneType', 'LeftLaneDist', 'LeftLaneType',
'ReactionTime']
raw_df = pd.read_csv(dataset_file, usecols=raw_columns)
raw_df.set_index(['ID'], inplace=True)
pure_df = pd.read_csv(dataset_file)
pure_df.set_index(['ID'], inplace=True)
pure_df
# 5 class using mean & sdev
def create_tot_categories(rt_column):
rt_mean = round(rt_column.mean())
rt_sdev = round(rt_column.std())
bound_1 = rt_mean - rt_sdev
bound_2 = rt_mean - rt_sdev // 2
bound_3 = rt_mean + rt_sdev // 2
bound_4 = rt_mean + rt_sdev
bins = [float('-inf'), bound_1, bound_2, bound_3, bound_4, float('inf')]
labels = np.array(['fast', 'med_fast', 'med', 'med_slow', 'slow'], dtype=object)
return (bins, labels)
# make a copy the raw data
df = raw_df.copy()
# compute 'TOT' categories
tot_bins, tot_labels = create_tot_categories(df.ReactionTime)
n_categories = len(tot_labels)
df.RightLaneType = df.RightLaneType.astype(int)
df.LeftLaneType = df.LeftLaneType.astype(int)
# convert leftlane type and rightlanetype to categorical:
# add the class to the dataframe
df['TOT'] = pd.cut(df.ReactionTime, bins=tot_bins, labels=tot_labels).astype(object)
# # Select a handful of ppl for saving resource
df['Name'] = df['Name'].str.upper()
chunk_users = [[f'{i}'.zfill(3) + f'_M{j}' for j in range(1, 4)] for i in [13, 14]]
chunk_users = [u for l in chunk_users for u in l]
all_users = df.copy()
df = df.loc[df['Name'].isin(chunk_users)]
def upsample_minority_TOTs(X_train, y_train, tot_labels, random_state=27):
# contat the training data together.
X = pd.concat([X_train, y_train], axis=1)
# separate majority and minority classes
buckets = {l: X[X.TOT == l] for l in tot_labels}
maj_label, majority = reduce(lambda a,b: b if b[1].shape[0] > a[1].shape[0] else a, buckets.items())
minorities = {k:v for k,v in buckets.items() if k != maj_label}
# upsample the minority classes
for k,v in minorities.items():
buckets[k] = resample(v, replace=True, n_samples=majority.shape[0], random_state=random_state)
upsampled = pd.concat(buckets.values()).sample(frac=1)
# split the upsampled data into X and y
y_train = upsampled['TOT']
X_train = upsampled.drop('TOT', axis=1)
return X_train, y_train
def prepare_inputs(X_train, X_test):
# scales inputs using "standard scaler", and returns 2D numpy array
scaler = StandardScaler().fit(pd.concat([X_train, X_test]))
X_train = scaler.transform(X_train.values)
X_test = scaler.transform(X_test.values)
return X_train, X_test, scaler
def prepare_target(y_train, y_test, categories):
# convert target to categorical, and returns 2D numpy array
y_train = y_train.to_numpy().reshape(-1,1)
y_test = y_test.to_numpy().reshape(-1,1)
onehot = OneHotEncoder(categories=categories)
onehot.fit(np.concatenate([y_train, y_test]))
y_train = onehot.transform(y_train).toarray()
y_test = onehot.transform(y_test).toarray()
return y_train, y_test, onehot
# split features and targets
y = df.TOT
X = df.drop(['Name', 'ReactionTime', 'TOT'], axis=1)
# make results easier to reproduce
random_state = 27
# split train and test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, stratify=y, random_state=random_state)
# upsample the training data
X_train, y_train = upsample_minority_TOTs(X_train, y_train, tot_labels)
# scale the inputs
X_train_enc, X_test_enc, scaler = prepare_inputs(X_train, X_test)
# categorize outputs
y_train_enc, y_test_enc, onehot = prepare_target(y_train, y_test, categories=[tot_labels])
print_heading('TOT Value Counts')
print(y_train.value_counts())
# Prepare data used for extended evaluation and verification (all participants)
# split features and targets
Y_verification = all_users.TOT
X_verification = all_users.drop(['Name', 'ReactionTime', 'TOT'], axis=1)
# upsample minority classes
X_verification, Y_verification = upsample_minority_TOTs(X_verification, Y_verification, tot_labels)
# scale the inputs
X_verification = scaler.transform(X_verification.values)
# categorize outputs
Y_verification = onehot.transform(Y_verification.to_numpy().reshape(-1, 1)).toarray()
def add_adversarial_data(X_train, y_train, adversarial_df):
y_cols = [f'y{y}' for y in range(y_train.shape[1])]
y_adv = adv_df[y_cols].values
X_adv = adv_df.drop(y_cols, axis=1).values
return np.append(X_train, X_adv, axis=0), np.append(y_train, y_adv, axis=0)
# adv_df = pd.read_csv(adv_dataset_file)
# X_train_enc, y_train_enc = add_adversarial_data(X_train_enc, y_train_enc, adv_df)
# save the column names & indexes for use during verification
feature_names = list(X.columns)
# display the feature names
print_heading('Feature Names')
print_message(feature_names)
# print the TOT categories
print_heading('TOT Categories')
print('\n'.join(['%s: %9.2f, %7.2f' % (tot_labels[i].rjust(8), tot_bins[i], tot_bins[i+1]) for i in range(n_categories)]))
def display_processed_data(feature_names, unencoded=True, encoded=True, describe=True):
if unencoded:
|
if encoded:
enc_tot_labels = onehot.get_feature_names(input_features=['TOT'])
print_heading('Encoded Data')
display(pd.concat([pd.DataFrame(X_train_enc, columns=feature_names),
pd.DataFrame(y_train_enc, columns=enc_tot_labels)],
axis=1).astype({k:int for k in enc_tot_labels}).describe())
display_processed_data(feature_names, unencoded=False)
"""
## Build & Train NN"""
# cleanup the old training logs and models
!rm -rf $tensorboard_logs model-*.h5 $saved_model_dir
!mkdir -p $tensorboard_logs
# training callbacks
mc_file = 'model-best-{epoch:02d}-{val_loss:.2f}.h5'
es_cb = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=20)
mc_cb = ModelCheckpoint(mc_file, monitor='val_accuracy', verbose=1, save_best_only=True)
# tb_cb = TensorBoard(log_dir=tensorboard_logs, histogram_freq=1, write_graph=True, write_images=True)
# v3.2.2
# loss: 0.3316 - accuracy: 0.8707 - val_loss: 0.3212 - val_accuracy: 0.874
# 1) Train: 0.869, 2) Test: 0.847
model = Sequential()
model.add(InputLayer(input_shape=(X_train_enc.shape[1],)))
model.add(Dense(23, activation='relu', kernel_initializer='he_normal'))
model.add(Dense(18, activation='relu'))
model.add(Dense(11, activation='relu'))
model.add(Dense(n_categories, activation='softmax')) # logits layer
optimizer = 'adam'
# optimizer = tf.keras.optimizers.Adam(learning_rate=0.02)
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# fit the keras model on the dataset
history = model.fit(X_train_enc, y_train_enc,
validation_data=(X_test_enc, y_test_enc),
# epochs=30,
epochs=1,
batch_size=16,
callbacks=[es_cb, mc_cb])
# callbacks=[es_cb, mc_cb, tb_cb])
# pick best model file from filesystem
best_model_path = sorted(glob.glob('model-best-*.h5'), key=lambda f: int(re.search(r'\d+', f).group()))[-1]
print_heading('Best Model:')
print_message(best_model_path)
# cleanup old model
!rm -rf $saved_model_dir
# save model in tf and h5 formats
tf_model_path = f'{saved_model_dir}/model'
h5_model_path = f'{saved | print_heading('Unencoded Data')
display(pd.concat([X_train, y_train], axis=1).describe()) | conditional_block |
cdb.py | [data]
[hash_lookup_table] <- there's 256 of these; they're full of babies
... each one has [hash][absolute offset]
... each is (2*entries) long for hash searches
[hash_lookup_table]
Usage:
>>> (build a cdb)
>>> read = reader("test.cdb")
>>> print 'read["a key"] =', read["a key"]
>>> for (key, value) in read.iteritems():
... print key, '= (',
... for values in value:
... print value + ',',
... print ')'
"""
def __init__(self, infile):
"""Open the file connection."""
if isinstance(infile, str): self.filep = open(infile, "r+b")
else: self.filep = infile
# attempt to read file from the start
self.filep.seek(0)
self.start = self.filep.tell()
# get the least pos_bucket position (beginning of subtables)
self.header = unpack('<512L', self.filep.read(2048))
# find the end of the data
self.enddata = min(self.header[0::2])
def __get(self,index,single=True):
return_value = []
hash_prime = calc_hash(index)
# pull data from the cached header
headhash = hash_prime % 256
pos_bucket= self.header[headhash + headhash]
ncells = self.header[headhash + headhash + 1]
# since the 256*8 bytes are all zeroed, this means the hash
# was invalid as we pulled it.
if ncells == 0: raise KeyError
# calculate predictive lookup
offset = (hash_prime >> 8) % ncells
# set a die badly flag (throw key error)
found = False
# loop through the number of cells in the hash range
for step in range(ncells):
self.filep.seek(pos_bucket + ((offset + step) % ncells) * 8)
# grab the hash and position in the data stream
(hash, pointer) = unpack('<LL', self.filep.read(8))
# throw an error if the hash just dumped us in the dirt
if pointer == 0:
# if there were no keys found, complain (else break)
if not found: raise KeyError
break
# check that the hash values check
if hash == hash_prime:
# seek to the location indicated
self.filep.seek(pointer)
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
key = self.filep.read(klen)
value = self.filep.read(vlen)
# make sure that the keys match
if key == index:
return_value.append(value)
# if we're only looking for one item, break out
if single: break
# set found flag for multiple value end condition
found = True
# if there were no records hit, dump a keyerror
else: raise KeyError
# throw back a tuple of the values found for key
return tuple(return_value)
def __getitem__(self,index):
# shortcut to __get
if not isinstance(index, str): raise TypeError
self.__get(index)
def get(self,index,default=None):
try:
return self.__get(index,single=False)
except:
if default is not None: return default
raise KeyError
def has_key(self,index):
"""A simple analog of the has_key dict function."""
try:
self.__get(index)
return True
except:
return False
def iteritems(self):
"""A straight pull of the items in the cdb."""
self.filep.seek(self.start + 2048)
# iterate until we hit the enddata marker
while self.filep.tell() < self.enddata - 1:
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
# yield the key and value as a tuple
yield (self.filep.read(klen), self.filep.read(vlen))
def close(self):
"""Close out the file connection."""
self.filep.close()
class builder(object):
"""
The Constant Database system is by DJB (the greatest hero on the interwub)
I just happen to implement it here bceause it's 1.fast, 2.good, 3.fast.
And I need all three aspects.
Usage:
>>> build = builder("test.cdb")
>>> build['a key'] = 'some value n for stupid'
>>> build.close()
The resultant CDB is read by any compatible lib (including reader above)
Access times are good, but can be made mucho faster with psyco.
"""
def __init__(self, infile):
if isinstance(infile, str):
self.filep = open(infile, "w+b")
else: self.filep = infile
# attempt to read file from the start
self.filep.seek(0)
self.start = self.filep.tell()
# track pointers and hash table data
self.hashbucket = [ array.array('L') for i in range(256) ]
# skip past header storage (file header + 2048)
self.position_hash = self.start + 2048
self.filep.seek(self.position_hash)
def __setitem__(self, index, value):
"""CDB supports multiple values for each key. Problems? Too bad."""
# create value and key storage
self.filep.write(pack('<LL',len(index), len(value)))
self.filep.write(index)
self.filep.write(value)
# grab a hash for the key
hash = calc_hash(index)
# dump a new hash into our bucket
self.hashbucket[hash % 256].fromlist([hash, self.position_hash])
self.position_hash += 8 + (len(index) + len(value))
def close(self):
from sys import byteorder
# preinitialize array and find byteorder
cell = array.array('L')
shouldswap = (byteorder == 'big')
# iterate completed values for the hash bucket
for hpindex in [ i for i in xrange(256) ]:
ncells = self.hashbucket[hpindex].buffer_info()[1]
if ncells <= 0:
self.hashbucket[hpindex].append(0)
continue
# create blank cell structure
cell.fromlist([ 0 for i in xrange(ncells+ncells) ])
# loop over hash pairs (xrange with parameters = fast)
for i in xrange(0, ncells, 2):
# pull hash from the hashbucket
hash = self.hashbucket[hpindex].pop(0)
# predictive lookup for jump
index = (hash >> 8) % ncells
# skip occupied cells
while cell[index+index] != 0: index = (index + 1) % ncells
# pull pointer and assign hash/pointer set to cell
cell[index+index] = hash
cell[index+index+1] = self.hashbucket[hpindex].pop(0)
# push length back onto stack
self.hashbucket[hpindex].append(ncells)
# write the hash table (swap bytes if we're bigendian)
if shouldswap: cell.byteswap()
cell.tofile(self.filep)
del cell[:]
# skip to start of file
self.filep.seek(self.start)
# dump some information about the hash pairs into the header
for i in xrange(256):
self.filep.write(pack('<LL', self.position_hash, self.hashbucket[i][0]))
self.position_hash += 8 * self.hashbucket[i].pop()
# free up the hashbucket and cell
del(cell)
del(self.hashbucket)
self.filep.close()
# a rather complete test suite
if __name__ == "__main__":
import os,sys,time
from random import randint, seed
import hotshot, hotshot.stats
# make python behave for our massive crunching needs
sys.setcheckinterval(10000)
# utility to write data
def randstr(): return "".join([ chr(randint(65,90)) for i in xrange(randint(1,32)) ])
def make_data(n):
print "TEST: Making test data"
return [ (randstr(),randstr()) for i in xrange(n)]
def test_write(testlist, fname="test.cdb"):
starttime = time.time()
# initialize a builder system for a cdb
print "TEST: Building CDB"
a = builder(fname)
# run the test
for (item,value) in testlist: a[item] = value
a['meat'] = "moo"
a['meat'] = "baa"
a['meat'] = "bow wow" | random_line_split |
||
cdb.py | a die badly flag (throw key error)
found = False
# loop through the number of cells in the hash range
for step in range(ncells):
self.filep.seek(pos_bucket + ((offset + step) % ncells) * 8)
# grab the hash and position in the data stream
(hash, pointer) = unpack('<LL', self.filep.read(8))
# throw an error if the hash just dumped us in the dirt
if pointer == 0:
# if there were no keys found, complain (else break)
if not found: raise KeyError
break
# check that the hash values check
if hash == hash_prime:
# seek to the location indicated
self.filep.seek(pointer)
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
key = self.filep.read(klen)
value = self.filep.read(vlen)
# make sure that the keys match
if key == index:
return_value.append(value)
# if we're only looking for one item, break out
if single: break
# set found flag for multiple value end condition
found = True
# if there were no records hit, dump a keyerror
else: raise KeyError
# throw back a tuple of the values found for key
return tuple(return_value)
def __getitem__(self,index):
# shortcut to __get
if not isinstance(index, str): raise TypeError
self.__get(index)
def get(self,index,default=None):
try:
return self.__get(index,single=False)
except:
if default is not None: return default
raise KeyError
def has_key(self,index):
"""A simple analog of the has_key dict function."""
try:
self.__get(index)
return True
except:
return False
def iteritems(self):
"""A straight pull of the items in the cdb."""
self.filep.seek(self.start + 2048)
# iterate until we hit the enddata marker
while self.filep.tell() < self.enddata - 1:
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
# yield the key and value as a tuple
yield (self.filep.read(klen), self.filep.read(vlen))
def close(self):
"""Close out the file connection."""
self.filep.close()
class builder(object):
"""
The Constant Database system is by DJB (the greatest hero on the interwub)
I just happen to implement it here bceause it's 1.fast, 2.good, 3.fast.
And I need all three aspects.
Usage:
>>> build = builder("test.cdb")
>>> build['a key'] = 'some value n for stupid'
>>> build.close()
The resultant CDB is read by any compatible lib (including reader above)
Access times are good, but can be made mucho faster with psyco.
"""
def __init__(self, infile):
if isinstance(infile, str):
self.filep = open(infile, "w+b")
else: self.filep = infile
# attempt to read file from the start
self.filep.seek(0)
self.start = self.filep.tell()
# track pointers and hash table data
self.hashbucket = [ array.array('L') for i in range(256) ]
# skip past header storage (file header + 2048)
self.position_hash = self.start + 2048
self.filep.seek(self.position_hash)
def __setitem__(self, index, value):
"""CDB supports multiple values for each key. Problems? Too bad."""
# create value and key storage
self.filep.write(pack('<LL',len(index), len(value)))
self.filep.write(index)
self.filep.write(value)
# grab a hash for the key
hash = calc_hash(index)
# dump a new hash into our bucket
self.hashbucket[hash % 256].fromlist([hash, self.position_hash])
self.position_hash += 8 + (len(index) + len(value))
def close(self):
from sys import byteorder
# preinitialize array and find byteorder
cell = array.array('L')
shouldswap = (byteorder == 'big')
# iterate completed values for the hash bucket
for hpindex in [ i for i in xrange(256) ]:
ncells = self.hashbucket[hpindex].buffer_info()[1]
if ncells <= 0:
self.hashbucket[hpindex].append(0)
continue
# create blank cell structure
cell.fromlist([ 0 for i in xrange(ncells+ncells) ])
# loop over hash pairs (xrange with parameters = fast)
for i in xrange(0, ncells, 2):
# pull hash from the hashbucket
hash = self.hashbucket[hpindex].pop(0)
# predictive lookup for jump
index = (hash >> 8) % ncells
# skip occupied cells
while cell[index+index] != 0: index = (index + 1) % ncells
# pull pointer and assign hash/pointer set to cell
cell[index+index] = hash
cell[index+index+1] = self.hashbucket[hpindex].pop(0)
# push length back onto stack
self.hashbucket[hpindex].append(ncells)
# write the hash table (swap bytes if we're bigendian)
if shouldswap: cell.byteswap()
cell.tofile(self.filep)
del cell[:]
# skip to start of file
self.filep.seek(self.start)
# dump some information about the hash pairs into the header
for i in xrange(256):
self.filep.write(pack('<LL', self.position_hash, self.hashbucket[i][0]))
self.position_hash += 8 * self.hashbucket[i].pop()
# free up the hashbucket and cell
del(cell)
del(self.hashbucket)
self.filep.close()
# a rather complete test suite
if __name__ == "__main__":
import os,sys,time
from random import randint, seed
import hotshot, hotshot.stats
# make python behave for our massive crunching needs
sys.setcheckinterval(10000)
# utility to write data
def randstr(): return "".join([ chr(randint(65,90)) for i in xrange(randint(1,32)) ])
def make_data(n):
print "TEST: Making test data"
return [ (randstr(),randstr()) for i in xrange(n)]
def test_write(testlist, fname="test.cdb"):
starttime = time.time()
# initialize a builder system for a cdb
print "TEST: Building CDB"
a = builder(fname)
# run the test
for (item,value) in testlist: a[item] = value
a['meat'] = "moo"
a['meat'] = "baa"
a['meat'] = "bow wow"
a['meat'] = "mew"
a['meat'] = "ouch"
# close the builder
a.close()
print "TEST: %fs to run build" % (time.time() - starttime)
def test_read(fname="test.cdb"):
print "TEST: Doing read of",fname
cdb = reader(fname)
print 'TEST: Should be False: cdb["not a key"] =', cdb.has_key("not a key")
if cdb.has_key("meat"):
print 'TEST: Multiple values: cdb["meat"] =', cdb.get("meat")
starttime = time.time()
print "TEST: Reconstructing keys from database"
testlist = {}
for (key, values) in cdb.iteritems(): testlist[key]=None
print "TEST: %fs to run fetch" % (time.time() - starttime)
starttime = time.time()
print "TEST: Reading",len(testlist),"entries by access key"
for slug in testlist.keys(): cdb.get(slug)
print "TEST: %fs to run fetch" % (time.time() - starttime)
cdb.close()
def test_massive(testlist, fname="stress.cdb", massive=10**5):
| starttime = time.time()
print "TEST: Massive stress test for large databases (%d entries)" % massive
a = builder(fname)
for i in xrange(massive):
a[testlist[i%len(testlist)][0]] = testlist[i%len(testlist)][1]
if not i % (massive / 37): print '.', #print "%3.1f%% complete" % (float(i) / (5*(10**6))*100)
a.close()
print 'done'
print "TEST: %fs to run write" % (time.time() - starttime) | identifier_body |
|
cdb.py | <- 256 pairs of uint32 structures [absolute offset][length]
... positioning works like this: header[hash & 0xff]
[header]
[data] <- we're jumping over this;
... each data node consists of [key_length][value_length][key][value]
[data]
[hash_lookup_table] <- there's 256 of these; they're full of babies
... each one has [hash][absolute offset]
... each is (2*entries) long for hash searches
[hash_lookup_table]
Usage:
>>> (build a cdb)
>>> read = reader("test.cdb")
>>> print 'read["a key"] =', read["a key"]
>>> for (key, value) in read.iteritems():
... print key, '= (',
... for values in value:
... print value + ',',
... print ')'
"""
def __init__(self, infile):
"""Open the file connection."""
if isinstance(infile, str): self.filep = open(infile, "r+b")
else: self.filep = infile
# attempt to read file from the start
self.filep.seek(0)
self.start = self.filep.tell()
# get the least pos_bucket position (beginning of subtables)
self.header = unpack('<512L', self.filep.read(2048))
# find the end of the data
self.enddata = min(self.header[0::2])
def | (self,index,single=True):
return_value = []
hash_prime = calc_hash(index)
# pull data from the cached header
headhash = hash_prime % 256
pos_bucket= self.header[headhash + headhash]
ncells = self.header[headhash + headhash + 1]
# since the 256*8 bytes are all zeroed, this means the hash
# was invalid as we pulled it.
if ncells == 0: raise KeyError
# calculate predictive lookup
offset = (hash_prime >> 8) % ncells
# set a die badly flag (throw key error)
found = False
# loop through the number of cells in the hash range
for step in range(ncells):
self.filep.seek(pos_bucket + ((offset + step) % ncells) * 8)
# grab the hash and position in the data stream
(hash, pointer) = unpack('<LL', self.filep.read(8))
# throw an error if the hash just dumped us in the dirt
if pointer == 0:
# if there were no keys found, complain (else break)
if not found: raise KeyError
break
# check that the hash values check
if hash == hash_prime:
# seek to the location indicated
self.filep.seek(pointer)
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
key = self.filep.read(klen)
value = self.filep.read(vlen)
# make sure that the keys match
if key == index:
return_value.append(value)
# if we're only looking for one item, break out
if single: break
# set found flag for multiple value end condition
found = True
# if there were no records hit, dump a keyerror
else: raise KeyError
# throw back a tuple of the values found for key
return tuple(return_value)
def __getitem__(self,index):
# shortcut to __get
if not isinstance(index, str): raise TypeError
self.__get(index)
def get(self,index,default=None):
try:
return self.__get(index,single=False)
except:
if default is not None: return default
raise KeyError
def has_key(self,index):
"""A simple analog of the has_key dict function."""
try:
self.__get(index)
return True
except:
return False
def iteritems(self):
"""A straight pull of the items in the cdb."""
self.filep.seek(self.start + 2048)
# iterate until we hit the enddata marker
while self.filep.tell() < self.enddata - 1:
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
# yield the key and value as a tuple
yield (self.filep.read(klen), self.filep.read(vlen))
def close(self):
"""Close out the file connection."""
self.filep.close()
class builder(object):
"""
The Constant Database system is by DJB (the greatest hero on the interwub)
I just happen to implement it here bceause it's 1.fast, 2.good, 3.fast.
And I need all three aspects.
Usage:
>>> build = builder("test.cdb")
>>> build['a key'] = 'some value n for stupid'
>>> build.close()
The resultant CDB is read by any compatible lib (including reader above)
Access times are good, but can be made mucho faster with psyco.
"""
def __init__(self, infile):
if isinstance(infile, str):
self.filep = open(infile, "w+b")
else: self.filep = infile
# attempt to read file from the start
self.filep.seek(0)
self.start = self.filep.tell()
# track pointers and hash table data
self.hashbucket = [ array.array('L') for i in range(256) ]
# skip past header storage (file header + 2048)
self.position_hash = self.start + 2048
self.filep.seek(self.position_hash)
def __setitem__(self, index, value):
"""CDB supports multiple values for each key. Problems? Too bad."""
# create value and key storage
self.filep.write(pack('<LL',len(index), len(value)))
self.filep.write(index)
self.filep.write(value)
# grab a hash for the key
hash = calc_hash(index)
# dump a new hash into our bucket
self.hashbucket[hash % 256].fromlist([hash, self.position_hash])
self.position_hash += 8 + (len(index) + len(value))
def close(self):
from sys import byteorder
# preinitialize array and find byteorder
cell = array.array('L')
shouldswap = (byteorder == 'big')
# iterate completed values for the hash bucket
for hpindex in [ i for i in xrange(256) ]:
ncells = self.hashbucket[hpindex].buffer_info()[1]
if ncells <= 0:
self.hashbucket[hpindex].append(0)
continue
# create blank cell structure
cell.fromlist([ 0 for i in xrange(ncells+ncells) ])
# loop over hash pairs (xrange with parameters = fast)
for i in xrange(0, ncells, 2):
# pull hash from the hashbucket
hash = self.hashbucket[hpindex].pop(0)
# predictive lookup for jump
index = (hash >> 8) % ncells
# skip occupied cells
while cell[index+index] != 0: index = (index + 1) % ncells
# pull pointer and assign hash/pointer set to cell
cell[index+index] = hash
cell[index+index+1] = self.hashbucket[hpindex].pop(0)
# push length back onto stack
self.hashbucket[hpindex].append(ncells)
# write the hash table (swap bytes if we're bigendian)
if shouldswap: cell.byteswap()
cell.tofile(self.filep)
del cell[:]
# skip to start of file
self.filep.seek(self.start)
# dump some information about the hash pairs into the header
for i in xrange(256):
self.filep.write(pack('<LL', self.position_hash, self.hashbucket[i][0]))
self.position_hash += 8 * self.hashbucket[i].pop()
# free up the hashbucket and cell
del(cell)
del(self.hashbucket)
self.filep.close()
# a rather complete test suite
if __name__ == "__main__":
import os,sys,time
from random import randint, seed
import hotshot, hotshot.stats
# make python behave for our massive crunching needs
sys.setcheckinterval(10000)
# utility to write data
def randstr(): return "".join([ chr(randint(65,90)) for i in xrange(randint(1,32)) ])
def make_data(n):
print "TEST: Making test data"
return [ (randstr(),randstr()) for i in xrange(n)]
def test_write(testlist, fname="test.cdb"):
starttime = time.time()
# initialize a builder system for a cdb
print "TEST: | __get | identifier_name |
cdb.py | <- 256 pairs of uint32 structures [absolute offset][length]
... positioning works like this: header[hash & 0xff]
[header]
[data] <- we're jumping over this;
... each data node consists of [key_length][value_length][key][value]
[data]
[hash_lookup_table] <- there's 256 of these; they're full of babies
... each one has [hash][absolute offset]
... each is (2*entries) long for hash searches
[hash_lookup_table]
Usage:
>>> (build a cdb)
>>> read = reader("test.cdb")
>>> print 'read["a key"] =', read["a key"]
>>> for (key, value) in read.iteritems():
... print key, '= (',
... for values in value:
... print value + ',',
... print ')'
"""
def __init__(self, infile):
"""Open the file connection."""
if isinstance(infile, str): self.filep = open(infile, "r+b")
else: self.filep = infile
# attempt to read file from the start
self.filep.seek(0)
self.start = self.filep.tell()
# get the least pos_bucket position (beginning of subtables)
self.header = unpack('<512L', self.filep.read(2048))
# find the end of the data
self.enddata = min(self.header[0::2])
def __get(self,index,single=True):
return_value = []
hash_prime = calc_hash(index)
# pull data from the cached header
headhash = hash_prime % 256
pos_bucket= self.header[headhash + headhash]
ncells = self.header[headhash + headhash + 1]
# since the 256*8 bytes are all zeroed, this means the hash
# was invalid as we pulled it.
if ncells == 0: raise KeyError
# calculate predictive lookup
offset = (hash_prime >> 8) % ncells
# set a die badly flag (throw key error)
found = False
# loop through the number of cells in the hash range
for step in range(ncells):
self.filep.seek(pos_bucket + ((offset + step) % ncells) * 8)
# grab the hash and position in the data stream
(hash, pointer) = unpack('<LL', self.filep.read(8))
# throw an error if the hash just dumped us in the dirt
if pointer == 0:
# if there were no keys found, complain (else break)
if not found: raise KeyError
break
# check that the hash values check
if hash == hash_prime:
# seek to the location indicated
self.filep.seek(pointer)
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
key = self.filep.read(klen)
value = self.filep.read(vlen)
# make sure that the keys match
if key == index:
return_value.append(value)
# if we're only looking for one item, break out
if single: break
# set found flag for multiple value end condition
found = True
# if there were no records hit, dump a keyerror
else: raise KeyError
# throw back a tuple of the values found for key
return tuple(return_value)
def __getitem__(self,index):
# shortcut to __get
if not isinstance(index, str): raise TypeError
self.__get(index)
def get(self,index,default=None):
try:
return self.__get(index,single=False)
except:
if default is not None: return default
raise KeyError
def has_key(self,index):
"""A simple analog of the has_key dict function."""
try:
self.__get(index)
return True
except:
return False
def iteritems(self):
"""A straight pull of the items in the cdb."""
self.filep.seek(self.start + 2048)
# iterate until we hit the enddata marker
while self.filep.tell() < self.enddata - 1:
# fetch the lengths of the key and value
(klen, vlen) = unpack('<LL', self.filep.read(8))
# yield the key and value as a tuple
yield (self.filep.read(klen), self.filep.read(vlen))
def close(self):
"""Close out the file connection."""
self.filep.close()
class builder(object):
"""
The Constant Database system is by DJB (the greatest hero on the interwub)
I just happen to implement it here bceause it's 1.fast, 2.good, 3.fast.
And I need all three aspects.
Usage:
>>> build = builder("test.cdb")
>>> build['a key'] = 'some value n for stupid'
>>> build.close()
The resultant CDB is read by any compatible lib (including reader above)
Access times are good, but can be made mucho faster with psyco.
"""
def __init__(self, infile):
if isinstance(infile, str):
|
else: self.filep = infile
# attempt to read file from the start
self.filep.seek(0)
self.start = self.filep.tell()
# track pointers and hash table data
self.hashbucket = [ array.array('L') for i in range(256) ]
# skip past header storage (file header + 2048)
self.position_hash = self.start + 2048
self.filep.seek(self.position_hash)
def __setitem__(self, index, value):
"""CDB supports multiple values for each key. Problems? Too bad."""
# create value and key storage
self.filep.write(pack('<LL',len(index), len(value)))
self.filep.write(index)
self.filep.write(value)
# grab a hash for the key
hash = calc_hash(index)
# dump a new hash into our bucket
self.hashbucket[hash % 256].fromlist([hash, self.position_hash])
self.position_hash += 8 + (len(index) + len(value))
def close(self):
from sys import byteorder
# preinitialize array and find byteorder
cell = array.array('L')
shouldswap = (byteorder == 'big')
# iterate completed values for the hash bucket
for hpindex in [ i for i in xrange(256) ]:
ncells = self.hashbucket[hpindex].buffer_info()[1]
if ncells <= 0:
self.hashbucket[hpindex].append(0)
continue
# create blank cell structure
cell.fromlist([ 0 for i in xrange(ncells+ncells) ])
# loop over hash pairs (xrange with parameters = fast)
for i in xrange(0, ncells, 2):
# pull hash from the hashbucket
hash = self.hashbucket[hpindex].pop(0)
# predictive lookup for jump
index = (hash >> 8) % ncells
# skip occupied cells
while cell[index+index] != 0: index = (index + 1) % ncells
# pull pointer and assign hash/pointer set to cell
cell[index+index] = hash
cell[index+index+1] = self.hashbucket[hpindex].pop(0)
# push length back onto stack
self.hashbucket[hpindex].append(ncells)
# write the hash table (swap bytes if we're bigendian)
if shouldswap: cell.byteswap()
cell.tofile(self.filep)
del cell[:]
# skip to start of file
self.filep.seek(self.start)
# dump some information about the hash pairs into the header
for i in xrange(256):
self.filep.write(pack('<LL', self.position_hash, self.hashbucket[i][0]))
self.position_hash += 8 * self.hashbucket[i].pop()
# free up the hashbucket and cell
del(cell)
del(self.hashbucket)
self.filep.close()
# a rather complete test suite
if __name__ == "__main__":
import os,sys,time
from random import randint, seed
import hotshot, hotshot.stats
# make python behave for our massive crunching needs
sys.setcheckinterval(10000)
# utility to write data
def randstr(): return "".join([ chr(randint(65,90)) for i in xrange(randint(1,32)) ])
def make_data(n):
print "TEST: Making test data"
return [ (randstr(),randstr()) for i in xrange(n)]
def test_write(testlist, fname="test.cdb"):
starttime = time.time()
# initialize a builder system for a cdb
print "TEST: | self.filep = open(infile, "w+b") | conditional_block |
gimli.rs | seg.filesize(endian) > 0 {
text_fileoff_zero = true;
}
}
segments.push(LibrarySegment {
len: seg.vmsize(endian).try_into().ok()?,
stated_virtual_memory_address: seg.vmaddr(endian).try_into().ok()?,
});
}
if let Some((seg, _)) = cmd.segment_64().ok()? {
if seg.name() == b"__TEXT" {
first_text = segments.len();
if seg.fileoff(endian) == 0 && seg.filesize(endian) > 0 {
text_fileoff_zero = true;
}
}
segments.push(LibrarySegment {
len: seg.vmsize(endian).try_into().ok()?,
stated_virtual_memory_address: seg.vmaddr(endian).try_into().ok()?,
});
}
}
// Determine the "slide" for this library which ends up being the
// bias we use to figure out where in memory objects are loaded.
// This is a bit of a weird computation though and is the result of
// trying a few things in the wild and seeing what sticks.
//
// The general idea is that the `bias` plus a segment's
// `stated_virtual_memory_address` is going to be where in the
// actual address space the segment resides. The other thing we rely
// on though is that a real address minus the `bias` is the index to
// look up in the symbol table and debuginfo.
//
// It turns out, though, that for system loaded libraries these
// calculations are incorrect. For native executables, however, it
// appears correct. Lifting some logic from LLDB's source it has
// some special-casing for the first `__TEXT` section loaded from
// file offset 0 with a nonzero size. For whatever reason when this
// is present it appears to mean that the symbol table is relative
// to just the vmaddr slide for the library. If it's *not* present
// then the symbol table is relative to the the vmaddr slide plus
// the segment's stated address.
//
// To handle this situation if we *don't* find a text section at
// file offset zero then we increase the bias by the first text
// sections's stated address and decrease all stated addresses by
// that amount as well. That way the symbol table is always appears
// relative to the library's bias amount. This appears to have the
// right results for symbolizing via the symbol table.
//
// Honestly I'm not entirely sure whether this is right or if
// there's something else that should indicate how to do this. For
// now though this seems to work well enough (?) and we should
// always be able to tweak this over time if necessary.
//
// For some more information see #318
let mut slide = unsafe { libc::_dyld_get_image_vmaddr_slide(i) as usize };
if !text_fileoff_zero {
let adjust = segments[first_text].stated_virtual_memory_address;
for segment in segments.iter_mut() {
segment.stated_virtual_memory_address -= adjust;
}
slide += adjust;
}
Some(Library {
name: OsStr::from_bytes(name.to_bytes()).to_owned(),
segments,
bias: slide,
})
}
} else if #[cfg(any(
target_os = "linux",
target_os = "fuchsia",
))] {
// Other Unix (e.g. Linux) platforms use ELF as an object file format
// and typically implement an API called `dl_iterate_phdr` to load
// native libraries.
use mystd::os::unix::prelude::*;
use mystd::ffi::{OsStr, CStr};
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
let mut ret = Vec::new();
unsafe {
libc::dl_iterate_phdr(Some(callback), &mut ret as *mut _ as *mut _);
}
return ret;
}
unsafe extern "C" fn callback(
info: *mut libc::dl_phdr_info,
_size: libc::size_t,
vec: *mut libc::c_void,
) -> libc::c_int {
let libs = &mut *(vec as *mut Vec<Library>);
let name = if (*info).dlpi_name.is_null() || *(*info).dlpi_name == 0{
if libs.is_empty() {
mystd::env::current_exe().map(|e| e.into()).unwrap_or_default()
} else {
OsString::new()
}
} else {
let bytes = CStr::from_ptr((*info).dlpi_name).to_bytes();
OsStr::from_bytes(bytes).to_owned()
};
let headers = core::slice::from_raw_parts((*info).dlpi_phdr, (*info).dlpi_phnum as usize);
libs.push(Library {
name,
segments: headers
.iter()
.map(|header| LibrarySegment {
len: (*header).p_memsz as usize,
stated_virtual_memory_address: (*header).p_vaddr as usize,
})
.collect(),
bias: (*info).dlpi_addr as usize,
});
0
}
} else if #[cfg(target_env = "libnx")] {
// DevkitA64 doesn't natively support debug info, but the build system will place debug
// info at the path `romfs:/debug_info.elf`.
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
extern "C" {
static __start__: u8;
}
let bias = unsafe { &__start__ } as *const u8 as usize;
let mut ret = Vec::new();
let mut segments = Vec::new();
segments.push(LibrarySegment {
stated_virtual_memory_address: 0,
len: usize::max_value() - bias,
});
let path = "romfs:/debug_info.elf";
ret.push(Library {
name: path.into(),
segments,
bias,
});
ret
}
} else {
// Everything else should use ELF, but doesn't know how to load native
// libraries.
use mystd::os::unix::prelude::*;
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
Vec::new()
}
}
}
#[derive(Default)]
struct Cache {
/// All known shared libraries that have been loaded.
libraries: Vec<Library>,
/// Mappings cache where we retain parsed dwarf information.
///
/// This list has a fixed capacity for its entire liftime which never
/// increases. The `usize` element of each pair is an index into `libraries`
/// above where `usize::max_value()` represents the current executable. The
/// `Mapping` is corresponding parsed dwarf information.
///
/// Note that this is basically an LRU cache and we'll be shifting things
/// around in here as we symbolize addresses.
mappings: Vec<(usize, Mapping)>,
}
struct Library {
name: OsString,
/// Segments of this library loaded into memory, and where they're loaded.
segments: Vec<LibrarySegment>,
/// The "bias" of this library, typically where it's loaded into memory.
/// This value is added to each segment's stated address to get the actual
/// virtual memory address that the segment is loaded into. Additionally
/// this bias is subtracted from real virtual memory addresses to index into
/// debuginfo and the symbol table.
bias: usize,
}
struct LibrarySegment {
/// The stated address of this segment in the object file. This is not
/// actually where the segment is loaded, but rather this address plus the
/// containing library's `bias` is where to find it.
stated_virtual_memory_address: usize,
/// The size of ths segment in memory.
len: usize,
}
// unsafe because this is required to be externally synchronized
pub unsafe fn clear_symbol_cache() {
Cache::with_global(|cache| cache.mappings.clear());
}
impl Cache {
fn new() -> Cache {
Cache {
mappings: Vec::with_capacity(MAPPINGS_CACHE_SIZE),
libraries: native_libraries(),
}
}
// unsafe because this is required to be externally synchronized
unsafe fn with_global(f: impl FnOnce(&mut Self)) | {
// A very small, very simple LRU cache for debug info mappings.
//
// The hit rate should be very high, since the typical stack doesn't cross
// between many shared libraries.
//
// The `addr2line::Context` structures are pretty expensive to create. Its
// cost is expected to be amortized by subsequent `locate` queries, which
// leverage the structures built when constructing `addr2line::Context`s to
// get nice speedups. If we didn't have this cache, that amortization would
// never happen, and symbolicating backtraces would be ssssllllooooowwww.
static mut MAPPINGS_CACHE: Option<Cache> = None;
f(MAPPINGS_CACHE.get_or_insert_with(|| Cache::new()))
} | identifier_body |
|
gimli.rs | let name = libc::_dyld_get_image_name(i);
if name.is_null() {
return None;
}
CStr::from_ptr(name)
};
// Load the image header of this library and delegate to `object` to
// parse all the load commands so we can figure out all the segments
// involved here.
let (mut load_commands, endian) = unsafe {
let header = libc::_dyld_get_image_header(i);
if header.is_null() {
return None;
}
match (*header).magic {
macho::MH_MAGIC => {
let endian = NativeEndian;
let header = &*(header as *const macho::MachHeader32<NativeEndian>);
let data = core::slice::from_raw_parts(
header as *const _ as *const u8,
mem::size_of_val(header) + header.sizeofcmds.get(endian) as usize
);
(header.load_commands(endian, Bytes(data)).ok()?, endian)
}
macho::MH_MAGIC_64 => {
let endian = NativeEndian;
let header = &*(header as *const macho::MachHeader64<NativeEndian>);
let data = core::slice::from_raw_parts(
header as *const _ as *const u8,
mem::size_of_val(header) + header.sizeofcmds.get(endian) as usize
);
(header.load_commands(endian, Bytes(data)).ok()?, endian)
}
_ => return None,
}
};
// Iterate over the segments and register known regions for segments
// that we find. Additionally record information bout text segments
// for processing later, see comments below.
let mut segments = Vec::new();
let mut first_text = 0;
let mut text_fileoff_zero = false;
while let Some(cmd) = load_commands.next().ok()? {
if let Some((seg, _)) = cmd.segment_32().ok()? {
if seg.name() == b"__TEXT" {
first_text = segments.len();
if seg.fileoff(endian) == 0 && seg.filesize(endian) > 0 {
text_fileoff_zero = true;
}
}
segments.push(LibrarySegment {
len: seg.vmsize(endian).try_into().ok()?,
stated_virtual_memory_address: seg.vmaddr(endian).try_into().ok()?,
});
}
if let Some((seg, _)) = cmd.segment_64().ok()? {
if seg.name() == b"__TEXT" {
first_text = segments.len();
if seg.fileoff(endian) == 0 && seg.filesize(endian) > 0 {
text_fileoff_zero = true;
}
}
segments.push(LibrarySegment {
len: seg.vmsize(endian).try_into().ok()?,
stated_virtual_memory_address: seg.vmaddr(endian).try_into().ok()?,
});
}
}
// Determine the "slide" for this library which ends up being the
// bias we use to figure out where in memory objects are loaded.
// This is a bit of a weird computation though and is the result of
// trying a few things in the wild and seeing what sticks.
//
// The general idea is that the `bias` plus a segment's
// `stated_virtual_memory_address` is going to be where in the
// actual address space the segment resides. The other thing we rely
// on though is that a real address minus the `bias` is the index to
// look up in the symbol table and debuginfo.
//
// It turns out, though, that for system loaded libraries these
// calculations are incorrect. For native executables, however, it
// appears correct. Lifting some logic from LLDB's source it has
// some special-casing for the first `__TEXT` section loaded from
// file offset 0 with a nonzero size. For whatever reason when this
// is present it appears to mean that the symbol table is relative
// to just the vmaddr slide for the library. If it's *not* present
// then the symbol table is relative to the the vmaddr slide plus
// the segment's stated address.
//
// To handle this situation if we *don't* find a text section at
// file offset zero then we increase the bias by the first text
// sections's stated address and decrease all stated addresses by
// that amount as well. That way the symbol table is always appears
// relative to the library's bias amount. This appears to have the
// right results for symbolizing via the symbol table.
//
// Honestly I'm not entirely sure whether this is right or if
// there's something else that should indicate how to do this. For
// now though this seems to work well enough (?) and we should
// always be able to tweak this over time if necessary.
//
// For some more information see #318
let mut slide = unsafe { libc::_dyld_get_image_vmaddr_slide(i) as usize };
if !text_fileoff_zero {
let adjust = segments[first_text].stated_virtual_memory_address;
for segment in segments.iter_mut() {
segment.stated_virtual_memory_address -= adjust;
}
slide += adjust;
}
Some(Library {
name: OsStr::from_bytes(name.to_bytes()).to_owned(),
segments,
bias: slide,
})
}
} else if #[cfg(any(
target_os = "linux",
target_os = "fuchsia",
))] {
// Other Unix (e.g. Linux) platforms use ELF as an object file format
// and typically implement an API called `dl_iterate_phdr` to load
// native libraries.
use mystd::os::unix::prelude::*;
use mystd::ffi::{OsStr, CStr};
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
let mut ret = Vec::new();
unsafe {
libc::dl_iterate_phdr(Some(callback), &mut ret as *mut _ as *mut _);
}
return ret;
}
unsafe extern "C" fn callback(
info: *mut libc::dl_phdr_info,
_size: libc::size_t,
vec: *mut libc::c_void,
) -> libc::c_int {
let libs = &mut *(vec as *mut Vec<Library>);
let name = if (*info).dlpi_name.is_null() || *(*info).dlpi_name == 0{
if libs.is_empty() {
mystd::env::current_exe().map(|e| e.into()).unwrap_or_default()
} else {
OsString::new()
}
} else {
let bytes = CStr::from_ptr((*info).dlpi_name).to_bytes();
OsStr::from_bytes(bytes).to_owned()
};
let headers = core::slice::from_raw_parts((*info).dlpi_phdr, (*info).dlpi_phnum as usize);
libs.push(Library {
name,
segments: headers
.iter()
.map(|header| LibrarySegment {
len: (*header).p_memsz as usize,
stated_virtual_memory_address: (*header).p_vaddr as usize,
})
.collect(),
bias: (*info).dlpi_addr as usize,
});
0
}
} else if #[cfg(target_env = "libnx")] {
// DevkitA64 doesn't natively support debug info, but the build system will place debug
// info at the path `romfs:/debug_info.elf`.
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
extern "C" {
static __start__: u8;
}
let bias = unsafe { &__start__ } as *const u8 as usize;
let mut ret = Vec::new();
let mut segments = Vec::new();
segments.push(LibrarySegment {
stated_virtual_memory_address: 0,
len: usize::max_value() - bias,
});
let path = "romfs:/debug_info.elf";
ret.push(Library {
name: path.into(),
segments,
bias,
});
ret
}
} else {
// Everything else should use ELF, but doesn't know how to load native
// libraries.
use mystd::os::unix::prelude::*;
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
Vec::new()
}
}
}
#[derive(Default)]
struct Cache {
/// All known shared libraries that have been loaded.
libraries: Vec<Library>,
/// Mappings cache where we retain parsed dwarf information.
///
/// This list has a fixed capacity for its entire liftime which never
/// increases. The `usize` element of each pair is an index into `libraries`
/// above where `usize::max_value()` represents the current executable. The
/// `Mapping` is corresponding parsed dwarf information.
/// | /// Note that this is basically an LRU cache and we'll be shifting things
/// around in here as we symbolize addresses.
mappings: Vec<(usize, Mapping)>, | random_line_split |
|
gimli.rs | incorrect. For native executables, however, it
// appears correct. Lifting some logic from LLDB's source it has
// some special-casing for the first `__TEXT` section loaded from
// file offset 0 with a nonzero size. For whatever reason when this
// is present it appears to mean that the symbol table is relative
// to just the vmaddr slide for the library. If it's *not* present
// then the symbol table is relative to the the vmaddr slide plus
// the segment's stated address.
//
// To handle this situation if we *don't* find a text section at
// file offset zero then we increase the bias by the first text
// sections's stated address and decrease all stated addresses by
// that amount as well. That way the symbol table is always appears
// relative to the library's bias amount. This appears to have the
// right results for symbolizing via the symbol table.
//
// Honestly I'm not entirely sure whether this is right or if
// there's something else that should indicate how to do this. For
// now though this seems to work well enough (?) and we should
// always be able to tweak this over time if necessary.
//
// For some more information see #318
let mut slide = unsafe { libc::_dyld_get_image_vmaddr_slide(i) as usize };
if !text_fileoff_zero {
let adjust = segments[first_text].stated_virtual_memory_address;
for segment in segments.iter_mut() {
segment.stated_virtual_memory_address -= adjust;
}
slide += adjust;
}
Some(Library {
name: OsStr::from_bytes(name.to_bytes()).to_owned(),
segments,
bias: slide,
})
}
} else if #[cfg(any(
target_os = "linux",
target_os = "fuchsia",
))] {
// Other Unix (e.g. Linux) platforms use ELF as an object file format
// and typically implement an API called `dl_iterate_phdr` to load
// native libraries.
use mystd::os::unix::prelude::*;
use mystd::ffi::{OsStr, CStr};
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
let mut ret = Vec::new();
unsafe {
libc::dl_iterate_phdr(Some(callback), &mut ret as *mut _ as *mut _);
}
return ret;
}
unsafe extern "C" fn callback(
info: *mut libc::dl_phdr_info,
_size: libc::size_t,
vec: *mut libc::c_void,
) -> libc::c_int {
let libs = &mut *(vec as *mut Vec<Library>);
let name = if (*info).dlpi_name.is_null() || *(*info).dlpi_name == 0{
if libs.is_empty() {
mystd::env::current_exe().map(|e| e.into()).unwrap_or_default()
} else {
OsString::new()
}
} else {
let bytes = CStr::from_ptr((*info).dlpi_name).to_bytes();
OsStr::from_bytes(bytes).to_owned()
};
let headers = core::slice::from_raw_parts((*info).dlpi_phdr, (*info).dlpi_phnum as usize);
libs.push(Library {
name,
segments: headers
.iter()
.map(|header| LibrarySegment {
len: (*header).p_memsz as usize,
stated_virtual_memory_address: (*header).p_vaddr as usize,
})
.collect(),
bias: (*info).dlpi_addr as usize,
});
0
}
} else if #[cfg(target_env = "libnx")] {
// DevkitA64 doesn't natively support debug info, but the build system will place debug
// info at the path `romfs:/debug_info.elf`.
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
extern "C" {
static __start__: u8;
}
let bias = unsafe { &__start__ } as *const u8 as usize;
let mut ret = Vec::new();
let mut segments = Vec::new();
segments.push(LibrarySegment {
stated_virtual_memory_address: 0,
len: usize::max_value() - bias,
});
let path = "romfs:/debug_info.elf";
ret.push(Library {
name: path.into(),
segments,
bias,
});
ret
}
} else {
// Everything else should use ELF, but doesn't know how to load native
// libraries.
use mystd::os::unix::prelude::*;
mod elf;
use self::elf::Object;
fn native_libraries() -> Vec<Library> {
Vec::new()
}
}
}
#[derive(Default)]
struct Cache {
/// All known shared libraries that have been loaded.
libraries: Vec<Library>,
/// Mappings cache where we retain parsed dwarf information.
///
/// This list has a fixed capacity for its entire liftime which never
/// increases. The `usize` element of each pair is an index into `libraries`
/// above where `usize::max_value()` represents the current executable. The
/// `Mapping` is corresponding parsed dwarf information.
///
/// Note that this is basically an LRU cache and we'll be shifting things
/// around in here as we symbolize addresses.
mappings: Vec<(usize, Mapping)>,
}
struct Library {
name: OsString,
/// Segments of this library loaded into memory, and where they're loaded.
segments: Vec<LibrarySegment>,
/// The "bias" of this library, typically where it's loaded into memory.
/// This value is added to each segment's stated address to get the actual
/// virtual memory address that the segment is loaded into. Additionally
/// this bias is subtracted from real virtual memory addresses to index into
/// debuginfo and the symbol table.
bias: usize,
}
struct LibrarySegment {
/// The stated address of this segment in the object file. This is not
/// actually where the segment is loaded, but rather this address plus the
/// containing library's `bias` is where to find it.
stated_virtual_memory_address: usize,
/// The size of ths segment in memory.
len: usize,
}
// unsafe because this is required to be externally synchronized
pub unsafe fn clear_symbol_cache() {
Cache::with_global(|cache| cache.mappings.clear());
}
impl Cache {
fn new() -> Cache {
Cache {
mappings: Vec::with_capacity(MAPPINGS_CACHE_SIZE),
libraries: native_libraries(),
}
}
// unsafe because this is required to be externally synchronized
unsafe fn with_global(f: impl FnOnce(&mut Self)) {
// A very small, very simple LRU cache for debug info mappings.
//
// The hit rate should be very high, since the typical stack doesn't cross
// between many shared libraries.
//
// The `addr2line::Context` structures are pretty expensive to create. Its
// cost is expected to be amortized by subsequent `locate` queries, which
// leverage the structures built when constructing `addr2line::Context`s to
// get nice speedups. If we didn't have this cache, that amortization would
// never happen, and symbolicating backtraces would be ssssllllooooowwww.
static mut MAPPINGS_CACHE: Option<Cache> = None;
f(MAPPINGS_CACHE.get_or_insert_with(|| Cache::new()))
}
fn avma_to_svma(&self, addr: *const u8) -> Option<(usize, *const u8)> {
self.libraries
.iter()
.enumerate()
.filter_map(|(i, lib)| {
// First up, test if this `lib` has any segment containing the
// `addr` (handling relocation). If this check passes then we
// can continue below and actually translate the address.
//
// Note that we're using `wrapping_add` here to avoid overflow
// checks. It's been seen in the wild that the SVMA + bias
// computation overflows. It seems a bit odd that would happen
// but there's not a huge amount we can do about it other than
// probably just ignore those segments since they're likely
// pointing off into space. This originally came up in
// rust-lang/backtrace-rs#329.
if !lib.segments.iter().any(|s| {
let svma = s.stated_virtual_memory_address;
let start = svma.wrapping_add(lib.bias);
let end = start.wrapping_add(s.len);
let address = addr as usize;
start <= address && address < end
}) {
return None;
}
// Now that we know `lib` contains `addr`, we can offset with
// the bias to find the stated virutal memory address.
let svma = (addr as usize).wrapping_sub(lib.bias);
Some((i, svma as *const u8))
})
.next()
}
fn | mapping_for_lib | identifier_name |
|
main.py | logging.critical('Please, rename config.py.template to config.py and edit it.\nOr specify a config to load on the command line: py scgb.py <config file>')
sys.exit(1)
# Init database
db = Database(config.stats_database)
# Init banlist
load_banlist()
# Init soundcloud client
init_api()
def init_api():
"""Authenticate with SoundCloud API.
Cache access token in the secrets file."""
global soundcloud
import json
SECRETS_VERSION = 1
# Load secrets file
if os.path.exists(config.token_cache):
with open(config.token_cache, 'r', encoding='utf-8') as f:
secrets = json.load(f)
else:
secrets = {}
# Try to reuse the cached access token
if secrets\
and secrets['version'] == SECRETS_VERSION\
and secrets['access_token_acquired_at'] + secrets['access_token_expires_in'] > time() - 5 * 60\
and secrets['username'] == config.username:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
access_token=secrets['access_token']
)
return
# Get a new access token
logging.info('Getting a new access token')
try:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
username=config.username,
password=config.password
)
except HTTPError as e:
if e.response.status_code == 401:
logging.critical('Incorrect API key, login or password. Please, edit config.py.')
sys.exit(1)
else:
raise
# Save the token
secrets = {
'version': SECRETS_VERSION,
'username': config.username,
'access_token': soundcloud.access_token,
'access_token_acquired_at': time(),
'access_token_expires_in': soundcloud.token.expires_in,
}
with open(config.token_cache, 'w', encoding='utf-8') as f:
secrets = json.dump(secrets, f, indent='\t', ensure_ascii=False)
def load_banlist():
"""Load the banlist."""
# create banlist if it doesn't exist
if not os.path.exists(config.banlistfile):
open(config.banlistfile, 'ab').close()
with open(config.banlistfile, 'r') as file:
for line in file:
line = line.strip()
if line == '' or line.startswith('//'):
continue # skip empty lines and comments
values = line.split(None, 2)
what = values[0]
if what not in ['user', 'track', 'playlist']:
logging.warning('Banlist error: unknown ban type: %s', what)
continue
try:
id = int(values[1])
except ValueError:
logging.warning('Banlist error: %d is not a %s id number', id, what)
continue
if len(values) > 2:
banlist[what][id] = values[2]
else:
banlist[what][id] = "No reason given."
def check_comments():
"""Download all comments and process them."""
# Get the id of the group track
try:
group_track = soundcloud.get('/me/tracks')[config.post_track_id]
except HTTPError as e:
if e.response.status_code == 404:
logging.critical('Cannot find a track with id %d. Please, fix post_track_id in config.py', config.post_track_id)
sys.exit(1)
else:
raise
# Get the comment list for the group track
comments = soundcloud.get('/tracks/%d/comments' % group_track.id)
if not comments:
logging.info('Nothing found...')
return
# Process each comment and delete it
for comment in reversed(comments):
logging.info('Processing a comment by user %d (%s): %s', comment.user_id, comment.user['username'], comment.body)
response = None
# Try to process the comment
try:
response = process_comment(comment)
except HTTPError as e:
if e.response.status_code == 429:
logging.exception('Failed to repost track: too many requests:')
return
elif e.response.status_code // 100 == 4:
logging.exception('Failed to process comment due to a client request error:')
else:
raise
except Exception as e: # Program crash
logging.exception('Failed to process comment:')
else:
if response:
logging.info('The comment would have this response: %s', response)
else:
logging.info('Comment processed successfully')
# Delete the processed comment
try:
soundcloud.delete('/tracks/' + str(group_track.id) + '/comments/' + str(comment.id))
except HTTPError as e:
if e.response.status_code == 404:
logging.warning('Comment already deleted')
else:
raise |
def process_comment(comment):
"""Process a single comment."""
if not comment.body:
logging.info('Empty URL detected.')
return 'Your comment is empty.'
if comment.user_id in banlist['user']:
logging.info('Banned user id: %d', comment.user_id)
return 'You are banned from this group.'
url = comment.body
action = 'repost'
if url.startswith('!'):
action = 'delete'
url = url[1:]
# Resolve the resource to repost
resource = resolve_resource(url)
if resource:
logging.info('Resolved: %s %d', resource.kind, resource.id)
if resource.kind == 'playlist' and not config.allow_playlists:
logging.info('Playlists are not allowed. Skipping.')
return 'Playlists are not allowed in this group.'
else:
logging.info('Not found')
if not resource or resource.kind not in ('track', 'playlist'):
if config.allow_playlists:
return 'The provided link does not lead to a track or playlist.'
else:
return 'The provided link does not lead to a track.'
resource_type = resource.kind
# Check for ownership
if not config.debug_mode and comment.user_id != resource.user_id:
logging.info('Not the author of the resource')
return 'You must be the author of the {} to post it in this group.'.format(resource_type)
# Is the resource banned?
if resource.id in banlist[resource_type]:
reason = banlist[resource_type][resource.id];
logging.info('This resource is banned: %s', reason)
return 'This track or playlist is banned from this group: ' + reason
# Repost/delete if needed
is_reposted = check_repost_exists(resource_type, resource.id)
if action == 'repost':
# Genre filter
if config.allowed_genres is not None:
genres_lowercase = [ genre.lower() for genre in config.allowed_genres ]
if resource.genre.lower() not in genres_lowercase:
logging.info('Genre not allowed: %s', resource.genre)
return 'This genre is not allowed in this group. Allowed genres are: ' + ', '.join(config.allowed_genres)
# Disable bumps if needed
if not config.allow_bumps and db.has_ever_been_posted(resource_type, resource.id):
logging.info('Bumping is disabled and this resource is present in the database.')
return 'Bumping is not allowed in this group.'
# Enforce minimum bump interval
last_reposted = db.last_repost_time(resource_type, resource.id)
if last_reposted is not None and last_reposted > int(time()) - config.min_bump_interval:
logging.info('This %s was posted %d seconds ago, but minimum bump interval is %d.', resource_type, int(time()) - last_reposted, config.min_bump_interval)
return 'This {} is posted to the group too frequently. Try again later.'.format(resource_type)
# Enforce max posts
last_post_count = db.user_last_posts_count(comment.user_id, config.post_limit_interval)
if last_post_count >= config.post_limit:
logging.info('The user has already made %d reposts.', last_post_count)
return 'You have already made {} posts.'.format(config.post_limit)
# Execute the command
if is_reposted:
logging.info('Bumping:')
group_delete(comment.user_id, resource_type, resource.id)
group_repost(comment.user_id, resource_type, resource.id)
else:
group_repost(comment.user_id, resource_type, resource.id)
request_description_update()
elif action == 'delete':
if is_reposted:
group_delete(comment.user_id, resource_type, resource.id)
request_description_update()
else:
logging.info('Resource already deleted')
else:
assert False, 'Unknown action: ' + repr(action)
def resolve_resource(url):
"""Return the resource object downloaded from url, or None, if not found."""
try:
resource = soundcloud.get('/resolve', url=url)
except HTTPError as e:
if e.response.status_code == 404:
return None
else:
raise
return resource
def |
if config.use_advanced_description and should_update_description:
update_description() | random_line_split |
main.py |
# Load secrets file
if os.path.exists(config.token_cache):
with open(config.token_cache, 'r', encoding='utf-8') as f:
secrets = json.load(f)
else:
secrets = {}
# Try to reuse the cached access token
if secrets\
and secrets['version'] == SECRETS_VERSION\
and secrets['access_token_acquired_at'] + secrets['access_token_expires_in'] > time() - 5 * 60\
and secrets['username'] == config.username:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
access_token=secrets['access_token']
)
return
# Get a new access token
logging.info('Getting a new access token')
try:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
username=config.username,
password=config.password
)
except HTTPError as e:
if e.response.status_code == 401:
logging.critical('Incorrect API key, login or password. Please, edit config.py.')
sys.exit(1)
else:
raise
# Save the token
secrets = {
'version': SECRETS_VERSION,
'username': config.username,
'access_token': soundcloud.access_token,
'access_token_acquired_at': time(),
'access_token_expires_in': soundcloud.token.expires_in,
}
with open(config.token_cache, 'w', encoding='utf-8') as f:
secrets = json.dump(secrets, f, indent='\t', ensure_ascii=False)
def load_banlist():
"""Load the banlist."""
# create banlist if it doesn't exist
if not os.path.exists(config.banlistfile):
open(config.banlistfile, 'ab').close()
with open(config.banlistfile, 'r') as file:
for line in file:
line = line.strip()
if line == '' or line.startswith('//'):
continue # skip empty lines and comments
values = line.split(None, 2)
what = values[0]
if what not in ['user', 'track', 'playlist']:
logging.warning('Banlist error: unknown ban type: %s', what)
continue
try:
id = int(values[1])
except ValueError:
logging.warning('Banlist error: %d is not a %s id number', id, what)
continue
if len(values) > 2:
banlist[what][id] = values[2]
else:
banlist[what][id] = "No reason given."
def check_comments():
"""Download all comments and process them."""
# Get the id of the group track
try:
group_track = soundcloud.get('/me/tracks')[config.post_track_id]
except HTTPError as e:
if e.response.status_code == 404:
logging.critical('Cannot find a track with id %d. Please, fix post_track_id in config.py', config.post_track_id)
sys.exit(1)
else:
raise
# Get the comment list for the group track
comments = soundcloud.get('/tracks/%d/comments' % group_track.id)
if not comments:
logging.info('Nothing found...')
return
# Process each comment and delete it
for comment in reversed(comments):
logging.info('Processing a comment by user %d (%s): %s', comment.user_id, comment.user['username'], comment.body)
response = None
# Try to process the comment
try:
response = process_comment(comment)
except HTTPError as e:
if e.response.status_code == 429:
logging.exception('Failed to repost track: too many requests:')
return
elif e.response.status_code // 100 == 4:
logging.exception('Failed to process comment due to a client request error:')
else:
raise
except Exception as e: # Program crash
logging.exception('Failed to process comment:')
else:
if response:
logging.info('The comment would have this response: %s', response)
else:
logging.info('Comment processed successfully')
# Delete the processed comment
try:
soundcloud.delete('/tracks/' + str(group_track.id) + '/comments/' + str(comment.id))
except HTTPError as e:
if e.response.status_code == 404:
logging.warning('Comment already deleted')
else:
raise
if config.use_advanced_description and should_update_description:
update_description()
def process_comment(comment):
"""Process a single comment."""
if not comment.body:
logging.info('Empty URL detected.')
return 'Your comment is empty.'
if comment.user_id in banlist['user']:
logging.info('Banned user id: %d', comment.user_id)
return 'You are banned from this group.'
url = comment.body
action = 'repost'
if url.startswith('!'):
action = 'delete'
url = url[1:]
# Resolve the resource to repost
resource = resolve_resource(url)
if resource:
logging.info('Resolved: %s %d', resource.kind, resource.id)
if resource.kind == 'playlist' and not config.allow_playlists:
logging.info('Playlists are not allowed. Skipping.')
return 'Playlists are not allowed in this group.'
else:
logging.info('Not found')
if not resource or resource.kind not in ('track', 'playlist'):
if config.allow_playlists:
return 'The provided link does not lead to a track or playlist.'
else:
return 'The provided link does not lead to a track.'
resource_type = resource.kind
# Check for ownership
if not config.debug_mode and comment.user_id != resource.user_id:
logging.info('Not the author of the resource')
return 'You must be the author of the {} to post it in this group.'.format(resource_type)
# Is the resource banned?
if resource.id in banlist[resource_type]:
reason = banlist[resource_type][resource.id];
logging.info('This resource is banned: %s', reason)
return 'This track or playlist is banned from this group: ' + reason
# Repost/delete if needed
is_reposted = check_repost_exists(resource_type, resource.id)
if action == 'repost':
# Genre filter
if config.allowed_genres is not None:
genres_lowercase = [ genre.lower() for genre in config.allowed_genres ]
if resource.genre.lower() not in genres_lowercase:
logging.info('Genre not allowed: %s', resource.genre)
return 'This genre is not allowed in this group. Allowed genres are: ' + ', '.join(config.allowed_genres)
# Disable bumps if needed
if not config.allow_bumps and db.has_ever_been_posted(resource_type, resource.id):
logging.info('Bumping is disabled and this resource is present in the database.')
return 'Bumping is not allowed in this group.'
# Enforce minimum bump interval
last_reposted = db.last_repost_time(resource_type, resource.id)
if last_reposted is not None and last_reposted > int(time()) - config.min_bump_interval:
logging.info('This %s was posted %d seconds ago, but minimum bump interval is %d.', resource_type, int(time()) - last_reposted, config.min_bump_interval)
return 'This {} is posted to the group too frequently. Try again later.'.format(resource_type)
# Enforce max posts
last_post_count = db.user_last_posts_count(comment.user_id, config.post_limit_interval)
if last_post_count >= config.post_limit:
logging.info('The user has already made %d reposts.', last_post_count)
return 'You have already made {} posts.'.format(config.post_limit)
# Execute the command
if is_reposted:
logging.info('Bumping:')
group_delete(comment.user_id, resource_type, resource.id)
group_repost(comment.user_id, resource_type, resource.id)
else:
group_repost(comment.user_id, resource_type, resource.id)
request_description_update()
elif action == 'delete':
if is_reposted:
group_delete(comment.user_id, resource_type, resource.id)
request_description_update()
else:
logging.info('Resource already deleted')
else:
assert False, 'Unknown action: ' + repr(action)
def resolve_resource(url):
"""Return the resource object downloaded from url, or None, if not found."""
try:
resource = soundcloud.get('/resolve', url=url)
except HTTPError as e:
if e.response.status_code == 404:
return None
else:
raise
return resource
def check_repost_exists(type, id):
"""Return true if the respost exists, according to soundcloud.
Also update the database if a repost is already deleted
on soundcloud, but is not marked as deleted in the db."""
try:
soundcloud.get('/e1/me/{}_reposts/{}'.format(type, id))
return True
except HTTPError as e:
if e.response.status_code == 404:
db.mark_as_deleted(type, id)
return False
else:
raise
def | group_repost | identifier_name |
|
main.py | # Init banlist
load_banlist()
# Init soundcloud client
init_api()
def init_api():
"""Authenticate with SoundCloud API.
Cache access token in the secrets file."""
global soundcloud
import json
SECRETS_VERSION = 1
# Load secrets file
if os.path.exists(config.token_cache):
with open(config.token_cache, 'r', encoding='utf-8') as f:
secrets = json.load(f)
else:
secrets = {}
# Try to reuse the cached access token
if secrets\
and secrets['version'] == SECRETS_VERSION\
and secrets['access_token_acquired_at'] + secrets['access_token_expires_in'] > time() - 5 * 60\
and secrets['username'] == config.username:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
access_token=secrets['access_token']
)
return
# Get a new access token
logging.info('Getting a new access token')
try:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
username=config.username,
password=config.password
)
except HTTPError as e:
if e.response.status_code == 401:
logging.critical('Incorrect API key, login or password. Please, edit config.py.')
sys.exit(1)
else:
raise
# Save the token
secrets = {
'version': SECRETS_VERSION,
'username': config.username,
'access_token': soundcloud.access_token,
'access_token_acquired_at': time(),
'access_token_expires_in': soundcloud.token.expires_in,
}
with open(config.token_cache, 'w', encoding='utf-8') as f:
secrets = json.dump(secrets, f, indent='\t', ensure_ascii=False)
def load_banlist():
"""Load the banlist."""
# create banlist if it doesn't exist
if not os.path.exists(config.banlistfile):
open(config.banlistfile, 'ab').close()
with open(config.banlistfile, 'r') as file:
for line in file:
line = line.strip()
if line == '' or line.startswith('//'):
continue # skip empty lines and comments
values = line.split(None, 2)
what = values[0]
if what not in ['user', 'track', 'playlist']:
logging.warning('Banlist error: unknown ban type: %s', what)
continue
try:
id = int(values[1])
except ValueError:
logging.warning('Banlist error: %d is not a %s id number', id, what)
continue
if len(values) > 2:
banlist[what][id] = values[2]
else:
banlist[what][id] = "No reason given."
def check_comments():
"""Download all comments and process them."""
# Get the id of the group track
try:
group_track = soundcloud.get('/me/tracks')[config.post_track_id]
except HTTPError as e:
if e.response.status_code == 404:
logging.critical('Cannot find a track with id %d. Please, fix post_track_id in config.py', config.post_track_id)
sys.exit(1)
else:
raise
# Get the comment list for the group track
comments = soundcloud.get('/tracks/%d/comments' % group_track.id)
if not comments:
logging.info('Nothing found...')
return
# Process each comment and delete it
for comment in reversed(comments):
logging.info('Processing a comment by user %d (%s): %s', comment.user_id, comment.user['username'], comment.body)
response = None
# Try to process the comment
try:
response = process_comment(comment)
except HTTPError as e:
if e.response.status_code == 429:
logging.exception('Failed to repost track: too many requests:')
return
elif e.response.status_code // 100 == 4:
logging.exception('Failed to process comment due to a client request error:')
else:
raise
except Exception as e: # Program crash
logging.exception('Failed to process comment:')
else:
if response:
logging.info('The comment would have this response: %s', response)
else:
logging.info('Comment processed successfully')
# Delete the processed comment
try:
soundcloud.delete('/tracks/' + str(group_track.id) + '/comments/' + str(comment.id))
except HTTPError as e:
if e.response.status_code == 404:
logging.warning('Comment already deleted')
else:
raise
if config.use_advanced_description and should_update_description:
update_description()
def process_comment(comment):
"""Process a single comment."""
if not comment.body:
logging.info('Empty URL detected.')
return 'Your comment is empty.'
if comment.user_id in banlist['user']:
logging.info('Banned user id: %d', comment.user_id)
return 'You are banned from this group.'
url = comment.body
action = 'repost'
if url.startswith('!'):
action = 'delete'
url = url[1:]
# Resolve the resource to repost
resource = resolve_resource(url)
if resource:
logging.info('Resolved: %s %d', resource.kind, resource.id)
if resource.kind == 'playlist' and not config.allow_playlists:
logging.info('Playlists are not allowed. Skipping.')
return 'Playlists are not allowed in this group.'
else:
logging.info('Not found')
if not resource or resource.kind not in ('track', 'playlist'):
if config.allow_playlists:
return 'The provided link does not lead to a track or playlist.'
else:
return 'The provided link does not lead to a track.'
resource_type = resource.kind
# Check for ownership
if not config.debug_mode and comment.user_id != resource.user_id:
logging.info('Not the author of the resource')
return 'You must be the author of the {} to post it in this group.'.format(resource_type)
# Is the resource banned?
if resource.id in banlist[resource_type]:
reason = banlist[resource_type][resource.id];
logging.info('This resource is banned: %s', reason)
return 'This track or playlist is banned from this group: ' + reason
# Repost/delete if needed
is_reposted = check_repost_exists(resource_type, resource.id)
if action == 'repost':
# Genre filter
if config.allowed_genres is not None:
genres_lowercase = [ genre.lower() for genre in config.allowed_genres ]
if resource.genre.lower() not in genres_lowercase:
logging.info('Genre not allowed: %s', resource.genre)
return 'This genre is not allowed in this group. Allowed genres are: ' + ', '.join(config.allowed_genres)
# Disable bumps if needed
if not config.allow_bumps and db.has_ever_been_posted(resource_type, resource.id):
logging.info('Bumping is disabled and this resource is present in the database.')
return 'Bumping is not allowed in this group.'
# Enforce minimum bump interval
last_reposted = db.last_repost_time(resource_type, resource.id)
if last_reposted is not None and last_reposted > int(time()) - config.min_bump_interval:
logging.info('This %s was posted %d seconds ago, but minimum bump interval is %d.', resource_type, int(time()) - last_reposted, config.min_bump_interval)
return 'This {} is posted to the group too frequently. Try again later.'.format(resource_type)
# Enforce max posts
last_post_count = db.user_last_posts_count(comment.user_id, config.post_limit_interval)
if last_post_count >= config.post_limit:
logging.info('The user has already made %d reposts.', last_post_count)
return 'You have already made {} posts.'.format(config.post_limit)
# Execute the command
if is_reposted:
logging.info('Bumping:')
group_delete(comment.user_id, resource_type, resource.id)
group_repost(comment.user_id, resource_type, resource.id)
else:
group_repost(comment.user_id, resource_type, | global db
global config
# Init log
logging.basicConfig(stream=sys.stdout, level=logging.INFO, datefmt='[%Y-%m-%d %H:%M:%S]', format='%(asctime)s %(levelname)s %(message)s')
logging.getLogger("requests").setLevel(logging.WARNING)
logging.getLogger("urllib3").setLevel(logging.WARNING)
# Init config
if len(sys.argv) > 1:
config = imp.load_source('scgb_config', sys.argv[1])
elif os.path.exists('config.py'):
config = imp.load_source('scgb_config', os.path.join(os.getcwd(), 'config.py'))
else:
logging.critical('Please, rename config.py.template to config.py and edit it.\nOr specify a config to load on the command line: py scgb.py <config file>')
sys.exit(1)
# Init database
db = Database(config.stats_database)
| identifier_body |
|
main.py | logging.critical('Please, rename config.py.template to config.py and edit it.\nOr specify a config to load on the command line: py scgb.py <config file>')
sys.exit(1)
# Init database
db = Database(config.stats_database)
# Init banlist
load_banlist()
# Init soundcloud client
init_api()
def init_api():
"""Authenticate with SoundCloud API.
Cache access token in the secrets file."""
global soundcloud
import json
SECRETS_VERSION = 1
# Load secrets file
if os.path.exists(config.token_cache):
with open(config.token_cache, 'r', encoding='utf-8') as f:
secrets = json.load(f)
else:
secrets = {}
# Try to reuse the cached access token
if secrets\
and secrets['version'] == SECRETS_VERSION\
and secrets['access_token_acquired_at'] + secrets['access_token_expires_in'] > time() - 5 * 60\
and secrets['username'] == config.username:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
access_token=secrets['access_token']
)
return
# Get a new access token
logging.info('Getting a new access token')
try:
soundcloud = Soundcloud(
client_id=config.client_id,
client_secret=config.client_secret,
username=config.username,
password=config.password
)
except HTTPError as e:
if e.response.status_code == 401:
logging.critical('Incorrect API key, login or password. Please, edit config.py.')
sys.exit(1)
else:
raise
# Save the token
secrets = {
'version': SECRETS_VERSION,
'username': config.username,
'access_token': soundcloud.access_token,
'access_token_acquired_at': time(),
'access_token_expires_in': soundcloud.token.expires_in,
}
with open(config.token_cache, 'w', encoding='utf-8') as f:
secrets = json.dump(secrets, f, indent='\t', ensure_ascii=False)
def load_banlist():
"""Load the banlist."""
# create banlist if it doesn't exist
if not os.path.exists(config.banlistfile):
open(config.banlistfile, 'ab').close()
with open(config.banlistfile, 'r') as file:
for line in file:
line = line.strip()
if line == '' or line.startswith('//'):
continue # skip empty lines and comments
values = line.split(None, 2)
what = values[0]
if what not in ['user', 'track', 'playlist']:
logging.warning('Banlist error: unknown ban type: %s', what)
continue
try:
id = int(values[1])
except ValueError:
logging.warning('Banlist error: %d is not a %s id number', id, what)
continue
if len(values) > 2:
banlist[what][id] = values[2]
else:
banlist[what][id] = "No reason given."
def check_comments():
"""Download all comments and process them."""
# Get the id of the group track
try:
group_track = soundcloud.get('/me/tracks')[config.post_track_id]
except HTTPError as e:
if e.response.status_code == 404:
logging.critical('Cannot find a track with id %d. Please, fix post_track_id in config.py', config.post_track_id)
sys.exit(1)
else:
raise
# Get the comment list for the group track
comments = soundcloud.get('/tracks/%d/comments' % group_track.id)
if not comments:
logging.info('Nothing found...')
return
# Process each comment and delete it
for comment in reversed(comments):
logging.info('Processing a comment by user %d (%s): %s', comment.user_id, comment.user['username'], comment.body)
response = None
# Try to process the comment
try:
response = process_comment(comment)
except HTTPError as e:
if e.response.status_code == 429:
logging.exception('Failed to repost track: too many requests:')
return
elif e.response.status_code // 100 == 4:
logging.exception('Failed to process comment due to a client request error:')
else:
raise
except Exception as e: # Program crash
logging.exception('Failed to process comment:')
else:
if response:
logging.info('The comment would have this response: %s', response)
else:
logging.info('Comment processed successfully')
# Delete the processed comment
try:
soundcloud.delete('/tracks/' + str(group_track.id) + '/comments/' + str(comment.id))
except HTTPError as e:
if e.response.status_code == 404:
logging.warning('Comment already deleted')
else:
raise
if config.use_advanced_description and should_update_description:
|
def process_comment(comment):
"""Process a single comment."""
if not comment.body:
logging.info('Empty URL detected.')
return 'Your comment is empty.'
if comment.user_id in banlist['user']:
logging.info('Banned user id: %d', comment.user_id)
return 'You are banned from this group.'
url = comment.body
action = 'repost'
if url.startswith('!'):
action = 'delete'
url = url[1:]
# Resolve the resource to repost
resource = resolve_resource(url)
if resource:
logging.info('Resolved: %s %d', resource.kind, resource.id)
if resource.kind == 'playlist' and not config.allow_playlists:
logging.info('Playlists are not allowed. Skipping.')
return 'Playlists are not allowed in this group.'
else:
logging.info('Not found')
if not resource or resource.kind not in ('track', 'playlist'):
if config.allow_playlists:
return 'The provided link does not lead to a track or playlist.'
else:
return 'The provided link does not lead to a track.'
resource_type = resource.kind
# Check for ownership
if not config.debug_mode and comment.user_id != resource.user_id:
logging.info('Not the author of the resource')
return 'You must be the author of the {} to post it in this group.'.format(resource_type)
# Is the resource banned?
if resource.id in banlist[resource_type]:
reason = banlist[resource_type][resource.id];
logging.info('This resource is banned: %s', reason)
return 'This track or playlist is banned from this group: ' + reason
# Repost/delete if needed
is_reposted = check_repost_exists(resource_type, resource.id)
if action == 'repost':
# Genre filter
if config.allowed_genres is not None:
genres_lowercase = [ genre.lower() for genre in config.allowed_genres ]
if resource.genre.lower() not in genres_lowercase:
logging.info('Genre not allowed: %s', resource.genre)
return 'This genre is not allowed in this group. Allowed genres are: ' + ', '.join(config.allowed_genres)
# Disable bumps if needed
if not config.allow_bumps and db.has_ever_been_posted(resource_type, resource.id):
logging.info('Bumping is disabled and this resource is present in the database.')
return 'Bumping is not allowed in this group.'
# Enforce minimum bump interval
last_reposted = db.last_repost_time(resource_type, resource.id)
if last_reposted is not None and last_reposted > int(time()) - config.min_bump_interval:
logging.info('This %s was posted %d seconds ago, but minimum bump interval is %d.', resource_type, int(time()) - last_reposted, config.min_bump_interval)
return 'This {} is posted to the group too frequently. Try again later.'.format(resource_type)
# Enforce max posts
last_post_count = db.user_last_posts_count(comment.user_id, config.post_limit_interval)
if last_post_count >= config.post_limit:
logging.info('The user has already made %d reposts.', last_post_count)
return 'You have already made {} posts.'.format(config.post_limit)
# Execute the command
if is_reposted:
logging.info('Bumping:')
group_delete(comment.user_id, resource_type, resource.id)
group_repost(comment.user_id, resource_type, resource.id)
else:
group_repost(comment.user_id, resource_type, resource.id)
request_description_update()
elif action == 'delete':
if is_reposted:
group_delete(comment.user_id, resource_type, resource.id)
request_description_update()
else:
logging.info('Resource already deleted')
else:
assert False, 'Unknown action: ' + repr(action)
def resolve_resource(url):
"""Return the resource object downloaded from url, or None, if not found."""
try:
resource = soundcloud.get('/resolve', url=url)
except HTTPError as e:
if e.response.status_code == 404:
return None
else:
raise
return resource
def | update_description() | conditional_block |
sigma-form-upload-file.component.ts | el usuario */
object = Object;
/** Listado de errores personalizados permitidos por el componente */
@Input('errors') errors: [] = [];
/** Propiedad Placeholder asociado al campo del formulario */
@Input('placeholder') placeholder: string = '';
/** Cadena de texto con los tipos de archivos aceptados por el componente */
@Input('accept') accept: string = '*';
/** Bandera que indica si el componente admite multiples archivos */
@Input('multiple') multiple: boolean = false;
/** Cantidad maxima de archivos a cargar */
@Input('maxUpload') maxUpload: number = 0;
/** Cantidad mínima de archivos a cargar */
@Input('minUpload') minUpload: number = 0;
/** Bandera que permite identificar si se actualiza la vista del archivo al realizar el cargue */
@Input('autoUpdate') autoUpdate: boolean = true;
/** Bandera que indica si se presentará al usuario la vista previa del archivo */
@Input('showFile') showFile: boolean = false;
/** Tamaño máximo permitido para el cargue del archivo en MBs */
@Input('sizeFile') sizeFile: number = 10;
@Input('action') action: string = 'create';
status = '';
public filesProcessed = 0;
public filesToProcess = 0;
/** Entrada de tipo de componente que define el campo en el formulario */
@ViewChild('input') input: MatInput;
/** Entrada de tipo de componente que define el campo archivo en el formulario */
@ViewChild('inputFile') inputFile: ElementRef;
/** Definición del método que es llamado al momento de cambiar el dato del
* campo del formulario */
onChange = (_: any) => { }
/** Definición del método que es llamado al momento de realizar acción sobre el
* campo del formulario */
onTouch = () => { }
/**
* Método encargado de construir una instancia de componente
*
* @param ngControl Control de tipo de ng del componente del formulario
* @param _controlName Nombre del Control a usar en el formulario
* @param uploadFileService Servicio de carga de archivos
* @param cdRef Referencia a componente de observable para saber si ha cambiado el valor del componente
* @param snackBar Componente usado para abrir un recuadro modal
*/
constructor(
@Optional() @Self() ngControl: NgControl,
@Optional() private _controlName: FormControlName,
private uploadFileService: UploadFileService,
private cdRef: ChangeDetectorRef,
private snackBar: MatSnackBar,
) {
if (ngControl) {
ngControl.valueAccessor = this;
}
}
/** Método encargado de inicializar el componente */
ngOnInit() {
if (this._controlName) {
this.control = this._controlName.control;
}
this.clearInputHiden();
this.activeRequired(this.control);
this.acceptValid(this.control);
this.addTotalFiles(this.control);
this.addSizeFile(this.control);
this.addErrors();
this.setMensajeErrorTipoArchivo();
}
/** Método que permite saber cual es el archivo seleccionado */
selectFile() {
this.onTouch();
this.inputFile.nativeElement.click();
}
/**
* Método encargado de asignar la bandera de activo al contol
* indicado
*
* @param control Control al cual se le asignará la bandera de requerida
*/
activeRequired(control: FormControl) {
if (control.validator != undefined) {
const validator = control.validator({} as AbstractControl);
if (validator && validator.required) {
this.r | *
* Método que permite validar el tipo de archivo con los permitidos
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
acceptValid(control: FormControl) {
if (this.accept) {
let validate = this.setValidateFile(control.validator, InputFileAcceptsValidator(this.accept));
control.setValidators(validate);
}
}
/**
* Método encargado de adicionar los errores identificados
* en el validator a la sección de errores del campo del formulario
*/
addErrors() {
if (this.errors.length > 0) {
this.errors.map(item => {
this.basicErrors.push(item);
});
}
}
validateShowAttachFile(): Boolean {
if (this.control.disabled) {
return false;
}
if (this.maxUpload === 0 ) {
return true;
}
if ( this.files && ( this.maxUpload > this.files.length) ) {
return true;
} else {
return false;
}
}
/**
* Método encargado de adicionar el total de archivos al componente indicado
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addTotalFiles(control: FormControl) {
let total = this.files ? this.files.length : 0;
if (this.maxUpload > 0) {
let validate = this.setValidateFile(control.validator, InputFileMaxValidator(this.maxUpload, total));
control.setValidators(validate);
}
if (this.minUpload > 0) {
if (this.action === 'edit') {
total = 0;
}
let validate = this.setValidateFile(control.validator, InputFileMinValidator(this.minUpload, total));
control.setValidators(validate);
}
}
resetForm() {
this.action = 'edit';
this.ngOnInit();
}
/**
* Método encargado de adicionar el tamaño de archivo al control indicado
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addSizeFile(control) {
let validate = this.setValidateFile(control.validator, InputFileSize(this.sizeFile));
control.setValidators(validate);
}
/**
* Método encargado de realizar la validación del archivo cargado por el usuario
* @param existeValidate Indica si el archivo ya existe o es nuevo
* @param validate Indica si el archivo es de tipo válido
*/
setValidateFile(existeValidate, validate) {
if (existeValidate) {
return [existeValidate, validate];
} else {
return [validate];
}
}
/**
* Método que permite saber si el control al cual se le asigna el archivo
* es válido o no
*/
validControl(): boolean {
if (this.control.disabled) {
return false;
}
if (this.control.errors) {
if (Object.keys(this.control.errors).length > 0) {
return false;
}
}
if (!this.autoUpdate) {
return false;
}
return true;
}
/**
* Método encargado de adicionar los archivos cargados por el cliente al
* listado de archivos del modelo
*
* @param event Evento con los archivos cargados por el usuario
*/
agregarFiles(event) {
this.onTouch();
this.status = 'adding';
this.filesProcessed = 0;
this.filesToProcess = event.target.files.length;
this.control.setValue(event.target.files);
if (!this.validControl() && this.minUpload === 0) {
return;
}
this.files = [];
for (let file in event.target.files) {
if (typeof event.target.files[file] == 'object') {
this.files.push(event.target.files[file]);
this.upload(file, this.files[file]);
}
}
}
setFiles(files: any) {
this.files = files;
this.response();
this.status = 'rewrite';
this.detectChange();
this.clearInputHiden();
}
resetFormConditions() {
this.onTouch();
this.response();
this.status = 'reseting';
this.detectChange();
this.action = 'edit';
this.ngOnInit();
}
/**
* Método que permite la asignación de los errores de tipos de archivo
* a la sección de errores del formulario
*/
setMensajeErrorTipoArchivo() {
this.errorTipoArchivos = this.constants.typeFiles;
if (this.accept) {
let formatos = [] ;
const tipos = this.accept.split(',');
if (tipos) {
tipos.forEach(item => {
item = item.trim();
const index = this.constants.formatoArchivos.findIndex(formato => formato.mimeType.toLowerCase() === item.toLowerCase());
if (index > -1) {
if (formatos.findIndex(f => f === this.constants.formatoArchivos[index].nombreTipoArchivo) === -1) {
formatos.push(this.constants.formatoArchivos[index].nombreTipoArchivo);
}
}
});
}
if ( formatos.length > 0) {
let posicion = 0;
formatos.forEach(formato => {
posicion++;
if (formatos.length === posicion) {
this.errorTipoArchivos += formato + '. ';
} else {
this.errorTipoArchivos += formato + ', ';
}
});
}
}
}
/**
* Método encargado de actualizar el modelo de archivos con los archivos
* ingresados por el usuario
*
* | equired = true;
}
}
}
/* | conditional_block |
sigma-form-upload-file.component.ts | izados por el usuario */
object = Object;
/** Listado de errores personalizados permitidos por el componente */
@Input('errors') errors: [] = [];
/** Propiedad Placeholder asociado al campo del formulario */
@Input('placeholder') placeholder: string = '';
/** Cadena de texto con los tipos de archivos aceptados por el componente */
@Input('accept') accept: string = '*';
/** Bandera que indica si el componente admite multiples archivos */
@Input('multiple') multiple: boolean = false;
/** Cantidad maxima de archivos a cargar */
@Input('maxUpload') maxUpload: number = 0;
/** Cantidad mínima de archivos a cargar */
@Input('minUpload') minUpload: number = 0;
/** Bandera que permite identificar si se actualiza la vista del archivo al realizar el cargue */
@Input('autoUpdate') autoUpdate: boolean = true;
/** Bandera que indica si se presentará al usuario la vista previa del archivo */
@Input('showFile') showFile: boolean = false;
/** Tamaño máximo permitido para el cargue del archivo en MBs */
@Input('sizeFile') sizeFile: number = 10;
@Input('action') action: string = 'create';
status = '';
public filesProcessed = 0;
public filesToProcess = 0;
/** Entrada de tipo de componente que define el campo en el formulario */
@ViewChild('input') input: MatInput;
/** Entrada de tipo de componente que define el campo archivo en el formulario */
@ViewChild('inputFile') inputFile: ElementRef;
/** Definición del método que es llamado al momento de cambiar el dato del
* campo del formulario */
onChange = (_: any) => { }
/** Definición del método que es llamado al momento de realizar acción sobre el
* campo del formulario */
onTouch = () => { }
/**
* Método encargado de construir una instancia de componente
*
* @param ngControl Control de tipo de ng del componente del formulario
* @param _controlName Nombre del Control a usar en el formulario
* @param uploadFileService Servicio de carga de archivos
* @param cdRef Referencia a componente de observable para saber si ha cambiado el valor del componente
* @param snackBar Componente usado para abrir un recuadro modal
*/
constructor(
@Optional() @Self() ngControl: NgControl,
@Optional() private _controlName: FormControlName,
private uploadFileService: UploadFileService,
private cdRef: ChangeDetectorRef,
private snackBar: MatSnackBar,
) {
if (ngControl) {
ngControl.valueAccessor = this;
}
}
/** Método encargado de inicializar el componente */
ngOnInit() {
if (this._controlName) {
this.control = this._controlName.control;
}
this.clearInputHiden();
this.activeRequired(this.control);
this.acceptValid(this.control);
this.addTotalFiles(this.control);
this.addSizeFile(this.control);
this.addErrors();
this.setMensajeErrorTipoArchivo();
}
/** Método que permite saber cual es el archivo seleccionado */
selectFile() {
this.onTouch();
this.inputFile.nativeElement.click();
}
/**
* Método encargado de asignar la bandera de activo al contol
* indicado
*
* @param control Control al cual se le asignará la bandera de requerida
*/
activeRequired(control: FormControl) {
if (control.validator != undefined) {
const validator = control.validator({} as AbstractControl);
if (validator && validator.required) {
this.required = true;
}
}
}
/**
* Método que permite validar el tipo de archivo con los permitidos
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
acceptValid(control: FormControl) {
if (this.accept) {
let validate = this.setValidateFile(control.validator, InputFileAcceptsValidator(this.accept));
control.setValidators(validate);
}
}
/**
* Método encargado de adicionar los errores identificados
* en el validator a la sección de errores del campo del formulario | addErrors() {
if (this.errors.length > 0) {
this.errors.map(item => {
this.basicErrors.push(item);
});
}
}
validateShowAttachFile(): Boolean {
if (this.control.disabled) {
return false;
}
if (this.maxUpload === 0 ) {
return true;
}
if ( this.files && ( this.maxUpload > this.files.length) ) {
return true;
} else {
return false;
}
}
/**
* Método encargado de adicionar el total de archivos al componente indicado
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addTotalFiles(control: FormControl) {
let total = this.files ? this.files.length : 0;
if (this.maxUpload > 0) {
let validate = this.setValidateFile(control.validator, InputFileMaxValidator(this.maxUpload, total));
control.setValidators(validate);
}
if (this.minUpload > 0) {
if (this.action === 'edit') {
total = 0;
}
let validate = this.setValidateFile(control.validator, InputFileMinValidator(this.minUpload, total));
control.setValidators(validate);
}
}
resetForm() {
this.action = 'edit';
this.ngOnInit();
}
/**
* Método encargado de adicionar el tamaño de archivo al control indicado
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addSizeFile(control) {
let validate = this.setValidateFile(control.validator, InputFileSize(this.sizeFile));
control.setValidators(validate);
}
/**
* Método encargado de realizar la validación del archivo cargado por el usuario
* @param existeValidate Indica si el archivo ya existe o es nuevo
* @param validate Indica si el archivo es de tipo válido
*/
setValidateFile(existeValidate, validate) {
if (existeValidate) {
return [existeValidate, validate];
} else {
return [validate];
}
}
/**
* Método que permite saber si el control al cual se le asigna el archivo
* es válido o no
*/
validControl(): boolean {
if (this.control.disabled) {
return false;
}
if (this.control.errors) {
if (Object.keys(this.control.errors).length > 0) {
return false;
}
}
if (!this.autoUpdate) {
return false;
}
return true;
}
/**
* Método encargado de adicionar los archivos cargados por el cliente al
* listado de archivos del modelo
*
* @param event Evento con los archivos cargados por el usuario
*/
agregarFiles(event) {
this.onTouch();
this.status = 'adding';
this.filesProcessed = 0;
this.filesToProcess = event.target.files.length;
this.control.setValue(event.target.files);
if (!this.validControl() && this.minUpload === 0) {
return;
}
this.files = [];
for (let file in event.target.files) {
if (typeof event.target.files[file] == 'object') {
this.files.push(event.target.files[file]);
this.upload(file, this.files[file]);
}
}
}
setFiles(files: any) {
this.files = files;
this.response();
this.status = 'rewrite';
this.detectChange();
this.clearInputHiden();
}
resetFormConditions() {
this.onTouch();
this.response();
this.status = 'reseting';
this.detectChange();
this.action = 'edit';
this.ngOnInit();
}
/**
* Método que permite la asignación de los errores de tipos de archivo
* a la sección de errores del formulario
*/
setMensajeErrorTipoArchivo() {
this.errorTipoArchivos = this.constants.typeFiles;
if (this.accept) {
let formatos = [] ;
const tipos = this.accept.split(',');
if (tipos) {
tipos.forEach(item => {
item = item.trim();
const index = this.constants.formatoArchivos.findIndex(formato => formato.mimeType.toLowerCase() === item.toLowerCase());
if (index > -1) {
if (formatos.findIndex(f => f === this.constants.formatoArchivos[index].nombreTipoArchivo) === -1) {
formatos.push(this.constants.formatoArchivos[index].nombreTipoArchivo);
}
}
});
}
if ( formatos.length > 0) {
let posicion = 0;
formatos.forEach(formato => {
posicion++;
if (formatos.length === posicion) {
this.errorTipoArchivos += formato + '. ';
} else {
this.errorTipoArchivos += formato + ', ';
}
});
}
}
}
/**
* Método encargado de actualizar el modelo de archivos con los archivos
* ingresados por el usuario
*
* @param | */ | random_line_split |
sigma-form-upload-file.component.ts | por el usuario */
object = Object;
/** Listado de errores personalizados permitidos por el componente */
@Input('errors') errors: [] = [];
/** Propiedad Placeholder asociado al campo del formulario */
@Input('placeholder') placeholder: string = '';
/** Cadena de texto con los tipos de archivos aceptados por el componente */
@Input('accept') accept: string = '*';
/** Bandera que indica si el componente admite multiples archivos */
@Input('multiple') multiple: boolean = false;
/** Cantidad maxima de archivos a cargar */
@Input('maxUpload') maxUpload: number = 0;
/** Cantidad mínima de archivos a cargar */
@Input('minUpload') minUpload: number = 0;
/** Bandera que permite identificar si se actualiza la vista del archivo al realizar el cargue */
@Input('autoUpdate') autoUpdate: boolean = true;
/** Bandera que indica si se presentará al usuario la vista previa del archivo */
@Input('showFile') showFile: boolean = false;
/** Tamaño máximo permitido para el cargue del archivo en MBs */
@Input('sizeFile') sizeFile: number = 10;
@Input('action') action: string = 'create';
status = '';
public filesProcessed = 0;
public filesToProcess = 0;
/** Entrada de tipo de componente que define el campo en el formulario */
@ViewChild('input') input: MatInput;
/** Entrada de tipo de componente que define el campo archivo en el formulario */
@ViewChild('inputFile') inputFile: ElementRef;
/** Definición del método que es llamado al momento de cambiar el dato del
* campo del formulario */
onChange = (_: any) => { }
/** Definición del método que es llamado al momento de realizar acción sobre el
* campo del formulario */
onTouch = () => { }
/**
* Método encargado de construir una instancia de componente
*
* @param ngControl Control de tipo de ng del componente del formulario
* @param _controlName Nombre del Control a usar en el formulario
* @param uploadFileService Servicio de carga de archivos
* @param cdRef Referencia a componente de observable para saber si ha cambiado el valor del componente
* @param snackBar Componente usado para abrir un recuadro modal
*/
constructor(
@Optional() @Self() ngControl: NgControl,
@Optional() private _controlName: FormControlName,
private uploadFileService: UploadFileService,
private cdRef: ChangeDetectorRef,
private snackBar: MatSnackBar,
) {
if (ngControl) {
ngControl.valueAccessor = this;
}
}
/** Método encargado de inicializar el componente */
ngOnInit() {
if (this._controlName) {
this.control = this._controlName.control;
}
this.clearInputHiden();
this.activeRequired(this.control);
this.acceptValid(this.control);
this.addTotalFiles(this.control);
this.addSizeFile(this.control);
this.addErrors();
this.setMensajeErrorTipoArchivo();
}
/** Método que permite saber cual es el archivo seleccionado */
selectFile() {
this.onTouch();
this.inputFile.nativeElement.click();
}
/**
* Método encargado de asignar la bandera de activo al contol
* indicado
*
* @param control Control al cual se le asignará la bandera de requerida
*/
activeRequired(control: FormControl) {
if (control.validator != undefined) {
const validator = control.validator({} as AbstractControl);
if (validator && validator.required) {
this.required = true;
}
}
}
/**
* Método que permite validar el tipo de archivo con los permitidos
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
acceptValid(control: FormControl) {
if (this.accept) {
let validate = this.setValidateFile(control.validator, InputFileAcceptsValidator(this.accept));
control.setValidators(validate);
}
}
/**
* Método encargado de adicionar los errores identificados
* en el validator a la sección de errores del campo del formulario
*/
addErrors() {
if (this.errors.length > 0) {
this.errors.map(item => {
this.basicErrors.push(item);
});
}
}
validateShowAttachFile(): Boolean {
if (this.control.disabled) {
return false;
}
if (this.maxUpload === 0 ) {
return true;
}
if ( this.files && ( this.maxUpload > this.files.length) ) {
return true;
} else {
return false;
}
}
/**
* Método encargado de adicionar el total de archivos al componente indicado
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addTotalFiles(control: FormControl) {
let total = this.files ? this.files.length : 0;
if (this.maxUpload > 0) {
let validate = this.setValidateFile(control.validator, InputFileMaxValidator(this.maxUpload, total));
control.setValidators(validate);
}
if (this.minUpload > 0) {
if (this.action === 'edit') {
total = 0;
}
let validate = this.setValidateFile(control.validator, InputFileMinValidator(this.minUpload, total));
control.setValidators(validate);
}
}
resetForm() {
this.action = 'edit';
this.ngOnInit();
}
/**
* Método encargado de adicionar el tamaño de archivo al control indicado
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addSizeFile(control) {
let validate = this.setValidateFile(control.validator, InputFileSize(this.sizeFile));
control.setValidators(validate);
}
/**
* Método encargado de realizar la validación del archivo cargado por el usuario
* @param existeValidate Indica si el archivo ya existe o es nuevo
* @param validate Indica si el archivo es de tipo válido
*/
setValidateFile(existeValidate, validate) {
if (existeValidate) {
return [existeValidate, validate];
} else {
return [validate];
}
}
/**
* Método que permite saber si el control al cual se le asigna el archivo
* es válido o no
*/
validControl(): boolean {
if | l.disabled) {
return false;
}
if (this.control.errors) {
if (Object.keys(this.control.errors).length > 0) {
return false;
}
}
if (!this.autoUpdate) {
return false;
}
return true;
}
/**
* Método encargado de adicionar los archivos cargados por el cliente al
* listado de archivos del modelo
*
* @param event Evento con los archivos cargados por el usuario
*/
agregarFiles(event) {
this.onTouch();
this.status = 'adding';
this.filesProcessed = 0;
this.filesToProcess = event.target.files.length;
this.control.setValue(event.target.files);
if (!this.validControl() && this.minUpload === 0) {
return;
}
this.files = [];
for (let file in event.target.files) {
if (typeof event.target.files[file] == 'object') {
this.files.push(event.target.files[file]);
this.upload(file, this.files[file]);
}
}
}
setFiles(files: any) {
this.files = files;
this.response();
this.status = 'rewrite';
this.detectChange();
this.clearInputHiden();
}
resetFormConditions() {
this.onTouch();
this.response();
this.status = 'reseting';
this.detectChange();
this.action = 'edit';
this.ngOnInit();
}
/**
* Método que permite la asignación de los errores de tipos de archivo
* a la sección de errores del formulario
*/
setMensajeErrorTipoArchivo() {
this.errorTipoArchivos = this.constants.typeFiles;
if (this.accept) {
let formatos = [] ;
const tipos = this.accept.split(',');
if (tipos) {
tipos.forEach(item => {
item = item.trim();
const index = this.constants.formatoArchivos.findIndex(formato => formato.mimeType.toLowerCase() === item.toLowerCase());
if (index > -1) {
if (formatos.findIndex(f => f === this.constants.formatoArchivos[index].nombreTipoArchivo) === -1) {
formatos.push(this.constants.formatoArchivos[index].nombreTipoArchivo);
}
}
});
}
if ( formatos.length > 0) {
let posicion = 0;
formatos.forEach(formato => {
posicion++;
if (formatos.length === posicion) {
this.errorTipoArchivos += formato + '. ';
} else {
this.errorTipoArchivos += formato + ', ';
}
});
}
}
}
/**
* Método encargado de actualizar el modelo de archivos con los archivos
* ingresados por el usuario
*
* | (this.contro | identifier_name |
sigma-form-upload-file.component.ts | por el usuario */
object = Object;
/** Listado de errores personalizados permitidos por el componente */
@Input('errors') errors: [] = [];
/** Propiedad Placeholder asociado al campo del formulario */
@Input('placeholder') placeholder: string = '';
/** Cadena de texto con los tipos de archivos aceptados por el componente */
@Input('accept') accept: string = '*';
/** Bandera que indica si el componente admite multiples archivos */
@Input('multiple') multiple: boolean = false;
/** Cantidad maxima de archivos a cargar */
@Input('maxUpload') maxUpload: number = 0;
/** Cantidad mínima de archivos a cargar */
@Input('minUpload') minUpload: number = 0;
/** Bandera que permite identificar si se actualiza la vista del archivo al realizar el cargue */
@Input('autoUpdate') autoUpdate: boolean = true;
/** Bandera que indica si se presentará al usuario la vista previa del archivo */
@Input('showFile') showFile: boolean = false;
/** Tamaño máximo permitido para el cargue del archivo en MBs */
@Input('sizeFile') sizeFile: number = 10;
@Input('action') action: string = 'create';
status = '';
public filesProcessed = 0;
public filesToProcess = 0;
/** Entrada de tipo de componente que define el campo en el formulario */
@ViewChild('input') input: MatInput;
/** Entrada de tipo de componente que define el campo archivo en el formulario */
@ViewChild('inputFile') inputFile: ElementRef;
/** Definición del método que es llamado al momento de cambiar el dato del
* campo del formulario */
onChange = (_: any) => { }
/** Definición del método que es llamado al momento de realizar acción sobre el
* campo del formulario */
onTouch = () => { }
/**
* Método encargado de construir una instancia de componente
*
* @param ngControl Control de tipo de ng del componente del formulario
* @param _controlName Nombre del Control a usar en el formulario
* @param uploadFileService Servicio de carga de archivos
* @param cdRef Referencia a componente de observable para saber si ha cambiado el valor del componente
* @param snackBar Componente usado para abrir un recuadro modal
*/
constructor(
@Optional() @Self() ngControl: NgControl,
@Optional() private _controlName: FormControlName,
private uploadFileService: UploadFileService,
private cdRef: ChangeDetectorRef,
private snackBar: MatSnackBar,
) {
if (ngControl) {
ngControl.valueAccessor = this;
}
}
/** Método encargado de inicializar el componente */
ngOnInit() {
if (this._controlName) {
this.control = this._controlName.control;
}
this.clearInputHiden();
this.activeRequired(this.control);
this.acceptValid(this.control);
this.addTotalFiles(this.control);
this.addSizeFile(this.control);
this.addErrors();
this.setMensajeErrorTipoArchivo();
}
/** Método que permite saber cual es el archivo seleccionado */
selectFile() {
this.onTouch();
this.inputFile.nativeElement.click();
}
/**
* Método encargado de asignar la bandera de activo al contol
* indicado
*
* @param control Control al cual se le asignará la bandera de requerida
*/
activeRequired(control: FormControl) {
if (control.validator != undefined) {
const validator = control.validator({} as AbstractControl);
if (validator && validator.required) {
this.required = true;
}
}
}
/**
* Método que permite validar el tipo de archivo con los permitidos
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
acceptValid(control: FormControl) {
if (this.accept) {
let validate = this.setValidateFile(control.validator, InputFileAcceptsValidator(this.accept));
control.setValidators(validate);
}
}
/**
* Método encargado de adicionar los errores identificados
* en el validator a la sección de errores del campo del formulario
*/
addErrors() {
if (this.errors.length > 0) {
this.errors.map(item => {
this.basicErrors.push(item);
});
}
}
validateShowAttachFile(): Boolean {
if (this.control.disabled) {
return false;
}
if (this.maxUpload === 0 ) {
return true;
}
if ( this.files && ( this.maxUpload > this.files.length) ) {
return true;
} else {
return false;
}
}
/**
* Método encargado de adicionar el total de archivos al componente indicado
*
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addTotalFiles(control: FormControl) {
let total = this.files ? this.files.length : 0;
if (this.maxUpload > 0) {
let validate = this.setValidateFile(control.validator, InputFileMaxValidator(this.maxUpload, total));
control.setValidators(validate);
}
if (this.minUpload > 0) {
if (this.action === 'edit') {
total = 0;
}
let validate = this.setValidateFile(control.validator, InputFileMinValidator(this.minUpload, total));
control.setValidators(validate);
}
}
resetForm() {
this.action = 'edit';
this.ngOnInit();
}
/**
* Método encargado de adicionar el tamaño de archivo al control indicado
* @param control Control de formulario al cual se le asociará el mensaje de falla o éxito
*/
addSizeFile(control) {
let validate = this.setValidateFile(control.validator, InputFileSize(this.sizeFile));
control.setValidators(validate);
}
/**
* Método encargado de realizar la validación del archivo cargado por el usuario
* @param existeValidate Indica si el archivo ya existe o es nuevo
* @param validate Indica si el archivo es de tipo válido
*/
setValidateFile(existeValidate, validate) {
if (existeValidate) {
return [existeValidate, validate];
} else {
return [validate];
}
}
/**
* Método que permite saber si el control al cual se le asigna el archivo
* es válido o no
*/
validControl(): boolean {
if (this.control.disabled) {
return false;
}
if (this.control.errors) {
if (Object.keys(this.control.errors).length > 0) {
return false;
}
}
if (!this.autoUpdate) {
return false;
}
return true;
}
/**
* Método encargado de adicionar los archivos cargados por el cliente al
* listado de archivos del modelo
*
* @param event Evento con los archivos cargados por el usuario
*/
agregarFiles(event) {
this.onTouch();
this.status = 'adding';
this.filesProcessed = 0;
this.filesToProcess = event.target.files.length;
this.control.setValue(event.target.files);
if (!this.validControl() && this.minUpload === 0) {
return;
}
this.files = [];
for (let file in event.target.files) {
if (typeof event.target.files[file] == 'object') {
this.files.push(event.target.files[file]);
this.upload(file, this.files[file]);
}
}
}
setFiles(files: any) {
this.files = files;
this | is.onTouch();
this.response();
this.status = 'reseting';
this.detectChange();
this.action = 'edit';
this.ngOnInit();
}
/**
* Método que permite la asignación de los errores de tipos de archivo
* a la sección de errores del formulario
*/
setMensajeErrorTipoArchivo() {
this.errorTipoArchivos = this.constants.typeFiles;
if (this.accept) {
let formatos = [] ;
const tipos = this.accept.split(',');
if (tipos) {
tipos.forEach(item => {
item = item.trim();
const index = this.constants.formatoArchivos.findIndex(formato => formato.mimeType.toLowerCase() === item.toLowerCase());
if (index > -1) {
if (formatos.findIndex(f => f === this.constants.formatoArchivos[index].nombreTipoArchivo) === -1) {
formatos.push(this.constants.formatoArchivos[index].nombreTipoArchivo);
}
}
});
}
if ( formatos.length > 0) {
let posicion = 0;
formatos.forEach(formato => {
posicion++;
if (formatos.length === posicion) {
this.errorTipoArchivos += formato + '. ';
} else {
this.errorTipoArchivos += formato + ', ';
}
});
}
}
}
/**
* Método encargado de actualizar el modelo de archivos con los archivos
* ingresados por el usuario
*
* @ | .response();
this.status = 'rewrite';
this.detectChange();
this.clearInputHiden();
}
resetFormConditions() {
th | identifier_body |
types.rs | macro_rules! retain_release {
($name:ident, $ffi_ref:ty, $retain_fn:tt, $drop_fn:tt) => {
impl Drop for $name {
fn drop(&mut self) {
unsafe { $drop_fn(self.0) };
}
}
impl Clone for $name {
fn clone(&self) -> $name {
let x = unsafe { $retain_fn(self.0) };
$name(x)
}
}
impl Deref for $name {
type Target = $ffi_ref;
fn deref(&self) -> &$ffi_ref {
&self.0
}
}
};
}
unsafe impl Send for GlobalContext {}
unsafe impl Sync for GlobalContext {}
unsafe impl Send for Context {}
unsafe impl Sync for Context {}
unsafe impl Send for String {}
unsafe impl Sync for String {}
unsafe impl Send for Object {}
unsafe impl Sync for Object {}
unsafe impl Send for ContextGroup {}
unsafe impl Sync for ContextGroup {}
unsafe impl Send for Value {}
unsafe impl Sync for Value {}
#[derive(Copy, Clone, Debug)]
pub struct Context(pub(crate) JSContextRef);
pub struct ContextGroup(pub(crate) JSContextGroupRef);
pub struct GlobalContext(pub(crate) JSGlobalContextRef);
pub struct Object(pub(crate) Context, pub(crate) JSObjectRef);
pub struct String(pub(crate) JSStringRef);
use std::fmt;
impl fmt::Debug for Object {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut s = f.debug_struct("Object");
unsafe {
let array = JSObjectCopyPropertyNames(*self.0, self.1);
let size = JSPropertyNameArrayGetCount(array);
for i in 0..size {
let js_ref = JSPropertyNameArrayGetNameAtIndex(array, i);
let prop_name = std::string::String::from(&String(js_ref));
let prop_value = Value::from(
self.0,
JSObjectGetPropertyAtIndex(*self.0, self.1, i as u32, null_mut()),
);
s.field(&prop_name, &format!("{:?}", prop_value));
}
}
s.finish()
}
}
impl fmt::Debug for Exception {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Exception")
.field("stack", &self.stack())
.field("message", &self.message())
.finish()
}
}
impl fmt::Display for Exception {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "Message: {}", &self.message())?;
writeln!(f, "Stack:")?;
write!(f, "{}", self.stack())
}
}
#[derive(Debug, Copy, Clone)]
pub enum ValueType {
Undefined,
Null,
Boolean,
Number,
String,
Object,
Symbol,
}
#[derive(Debug)]
pub struct Value(
pub(crate) JSValueRef,
pub(crate) ValueType,
pub(crate) Context,
);
pub trait ContextType {
unsafe fn as_ptr(&self) -> JSContextRef;
fn undefined(&self) -> Value {
let ptr = unsafe { self.as_ptr() };
let value = unsafe { JSValueMakeUndefined(ptr) };
Value(value, ValueType::Undefined, Context(ptr))
}
}
impl ContextType for GlobalContext {
unsafe fn as_ptr(&self) -> JSContextRef {
self.0
}
}
impl ContextType for Context {
unsafe fn as_ptr(&self) -> JSContextRef {
self.0
}
}
impl Deref for Context {
type Target = JSContextRef;
fn deref(&self) -> &JSContextRef {
&self.0
}
}
impl Deref for Object {
type Target = JSObjectRef;
fn deref(&self) -> &JSObjectRef {
&self.1
}
}
retain_release!(
ContextGroup,
JSContextGroupRef,
JSContextGroupRetain,
JSContextGroupRelease
);
retain_release!(
GlobalContext,
JSGlobalContextRef,
JSGlobalContextRetain,
JSGlobalContextRelease
);
retain_release!(String, JSStringRef, JSStringRetain, JSStringRelease);
impl ContextGroup {
pub fn new() -> ContextGroup {
let ptr = unsafe { JSContextGroupCreate() };
ContextGroup(ptr)
}
pub fn create_global_context(&self) -> GlobalContext {
let ptr = unsafe { JSGlobalContextCreateInGroup(self.0, null_mut()) };
GlobalContext(ptr)
}
}
pub struct Exception(Object);
impl Exception {
pub fn stack(&self) -> std::string::String {
let stack_val = self
.0
.get_property(&String::new("stack").unwrap())
.expect("no `stack` property found");
let stack_str = String::try_from(&stack_val).expect("no string property found for `stack`");
std::string::String::from(&stack_str)
}
pub fn message(&self) -> std::string::String {
let message_val = self
.0
.get_property(&String::new("message").unwrap())
.expect("no `message` property found");
let message_str =
String::try_from(&message_val).expect("no string property found for `message`");
std::string::String::from(&message_str)
}
}
impl GlobalContext {
pub fn global_object(&self) -> Object {
let ptr = unsafe { JSContextGetGlobalObject(self.0) };
Object(Context(self.0), ptr)
}
pub fn evaluate_script_sync(&self, script: &String) -> Result<Value, Exception> {
let mut exception = null();
let ret = unsafe {
JSEvaluateScript(self.0, **script, null_mut(), null_mut(), 0, &mut exception)
};
if exception == null_mut() {
Ok(Value::from(Context(self.0), ret))
} else {
let value = Value::from(Context(self.0), exception);
let obj = Object::try_from(&value).unwrap();
Err(Exception(obj))
}
}
pub async fn evaluate_script<'a>(&'a self, script: &'a String) -> Result<Value, Exception> {
self.evaluate_script_sync(script)
}
pub fn add_function(
&self,
name: &str,
callback: JsCallback,
) -> Result<(), Box<dyn std::error::Error>> {
let name = String::new(name).unwrap();
let obj = self.global_object();
let fn_obj = obj.make_function_with_callback(&name, callback);
obj.set_property(&name, Value::from(Context(self.0), *fn_obj));
Ok(())
}
}
type JsCallback =
fn(Context, /*thisObject*/ Object, /*arguments*/ Vec<Value>) -> Result<Value, String>;
extern "C" fn callback_trampoline(
ctx: JSContextRef,
function: JSObjectRef,
this_object: JSObjectRef,
argument_count: usize,
arguments: *const JSValueRef,
exception: *mut JSValueRef,
) -> JSValueRef {
let callback = unsafe {
std::mem::transmute::<*mut ::std::os::raw::c_void, JsCallback>(JSObjectGetPrivate(function))
};
let ctx = Context(ctx);
let args = unsafe {
std::slice::from_raw_parts(arguments, argument_count)
.into_iter()
.map(|v| Value::from(ctx, *v))
.collect::<Vec<_>>()
};
match callback(ctx, Object(ctx, this_object), args) {
Ok(v) => v.0,
Err(e) => unsafe {
*exception = e.to_js_value(&ctx);
JSValueMakeUndefined(ctx.0)
},
}
}
impl ValueType {
unsafe fn from(ctx: Context, value_ref: JSValueRef) -> ValueType {
let raw_ty = JSValueGetType(ctx.0, value_ref);
match raw_ty {
0 => ValueType::Undefined,
1 => ValueType::Null,
2 => ValueType::Boolean,
3 => ValueType::Number,
4 => ValueType::String,
5 => ValueType::Object,
6 => ValueType::Symbol,
_ => unreachable!(),
}
}
}
impl Value {
fn from(ctx: Context, value_ref: JSValueRef) -> Value {
Value(value_ref, unsafe { ValueType::from(ctx, value_ref) }, ctx)
}
pub fn to_string(&self) -> std::string::String {
match self.js_type() {
ValueType::String => {
let js_str = String::try_from(self).expect("string");
std::string::String::from(&js_str)
}
ValueType::Number => {
let n = f64::try_from(self).expect("f64");
format!("{}", n)
}
ValueType::Boolean => {
let v = bool::try_from(self).expect("bool");
format!("{}", v)
}
ValueType::Null => "null".into(),
ValueType::Undefined => "undefined".into(),
ValueType::Symbol => "Symbol(...)".into(),
ValueType::Object => {
let obj = Object::try_from(self).expect("object");
format!("{:?}", obj)
}
}
}
}
fn rust_function_def | use std::ffi::CString;
use std::ops::Deref;
use std::ptr::{null, null_mut};
| random_line_split |
|
types.rs | f(&self) -> &$ffi_ref {
&self.0
}
}
};
}
unsafe impl Send for GlobalContext {}
unsafe impl Sync for GlobalContext {}
unsafe impl Send for Context {}
unsafe impl Sync for Context {}
unsafe impl Send for String {}
unsafe impl Sync for String {}
unsafe impl Send for Object {}
unsafe impl Sync for Object {}
unsafe impl Send for ContextGroup {}
unsafe impl Sync for ContextGroup {}
unsafe impl Send for Value {}
unsafe impl Sync for Value {}
#[derive(Copy, Clone, Debug)]
pub struct Context(pub(crate) JSContextRef);
pub struct ContextGroup(pub(crate) JSContextGroupRef);
pub struct GlobalContext(pub(crate) JSGlobalContextRef);
pub struct Object(pub(crate) Context, pub(crate) JSObjectRef);
pub struct String(pub(crate) JSStringRef);
use std::fmt;
impl fmt::Debug for Object {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result |
}
impl fmt::Debug for Exception {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Exception")
.field("stack", &self.stack())
.field("message", &self.message())
.finish()
}
}
impl fmt::Display for Exception {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "Message: {}", &self.message())?;
writeln!(f, "Stack:")?;
write!(f, "{}", self.stack())
}
}
#[derive(Debug, Copy, Clone)]
pub enum ValueType {
Undefined,
Null,
Boolean,
Number,
String,
Object,
Symbol,
}
#[derive(Debug)]
pub struct Value(
pub(crate) JSValueRef,
pub(crate) ValueType,
pub(crate) Context,
);
pub trait ContextType {
unsafe fn as_ptr(&self) -> JSContextRef;
fn undefined(&self) -> Value {
let ptr = unsafe { self.as_ptr() };
let value = unsafe { JSValueMakeUndefined(ptr) };
Value(value, ValueType::Undefined, Context(ptr))
}
}
impl ContextType for GlobalContext {
unsafe fn as_ptr(&self) -> JSContextRef {
self.0
}
}
impl ContextType for Context {
unsafe fn as_ptr(&self) -> JSContextRef {
self.0
}
}
impl Deref for Context {
type Target = JSContextRef;
fn deref(&self) -> &JSContextRef {
&self.0
}
}
impl Deref for Object {
type Target = JSObjectRef;
fn deref(&self) -> &JSObjectRef {
&self.1
}
}
retain_release!(
ContextGroup,
JSContextGroupRef,
JSContextGroupRetain,
JSContextGroupRelease
);
retain_release!(
GlobalContext,
JSGlobalContextRef,
JSGlobalContextRetain,
JSGlobalContextRelease
);
retain_release!(String, JSStringRef, JSStringRetain, JSStringRelease);
impl ContextGroup {
pub fn new() -> ContextGroup {
let ptr = unsafe { JSContextGroupCreate() };
ContextGroup(ptr)
}
pub fn create_global_context(&self) -> GlobalContext {
let ptr = unsafe { JSGlobalContextCreateInGroup(self.0, null_mut()) };
GlobalContext(ptr)
}
}
pub struct Exception(Object);
impl Exception {
pub fn stack(&self) -> std::string::String {
let stack_val = self
.0
.get_property(&String::new("stack").unwrap())
.expect("no `stack` property found");
let stack_str = String::try_from(&stack_val).expect("no string property found for `stack`");
std::string::String::from(&stack_str)
}
pub fn message(&self) -> std::string::String {
let message_val = self
.0
.get_property(&String::new("message").unwrap())
.expect("no `message` property found");
let message_str =
String::try_from(&message_val).expect("no string property found for `message`");
std::string::String::from(&message_str)
}
}
impl GlobalContext {
pub fn global_object(&self) -> Object {
let ptr = unsafe { JSContextGetGlobalObject(self.0) };
Object(Context(self.0), ptr)
}
pub fn evaluate_script_sync(&self, script: &String) -> Result<Value, Exception> {
let mut exception = null();
let ret = unsafe {
JSEvaluateScript(self.0, **script, null_mut(), null_mut(), 0, &mut exception)
};
if exception == null_mut() {
Ok(Value::from(Context(self.0), ret))
} else {
let value = Value::from(Context(self.0), exception);
let obj = Object::try_from(&value).unwrap();
Err(Exception(obj))
}
}
pub async fn evaluate_script<'a>(&'a self, script: &'a String) -> Result<Value, Exception> {
self.evaluate_script_sync(script)
}
pub fn add_function(
&self,
name: &str,
callback: JsCallback,
) -> Result<(), Box<dyn std::error::Error>> {
let name = String::new(name).unwrap();
let obj = self.global_object();
let fn_obj = obj.make_function_with_callback(&name, callback);
obj.set_property(&name, Value::from(Context(self.0), *fn_obj));
Ok(())
}
}
type JsCallback =
fn(Context, /*thisObject*/ Object, /*arguments*/ Vec<Value>) -> Result<Value, String>;
extern "C" fn callback_trampoline(
ctx: JSContextRef,
function: JSObjectRef,
this_object: JSObjectRef,
argument_count: usize,
arguments: *const JSValueRef,
exception: *mut JSValueRef,
) -> JSValueRef {
let callback = unsafe {
std::mem::transmute::<*mut ::std::os::raw::c_void, JsCallback>(JSObjectGetPrivate(function))
};
let ctx = Context(ctx);
let args = unsafe {
std::slice::from_raw_parts(arguments, argument_count)
.into_iter()
.map(|v| Value::from(ctx, *v))
.collect::<Vec<_>>()
};
match callback(ctx, Object(ctx, this_object), args) {
Ok(v) => v.0,
Err(e) => unsafe {
*exception = e.to_js_value(&ctx);
JSValueMakeUndefined(ctx.0)
},
}
}
impl ValueType {
unsafe fn from(ctx: Context, value_ref: JSValueRef) -> ValueType {
let raw_ty = JSValueGetType(ctx.0, value_ref);
match raw_ty {
0 => ValueType::Undefined,
1 => ValueType::Null,
2 => ValueType::Boolean,
3 => ValueType::Number,
4 => ValueType::String,
5 => ValueType::Object,
6 => ValueType::Symbol,
_ => unreachable!(),
}
}
}
impl Value {
fn from(ctx: Context, value_ref: JSValueRef) -> Value {
Value(value_ref, unsafe { ValueType::from(ctx, value_ref) }, ctx)
}
pub fn to_string(&self) -> std::string::String {
match self.js_type() {
ValueType::String => {
let js_str = String::try_from(self).expect("string");
std::string::String::from(&js_str)
}
ValueType::Number => {
let n = f64::try_from(self).expect("f64");
format!("{}", n)
}
ValueType::Boolean => {
let v = bool::try_from(self).expect("bool");
format!("{}", v)
}
ValueType::Null => "null".into(),
ValueType::Undefined => "undefined".into(),
ValueType::Symbol => "Symbol(...)".into(),
ValueType::Object => {
let obj = Object::try_from(self).expect("object");
format!("{:?}", obj)
}
}
}
}
fn rust_function_defn(name: &String) -> JSClassDefinition {
JSClassDefinition {
version: 0,
attributes: 0,
className: **name as *const _,
parentClass: null_mut(),
staticValues: null(),
staticFunctions: null(),
initialize: None,
finalize: None,
hasProperty: None,
getProperty: None,
setProperty: None,
deleteProperty: None,
getPropertyNames: None,
callAsFunction: Some(callback_trampoline),
callAsConstructor: None,
hasInstance: None,
convertToType: None,
}
}
impl Value {
pub fn js_type(&self) -> ValueType {
self | {
let mut s = f.debug_struct("Object");
unsafe {
let array = JSObjectCopyPropertyNames(*self.0, self.1);
let size = JSPropertyNameArrayGetCount(array);
for i in 0..size {
let js_ref = JSPropertyNameArrayGetNameAtIndex(array, i);
let prop_name = std::string::String::from(&String(js_ref));
let prop_value = Value::from(
self.0,
JSObjectGetPropertyAtIndex(*self.0, self.1, i as u32, null_mut()),
);
s.field(&prop_name, &format!("{:?}", prop_value));
}
}
s.finish()
} | identifier_body |
types.rs | f(&self) -> &$ffi_ref {
&self.0
}
}
};
}
unsafe impl Send for GlobalContext {}
unsafe impl Sync for GlobalContext {}
unsafe impl Send for Context {}
unsafe impl Sync for Context {}
unsafe impl Send for String {}
unsafe impl Sync for String {}
unsafe impl Send for Object {}
unsafe impl Sync for Object {}
unsafe impl Send for ContextGroup {}
unsafe impl Sync for ContextGroup {}
unsafe impl Send for Value {}
unsafe impl Sync for Value {}
#[derive(Copy, Clone, Debug)]
pub struct Context(pub(crate) JSContextRef);
pub struct ContextGroup(pub(crate) JSContextGroupRef);
pub struct GlobalContext(pub(crate) JSGlobalContextRef);
pub struct Object(pub(crate) Context, pub(crate) JSObjectRef);
pub struct String(pub(crate) JSStringRef);
use std::fmt;
impl fmt::Debug for Object {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut s = f.debug_struct("Object");
unsafe {
let array = JSObjectCopyPropertyNames(*self.0, self.1);
let size = JSPropertyNameArrayGetCount(array);
for i in 0..size {
let js_ref = JSPropertyNameArrayGetNameAtIndex(array, i);
let prop_name = std::string::String::from(&String(js_ref));
let prop_value = Value::from(
self.0,
JSObjectGetPropertyAtIndex(*self.0, self.1, i as u32, null_mut()),
);
s.field(&prop_name, &format!("{:?}", prop_value));
}
}
s.finish()
}
}
impl fmt::Debug for Exception {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Exception")
.field("stack", &self.stack())
.field("message", &self.message())
.finish()
}
}
impl fmt::Display for Exception {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "Message: {}", &self.message())?;
writeln!(f, "Stack:")?;
write!(f, "{}", self.stack())
}
}
#[derive(Debug, Copy, Clone)]
pub enum ValueType {
Undefined,
Null,
Boolean,
Number,
String,
Object,
Symbol,
}
#[derive(Debug)]
pub struct Value(
pub(crate) JSValueRef,
pub(crate) ValueType,
pub(crate) Context,
);
pub trait ContextType {
unsafe fn as_ptr(&self) -> JSContextRef;
fn undefined(&self) -> Value {
let ptr = unsafe { self.as_ptr() };
let value = unsafe { JSValueMakeUndefined(ptr) };
Value(value, ValueType::Undefined, Context(ptr))
}
}
impl ContextType for GlobalContext {
unsafe fn as_ptr(&self) -> JSContextRef {
self.0
}
}
impl ContextType for Context {
unsafe fn as_ptr(&self) -> JSContextRef {
self.0
}
}
impl Deref for Context {
type Target = JSContextRef;
fn deref(&self) -> &JSContextRef {
&self.0
}
}
impl Deref for Object {
type Target = JSObjectRef;
fn deref(&self) -> &JSObjectRef {
&self.1
}
}
retain_release!(
ContextGroup,
JSContextGroupRef,
JSContextGroupRetain,
JSContextGroupRelease
);
retain_release!(
GlobalContext,
JSGlobalContextRef,
JSGlobalContextRetain,
JSGlobalContextRelease
);
retain_release!(String, JSStringRef, JSStringRetain, JSStringRelease);
impl ContextGroup {
pub fn new() -> ContextGroup {
let ptr = unsafe { JSContextGroupCreate() };
ContextGroup(ptr)
}
pub fn create_global_context(&self) -> GlobalContext {
let ptr = unsafe { JSGlobalContextCreateInGroup(self.0, null_mut()) };
GlobalContext(ptr)
}
}
pub struct Exception(Object);
impl Exception {
pub fn stack(&self) -> std::string::String {
let stack_val = self
.0
.get_property(&String::new("stack").unwrap())
.expect("no `stack` property found");
let stack_str = String::try_from(&stack_val).expect("no string property found for `stack`");
std::string::String::from(&stack_str)
}
pub fn message(&self) -> std::string::String {
let message_val = self
.0
.get_property(&String::new("message").unwrap())
.expect("no `message` property found");
let message_str =
String::try_from(&message_val).expect("no string property found for `message`");
std::string::String::from(&message_str)
}
}
impl GlobalContext {
pub fn global_object(&self) -> Object {
let ptr = unsafe { JSContextGetGlobalObject(self.0) };
Object(Context(self.0), ptr)
}
pub fn evaluate_script_sync(&self, script: &String) -> Result<Value, Exception> {
let mut exception = null();
let ret = unsafe {
JSEvaluateScript(self.0, **script, null_mut(), null_mut(), 0, &mut exception)
};
if exception == null_mut() {
Ok(Value::from(Context(self.0), ret))
} else {
let value = Value::from(Context(self.0), exception);
let obj = Object::try_from(&value).unwrap();
Err(Exception(obj))
}
}
pub async fn | <'a>(&'a self, script: &'a String) -> Result<Value, Exception> {
self.evaluate_script_sync(script)
}
pub fn add_function(
&self,
name: &str,
callback: JsCallback,
) -> Result<(), Box<dyn std::error::Error>> {
let name = String::new(name).unwrap();
let obj = self.global_object();
let fn_obj = obj.make_function_with_callback(&name, callback);
obj.set_property(&name, Value::from(Context(self.0), *fn_obj));
Ok(())
}
}
type JsCallback =
fn(Context, /*thisObject*/ Object, /*arguments*/ Vec<Value>) -> Result<Value, String>;
extern "C" fn callback_trampoline(
ctx: JSContextRef,
function: JSObjectRef,
this_object: JSObjectRef,
argument_count: usize,
arguments: *const JSValueRef,
exception: *mut JSValueRef,
) -> JSValueRef {
let callback = unsafe {
std::mem::transmute::<*mut ::std::os::raw::c_void, JsCallback>(JSObjectGetPrivate(function))
};
let ctx = Context(ctx);
let args = unsafe {
std::slice::from_raw_parts(arguments, argument_count)
.into_iter()
.map(|v| Value::from(ctx, *v))
.collect::<Vec<_>>()
};
match callback(ctx, Object(ctx, this_object), args) {
Ok(v) => v.0,
Err(e) => unsafe {
*exception = e.to_js_value(&ctx);
JSValueMakeUndefined(ctx.0)
},
}
}
impl ValueType {
unsafe fn from(ctx: Context, value_ref: JSValueRef) -> ValueType {
let raw_ty = JSValueGetType(ctx.0, value_ref);
match raw_ty {
0 => ValueType::Undefined,
1 => ValueType::Null,
2 => ValueType::Boolean,
3 => ValueType::Number,
4 => ValueType::String,
5 => ValueType::Object,
6 => ValueType::Symbol,
_ => unreachable!(),
}
}
}
impl Value {
fn from(ctx: Context, value_ref: JSValueRef) -> Value {
Value(value_ref, unsafe { ValueType::from(ctx, value_ref) }, ctx)
}
pub fn to_string(&self) -> std::string::String {
match self.js_type() {
ValueType::String => {
let js_str = String::try_from(self).expect("string");
std::string::String::from(&js_str)
}
ValueType::Number => {
let n = f64::try_from(self).expect("f64");
format!("{}", n)
}
ValueType::Boolean => {
let v = bool::try_from(self).expect("bool");
format!("{}", v)
}
ValueType::Null => "null".into(),
ValueType::Undefined => "undefined".into(),
ValueType::Symbol => "Symbol(...)".into(),
ValueType::Object => {
let obj = Object::try_from(self).expect("object");
format!("{:?}", obj)
}
}
}
}
fn rust_function_defn(name: &String) -> JSClassDefinition {
JSClassDefinition {
version: 0,
attributes: 0,
className: **name as *const _,
parentClass: null_mut(),
staticValues: null(),
staticFunctions: null(),
initialize: None,
finalize: None,
hasProperty: None,
getProperty: None,
setProperty: None,
deleteProperty: None,
getPropertyNames: None,
callAsFunction: Some(callback_trampoline),
callAsConstructor: None,
hasInstance: None,
convertToType: None,
}
}
impl Value {
pub fn js_type(&self) -> ValueType {
self. | evaluate_script | identifier_name |
setting.go | 用户名: %s</br> 密码: %s</br>邮箱: %s</body></html>`, r.Referer(), r.Referer(), getuser.Nickname, getuser.Password, getuser.Email),
getuser.Email)
// // 验证组和职位不能为空
// if getuser.StatusGroup == "" || getuser.RoleGroup == "" || getuser.Position == "" {
// w.Write(errorcode.Error("验证组和职位不能为空"))
// return
// }
// //1，先要验证nickname 是否有重复的
// if _, ok := cache.CacheNickNameUid[getuser.Nickname]; ok {
// w.Write(errorcode.Error("nickname 重复"))
// return
// }
// //验证邮箱 是否有重复的
// var hasemail bool
// for _, v := range cache.CacheUidEmail {
// if v == getuser.Email {
// hasemail = true
// }
// }
// if hasemail {
// w.Write(errorcode.Error("email 重复"))
// return
// }
// ids := make([]string, 0)
// for k := range cache.CacheSidStatus {
// ids = append(ids, strconv.FormatInt(k.ToInt64(), 10))
// }
// var sgid int64
// var hassggroup bool
// for k, v := range cache.CacheSgidGroup {
// if v == getuser.StatusGroup {
// sgid = k
// hassggroup = true
// break
// }
// }
// var rid int64
// err := model.CheckRoleNameInGroup(getuser.RoleGroup, &rid)
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// if !hassggroup {
// w.Write(errorcode.Error("没有找到权限"))
// return
// }
// // 获取级别,如果这个职位不存在，就返回错误
// var jid int64
// var ok bool
// if jid, ok = cache.CacheJobnameJid[getuser.Position]; !ok {
// w.Write(errorcode.Error("职位不存在"))
// return
// }
// // 增加用户
// user := model.User{
// NickName: getuser.Nickname,
// RealName: getuser.RealName,
// Password: enpassword,
// Email: getuser.Email,
// CreateId: uid,
// ShowStatus: cache.StoreLevelId(strings.Join(ids, ",")),
// BugGroupId: sgid,
// Roleid: rid,
// Jobid: jid,
// }
// err = user.Create()
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// //更新缓存
// send, _ := json.Marshal(errorcode)
w.Write(errorcode.Success())
return
}
func RemoveUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
id := r.FormValue("id")
// 判断是否有bug
var count int
err := db.Mconn.GetOne("select count(id) from bugs where uid=?", id).Scan(&count)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
if count > 0 {
golog.Error("uid:%v,has bugs,can not remove")
w.Write(errorcode.IsUse())
return
}
// 查看用户组是否存在此用户
userrows, err := db.Mconn.GetRows("select ids from usergroup")
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
var hasgroup bool
for userrows.Next() {
var ids string
userrows.Scan(&ids)
for _, v := range strings.Split(ids, ",") {
if v == id {
hasgroup = true
break
}
}
if hasgroup {
w.Write(errorcode.Error("还有group"))
return
}
}
userrows.Close()
_, err = db.Mconn.Update("delete from user where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
func DisableUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
id := r.FormValue("id")
var err error
_, err = db.Mconn.Update("update user set disable=ABS(disable-1) where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
_, err = db.Mconn.Update("update bugs set dustbin=ABS(dustbin-1) where uid=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
// 显示自己能管理的权限，不显示自己的
func UserList(w http.ResponseWriter, r *http.Request) {
uid := xmux.GetInstance(r).Get("uid").(int64)
errorcode := &response.Response{}
uls := &user.UserList{}
if uid == cache.SUPERID {
getallsql := `select u.id,createtime,realname,nickname,email,disable,j.name from
user as u
join jobs as j
on u.jid = j.id and u.id<>?`
adminrows, err := db.Mconn.GetRows(getallsql, cache.SUPERID)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.W | db.Mconn.GetRows(getallsql, uid)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.RoleGroup, &ul.StatusGroup, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.Write(send)
return
}
}
func UserUpdate(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
uid := xmux.GetInstance(r).Get("uid").(int64)
if cache.SUPERID != uid {
w.Write(errorcode.ErrorNoPermission())
return
}
uls := xmux.GetInstance(r).Data.(*user.User)
// 0是系统管理员， 1是管理层， 2是普通用户
//switch level {
//case 0:
// var hasstatusgroup bool
// var rid int64
// var bsid int64
// err := model.CheckRoleNameInGroup(uls.RoleGroup, &rid)
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// for k, v := range cache.CacheSgidGroup {
// if v == uls.StatusGroup {
// bsid = k
// hasstatusgroup = true
// break
// }
// }
// if _, ok := cache.CacheJobnameJid[uls.Position]; !ok {
// w.Write(errorcode.Error("没有找到职位"))
// return
// }
// if !hasstatusgroup {
// w.Write(errorcode.Error("没有找到status"))
// return
// }
if strings.Contains(uls.Nickname, "@") {
w.Write(errorcode.Error("昵称不能包含@符号"))
return
}
getallsql := `update user set
realname=?, nickname=?, email=? | rite(send)
return
} else {
getallsql := `select u.id,createtime,realname,nickname,email,disable, j.name from
user as u join jobs as j
on u.jid in (select id from jobs where hypo=(select jid from user where id=?))`
adminrows, err := | conditional_block |
setting.go | 用户名: %s</br> 密码: %s</br>邮箱: %s</body></html>`, r.Referer(), r.Referer(), getuser.Nickname, getuser.Password, getuser.Email),
getuser.Email)
// // 验证组和职位不能为空
// if getuser.StatusGroup == "" || getuser.RoleGroup == "" || getuser.Position == "" {
// w.Write(errorcode.Error("验证组和职位不能为空"))
// return
// }
// //1，先要验证nickname 是否有重复的
// if _, ok := cache.CacheNickNameUid[getuser.Nickname]; ok {
// w.Write(errorcode.Error("nickname 重复"))
// return
// }
// //验证邮箱 是否有重复的
// var hasemail bool
// for _, v := range cache.CacheUidEmail {
// if v == getuser.Email {
// hasemail = true
// }
// }
// if hasemail {
// w.Write(errorcode.Error("email 重复"))
// return
// }
// ids := make([]string, 0)
// for k := range cache.CacheSidStatus {
// ids = append(ids, strconv.FormatInt(k.ToInt64(), 10))
// }
// var sgid int64
// var hassggroup bool
// for k, v := range cache.CacheSgidGroup {
// if v == getuser.StatusGroup {
// sgid = k
// hassggroup = true
// break
// }
// }
// var rid int64
// err := model.CheckRoleNameInGroup(getuser.RoleGroup, &rid)
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// if !hassggroup {
// w.Write(errorcode.Error("没有找到权限"))
// return
// }
// // 获取级别,如果这个职位不存在，就返回错误
// var jid int64
// var ok bool
// if jid, ok = cache.CacheJobnameJid[getuser.Position]; !ok {
// w.Write(errorcode.Error("职位不存在"))
// return
// }
// // 增加用户
// user := model.User{
// NickName: getuser.Nickname,
// RealName: getuser.RealName,
// Password: enpassword,
// Email: getuser.Email,
// CreateId: uid,
// ShowStatus: cache.StoreLevelId(strings.Join(ids, ",")),
// BugGroupId: sgid,
// Roleid: rid,
// Jobid: jid,
// }
// err = user.Create()
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// //更新缓存
// send, _ := json.Marshal(errorcode)
w.Write(errorcode.Success())
return
}
func RemoveUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
id := r.FormValue("id")
// 判断是否有bug
var count int
err := db.Mconn.GetOne("select count(id) from bugs where uid=?", id).Scan(&count)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
if count > 0 {
golog.Error("uid:%v,has bugs,can not remove")
w.Write(errorcode.IsUse())
return
}
// 查看用户组是否存在此用户
userrows, err := db.Mconn.GetRows("select ids from usergroup")
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
var hasgroup bool
for userrows.Next() {
var ids string
userrows.Scan(&ids)
for _, v := range strings.Split(ids, ",") {
if v == id {
hasgroup = true
break
}
}
if hasgroup {
w.Write(errorcode.Error("还有group"))
return
}
}
userrows.Close()
_, err = db.Mconn.Update("delete from user where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
func DisableUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
id := r.FormValue("id")
var err error
_, err = db.Mconn.Update("update user set disable=ABS(disable-1) where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcod | r))
return
}
_, err = db.Mconn.Update("update bugs set dustbin=ABS(dustbin-1) where uid=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
// 显示自己能管理的权限，不显示自己的
func UserList(w http.ResponseWriter, r *http.Request) {
uid := xmux.GetInstance(r).Get("uid").(int64)
errorcode := &response.Response{}
uls := &user.UserList{}
if uid == cache.SUPERID {
getallsql := `select u.id,createtime,realname,nickname,email,disable,j.name from
user as u
join jobs as j
on u.jid = j.id and u.id<>?`
adminrows, err := db.Mconn.GetRows(getallsql, cache.SUPERID)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.Write(send)
return
} else {
getallsql := `select u.id,createtime,realname,nickname,email,disable, j.name from
user as u join jobs as j
on u.jid in (select id from jobs where hypo=(select jid from user where id=?))`
adminrows, err := db.Mconn.GetRows(getallsql, uid)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.RoleGroup, &ul.StatusGroup, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.Write(send)
return
}
}
func UserUpdate(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
uid := xmux.GetInstance(r).Get("uid").(int64)
if cache.SUPERID != uid {
w.Write(errorcode.ErrorNoPermission())
return
}
uls := xmux.GetInstance(r).Data.(*user.User)
// 0是系统管理员， 1是管理层， 2是普通用户
//switch level {
//case 0:
// var hasstatusgroup bool
// var rid int64
// var bsid int64
// err := model.CheckRoleNameInGroup(uls.RoleGroup, &rid)
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// for k, v := range cache.CacheSgidGroup {
// if v == uls.StatusGroup {
// bsid = k
// hasstatusgroup = true
// break
// }
// }
// if _, ok := cache.CacheJobnameJid[uls.Position]; !ok {
// w.Write(errorcode.Error("没有找到职位"))
// return
// }
// if !hasstatusgroup {
// w.Write(errorcode.Error("没有找到status"))
// return
// }
if strings.Contains(uls.Nickname, "@") {
w.Write(errorcode.Error("昵称不能包含@符号"))
return
}
getallsql := `update user set
realname=?, nickname=?, email | e.ErrorE(er | identifier_name |
setting.go | code.IsUse())
return
}
// 查看用户组是否存在此用户
userrows, err := db.Mconn.GetRows("select ids from usergroup")
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
var hasgroup bool
for userrows.Next() {
var ids string
userrows.Scan(&ids)
for _, v := range strings.Split(ids, ",") {
if v == id {
hasgroup = true
break
}
}
if hasgroup {
w.Write(errorcode.Error("还有group"))
return
}
}
userrows.Close()
_, err = db.Mconn.Update("delete from user where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
func DisableUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
id := r.FormValue("id")
var err error
_, err = db.Mconn.Update("update user set disable=ABS(disable-1) where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
_, err = db.Mconn.Update("update bugs set dustbin=ABS(dustbin-1) where uid=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
// 显示自己能管理的权限，不显示自己的
func UserList(w http.ResponseWriter, r *http.Request) {
uid := xmux.GetInstance(r).Get("uid").(int64)
errorcode := &response.Response{}
uls := &user.UserList{}
if uid == cache.SUPERID {
getallsql := `select u.id,createtime,realname,nickname,email,disable,j.name from
user as u
join jobs as j
on u.jid = j.id and u.id<>?`
adminrows, err := db.Mconn.GetRows(getallsql, cache.SUPERID)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.Write(send)
return
} else {
getallsql := `select u.id,createtime,realname,nickname,email,disable, j.name from
user as u join jobs as j
on u.jid in (select id from jobs where hypo=(select jid from user where id=?))`
adminrows, err := db.Mconn.GetRows(getallsql, uid)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.RoleGroup, &ul.StatusGroup, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.Write(send)
return
}
}
func UserUpdate(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
uid := xmux.GetInstance(r).Get("uid").(int64)
if cache.SUPERID != uid {
w.Write(errorcode.ErrorNoPermission())
return
}
uls := xmux.GetInstance(r).Data.(*user.User)
// 0是系统管理员， 1是管理层， 2是普通用户
//switch level {
//case 0:
// var hasstatusgroup bool
// var rid int64
// var bsid int64
// err := model.CheckRoleNameInGroup(uls.RoleGroup, &rid)
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// for k, v := range cache.CacheSgidGroup {
// if v == uls.StatusGroup {
// bsid = k
// hasstatusgroup = true
// break
// }
// }
// if _, ok := cache.CacheJobnameJid[uls.Position]; !ok {
// w.Write(errorcode.Error("没有找到职位"))
// return
// }
// if !hasstatusgroup {
// w.Write(errorcode.Error("没有找到status"))
// return
// }
if strings.Contains(uls.Nickname, "@") {
w.Write(errorcode.Error("昵称不能包含@符号"))
return
}
getallsql := `update user set
realname=?, nickname=?, email=?,
jid=(select coalesce(min(id),0) from jobs where name=?)
where id=?`
_, err := db.Mconn.Update(getallsql,
uls.Realname, uls.Nickname, uls.Email, uls.Position,
uls.Id,
)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
func ChangePassword(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
getuser := xmux.GetInstance(r).Data.(*user.ChangePasswod)
uid := xmux.GetInstance(r).Get("uid").(int64)
getaritclesql := "select count(id) from user where id=? and password=?"
oldpassword := encrypt.PwdEncrypt(getuser.Oldpassword, cache.Salt)
var n int
err := db.Mconn.GetOne(getaritclesql, uid, oldpassword).Scan(&n)
if err != nil || n != 1 {
golog.Error(err)
w.Write(errorcode.ErrorNoPermission())
return
}
newpassword := encrypt.PwdEncrypt(getuser.Newpassword, cache.Salt)
chpwdsql := "update user set password=? where id=?"
_, err = db.Mconn.Update(chpwdsql, newpassword, uid)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
func GetRoles(w http.ResponseWriter, r *http.Request) {
rl := &role.RespRoles{}
w.Write(rl.List())
return
}
// func GetThisRoles(w http.ResponseWriter, r *http.Request) {
// errorcode := &response.Response{}
// rl := &getroles{}
// id := r.FormValue("id")
// var rolestring string
// err := db.Mconn.GetOne("select rolestring from user where id=?", id).Scan(&rolestring)
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ConnectMysqlFail())
// return
// }
// send, _ := json.Marshal(rl)
// w.Write(send)
// return
// }
type sendGroup struct {
Groups []string `json:"groups"`
Code int `json:"code"`
}
func GetGroup(w http.ResponseWriter, r *http.Request) {
sg := &sendGroup{}
send, _ := json.Marshal(sg)
w.Write(send)
return
}
type sty struct {
Ts map[int]string `json:"ts"`
Code int `json:"code"`
}
func GetTaskTyp(w http.ResponseWriter, r *http.Request) {
ts := &sty{
Ts: make(map[int]string, 0),
}
rows, err := db.Mconn.GetRows("select id,name from typ")
if err != nil {
w.Write([]byte(fmt.Sprintf(`{"code": 2, "msg": "%s"}`, err.Error())))
return
}
for rows.Next() {
var t string
var id int
err = rows.Scan(&id, &t)
if err != nil {
golog.Info(err)
continue
}
ts.Ts[id] = t
}
send, _ := json. | Marshal(ts)
w.Write(send)
return
}
func ResetPwd(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
rp := xmux.GetInstance(r).Data.(*user.ResetPassword)
newpassword := encrypt.PwdEncrypt(rp.Password, cache.Salt)
updatepwdsql := "update user set password=? where id=?"
_, err := db.Mconn.Update(updatepwdsql, newpassword, rp.Id)
if err != nil {
golog.Error(err)
w.Wri | identifier_body |
|
setting.go | "github.com/hyahm/golog"
"github.com/hyahm/xmux"
)
func CreateUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
// nickname := xmux.GetInstance(r).Get("nickname").(string)
uid := xmux.GetInstance(r).Get("uid").(int64)
createTime := time.Now().Unix()
getuser := xmux.GetInstance(r).Data.(*user.GetAddUser)
if strings.Contains(getuser.Nickname, "@") {
w.Write(errorcode.Error("昵称不能包含@符号"))
return
}
enpassword := encrypt.PwdEncrypt(getuser.Password, cache.Salt)
var err error
db.Mconn.OpenDebug()
errorcode.Id, err = db.Mconn.Insert(`insert into user(nickname, password, email, createtime, createuid, realname, jid) values(
?,?,?,?,?,?,
(select id from jobs where name=?))`, getuser.Nickname,
enpassword, getuser.Email, createTime,
uid, getuser.RealName, getuser.Position)
golog.Info(db.Mconn.GetSql())
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
cache.CacheEmail.SendMail("成功创建用户",
fmt.Sprintf(`<html><body><h1>已成功创建用户<h1>登录网址:<a href="%s">%s</a></br>用户名: %s</br> 密码: %s</br>邮箱: %s</body></html>`, r.Referer(), r.Referer(), getuser.Nickname, getuser.Password, getuser.Email),
getuser.Email)
// // 验证组和职位不能为空
// if getuser.StatusGroup == "" || getuser.RoleGroup == "" || getuser.Position == "" {
// w.Write(errorcode.Error("验证组和职位不能为空"))
// return
// }
// //1，先要验证nickname 是否有重复的
// if _, ok := cache.CacheNickNameUid[getuser.Nickname]; ok {
// w.Write(errorcode.Error("nickname 重复"))
// return
// }
// //验证邮箱 是否有重复的
// var hasemail bool
// for _, v := range cache.CacheUidEmail {
// if v == getuser.Email {
// hasemail = true
// }
// }
// if hasemail {
// w.Write(errorcode.Error("email 重复"))
// return
// }
// ids := make([]string, 0)
// for k := range cache.CacheSidStatus {
// ids = append(ids, strconv.FormatInt(k.ToInt64(), 10))
// }
// var sgid int64
// var hassggroup bool
// for k, v := range cache.CacheSgidGroup {
// if v == getuser.StatusGroup {
// sgid = k
// hassggroup = true
// break
// }
// }
// var rid int64
// err := model.CheckRoleNameInGroup(getuser.RoleGroup, &rid)
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// if !hassggroup {
// w.Write(errorcode.Error("没有找到权限"))
// return
// }
// // 获取级别,如果这个职位不存在，就返回错误
// var jid int64
// var ok bool
// if jid, ok = cache.CacheJobnameJid[getuser.Position]; !ok {
// w.Write(errorcode.Error("职位不存在"))
// return
// }
// // 增加用户
// user := model.User{
// NickName: getuser.Nickname,
// RealName: getuser.RealName,
// Password: enpassword,
// Email: getuser.Email,
// CreateId: uid,
// ShowStatus: cache.StoreLevelId(strings.Join(ids, ",")),
// BugGroupId: sgid,
// Roleid: rid,
// Jobid: jid,
// }
// err = user.Create()
// if err != nil {
// golog.Error(err)
// w.Write(errorcode.ErrorE(err))
// return
// }
// //更新缓存
// send, _ := json.Marshal(errorcode)
w.Write(errorcode.Success())
return
}
func RemoveUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
id := r.FormValue("id")
// 判断是否有bug
var count int
err := db.Mconn.GetOne("select count(id) from bugs where uid=?", id).Scan(&count)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
if count > 0 {
golog.Error("uid:%v,has bugs,can not remove")
w.Write(errorcode.IsUse())
return
}
// 查看用户组是否存在此用户
userrows, err := db.Mconn.GetRows("select ids from usergroup")
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
var hasgroup bool
for userrows.Next() {
var ids string
userrows.Scan(&ids)
for _, v := range strings.Split(ids, ",") {
if v == id {
hasgroup = true
break
}
}
if hasgroup {
w.Write(errorcode.Error("还有group"))
return
}
}
userrows.Close()
_, err = db.Mconn.Update("delete from user where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
func DisableUser(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
id := r.FormValue("id")
var err error
_, err = db.Mconn.Update("update user set disable=ABS(disable-1) where id=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
_, err = db.Mconn.Update("update bugs set dustbin=ABS(dustbin-1) where uid=?", id)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
send, _ := json.Marshal(errorcode)
w.Write(send)
return
}
// 显示自己能管理的权限，不显示自己的
func UserList(w http.ResponseWriter, r *http.Request) {
uid := xmux.GetInstance(r).Get("uid").(int64)
errorcode := &response.Response{}
uls := &user.UserList{}
if uid == cache.SUPERID {
getallsql := `select u.id,createtime,realname,nickname,email,disable,j.name from
user as u
join jobs as j
on u.jid = j.id and u.id<>?`
adminrows, err := db.Mconn.GetRows(getallsql, cache.SUPERID)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.Write(send)
return
} else {
getallsql := `select u.id,createtime,realname,nickname,email,disable, j.name from
user as u join jobs as j
on u.jid in (select id from jobs where hypo=(select jid from user where id=?))`
adminrows, err := db.Mconn.GetRows(getallsql, uid)
if err != nil {
golog.Error(err)
w.Write(errorcode.ErrorE(err))
return
}
for adminrows.Next() {
ul := &user.User{}
err = adminrows.Scan(&ul.Id, &ul.Createtime, &ul.Realname, &ul.Nickname, &ul.Email,
&ul.Disable, &ul.RoleGroup, &ul.StatusGroup, &ul.Position)
if err != nil {
golog.Info(err)
continue
}
uls.Userlist = append(uls.Userlist, ul)
}
adminrows.Close()
send, _ := json.Marshal(uls)
w.Write(send)
return
}
}
func UserUpdate(w http.ResponseWriter, r *http.Request) {
errorcode := &response.Response{}
uid := xmux.GetInstance(r).Get("uid | "itflow/internal/user"
"net/http"
"strings"
"time"
| random_line_split |
|
util.js | dragleave", function (event) {
// 当拖动元素离开可放置目标节点，重置其背景
if (event.target.className == "dropzone") {
event.target.style.background = "";
}
}, false);
document.addEventListener("drop", function (event) {
// 阻止默认动作（如打开一些元素的链接）
event.preventDefault();
// 移动拖动的元素到所选择的放置目标节点’
if (event.target.className == "dropzone") {
let name = $(event.target).attr("name");
if (name != 'home') {
// 判断是否已经有拖拽
let html = $(event.target).html();
if (html == null || html == "") {
event.target.style.background = "";
dragged.parentNode.removeChild(dragged);
event.target.appendChild(dragged);
} else {
alert("提示：只能添加一个标签")
//alert_util(host_proxy,'提示：已存在，无须再添加','warning')
}
} else {
event.target.style.background = "";
dragged.parentNode.removeChild(dragged);
event.target.appendChild(dragged);
}
}
}, false);
},
/**
* 将map1 转到 mao2 中
* @param map1
* @param map2
*/
mapToMap: function (map1, map2) {
$.each(map2, function (key, value) {
map2[key] = map1[key];
})
},
/**
* 清空map
* @param map
*/
cleanMap(map) {
$.each(map, function (key, value) {
if (key == 'is_enable') {
map[key] = true;
} else {
map[key] = "";
}
})
},
/**
* 清空map
* @param map
*/
cleaarMap(map) {
$.each(map, function (key, value) {
map[key] = "";
})
},
/**
* 获取复选框中的id
* @param list
* @returns {Array}
*/
getIds(list) {
let ids = [];
$(list).each(function (i, item) {
if ($.inArray(item._id, list) == '-1') {
ids.push(item._id)
}
})
return ids;
},
/**
*
* @param num
* @param str
*/
isNoStr(num) {
let str = "";
if (num == "0") {
str = "否"
} else if (num == "1") {
str = "是"
}
return str;
},
/**
* 转化sex
* @param str
*/
changeSex(str) {
if (str == '0') {
return "男";
} else {
return "女";
}
},
auditFormat(row) {
if (row.is_audit == 0) {
return '待审核'
} else if (row.is_audit == 1) {
return '通过'
} else if (row.is_audit == 2) {
return '退回'
} else if (row.is_audit == 3) {
return '已保存'
} else {
return '已保存'
}
},
auditFormatOrderby(str) {
let map = {};
if (str == 0) {
map.order_by = "2";
map.status = '待审核';
} else if (str == 1) {
map.order_by = "3";
map.status = '通过';
} else if (str == 2) {
map.order_by = "4";
map.status = '退回';
} else if (str == 3) {
map.order_by = "1";
map.status = '已保存';
} else {
map.order_by = "5";
map.status = '其他';
}
return map;
},
//加密
encrypt(word, keyStr) {
keyStr = keyStr ? keyStr : k;
var key = CryptoJS.enc.Utf8.parse(keyStr);
var srcs = CryptoJS.enc.Utf8.parse(word);
var encrypted = CryptoJS.AES.encrypt(srcs, key, {
iv: key,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding
});
return CryptoJS.enc.Base64.stringify(encrypted.ciphertext);
},
//解密
decrypt(word, keyStr) {
keyStr = keyStr ? keyStr : k;
var key = CryptoJS.enc.Utf8.parse(keyStr);
let base64 = CryptoJS.enc.Base64.parse(word);
let src = CryptoJS.enc.Base64.stringify(base64);
var decrypt = CryptoJS.AES.decrypt(src, key, {
iv: key,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding
});
var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
return decryptedStr.toString();
},
/* 数组对象排序,array-数组对象，key-排序字段,status=0-升序，status=1-降序 */
sortByKey(array, key, status) {
return array.sort(function (a, b) {
var x = a[key];
var y = b[key];
if (status === 0) {
return ((x < y) ? -1 : ((x > y) ? 1 : 0));
} else {
return ((x > y) ? -1 : ((x < y) ? 1 : 0));
}
})
},
loginType(row) {
if (row.login_type == "1") {
return '登录'
} else if (row.login_type == "2") {
return '异常'
} else if (row.login_type == "3") {
return '登出'
} else {
return '流程错误'
}
},
replace_all(html_str, name) {
let replace_str = "<span style='color: red'>" + name + "</span>"
let re = new RegExp(name, "g"); //定义正则表达式
//第一个参数是要替换掉的内容，第二个参数"g"表示替换全部（global）。
var Newstr = html_str.replace(re, replace_str); //第一个参数是正则表达式。//本例会将全部匹配项替换为第二个参数。
return Newstr;
},
/**
* 将list1 转到 list2中
* @param list1
* @param list2
*/
listToList: function (list1, list2) {
$.each(list2, function (index, item) {
$.each(list1, function (id, iten) {
if (item._id == iten._id) {
$.each(item, function (key, value) {
item[key] = iten[key];
})
}
})
})
return list2;
},
addCoreUrl() {
return "/kb-core/"
},
addApiUrl() {
return '/api'
},
getPicUrl() {
return "http://10.170.130.230:9002/core/static"
},
getUserInfo() {
let user = localStorage.getItem("user")
user = JSON.parse(user);
return user.id
},
addLoginUrl() {
return "/login/"
},
/**
* 将list转成map
* @param list 集合
* @param key map 的key
* @param value map 的value
*/
listToMap(list, key, value) {
let map = {}
if (list != null) {
list.forEach(function (item, index) {
map[item[key]] = item[value]
})
}
return map
},
/**
* 给多个查询条件的选项标签添加对应值映射和key。
* @param arr 查询条件 | aram dictMap 数据字典Map
*/
initConditionData(arr, dictMap) {
for (let i = 0; i < arr.length; i++) {
var key = arr[i].dict || arr[i].key;
if (key && dictMap[key]) {
this.attachDataMap(arr[i], dictMap[key]);
}
}
},
/**
* 获取字典表Map。
* @param callback 字典获取之后回调执行函数
*
*/
getDictDataMap(callback) {
adapter.queryDictData({}, function (d) {
var tData = d.data || {};
var mData = tData.data || {};
var map = {};
for (var k in mData) {
map[k] = map[k] || {};
for (var i = 0; i < mData[k].length; i++) {
var v = mData[k][i].value;
map[k][v] = mData[k][i].name;
}
}
if (typeof (callback) === "function") {
callback(map);
}
console.log(tData);
});
},
/**
* 给单个查询条件的选项标签添加对应值映射和key | 数组
* @p | identifier_name |
util.js | );
let src = CryptoJS.enc.Base64.stringify(base64);
var decrypt = CryptoJS.AES.decrypt(src, key, {
iv: key,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding
});
var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
return decryptedStr.toString();
},
/* 数组对象排序,array-数组对象，key-排序字段,status=0-升序，status=1-降序 */
sortByKey(array, key, status) {
return array.sort(function (a, b) {
var x = a[key];
var y = b[key];
if (status === 0) {
return ((x < y) ? -1 : ((x > y) ? 1 : 0));
} else {
return ((x > y) ? -1 : ((x < y) ? 1 : 0));
}
})
},
loginType(row) {
if (row.login_type == "1") {
return '登录'
} else if (row.login_type == "2") {
return '异常'
} else if (row.login_type == "3") {
return '登出'
} else {
return '流程错误'
}
},
replace_all(html_str, name) {
let replace_str = "<span style='color: red'>" + name + "</span>"
let re = new RegExp(name, "g"); //定义正则表达式
//第一个参数是要替换掉的内容，第二个参数"g"表示替换全部（global）。
var Newstr = html_str.replace(re, replace_str); //第一个参数是正则表达式。//本例会将全部匹配项替换为第二个参数。
return Newstr;
},
/**
* 将list1 转到 list2中
* @param list1
* @param list2
*/
listToList: function (list1, list2) {
$.each(list2, function (index, item) {
$.each(list1, function (id, iten) {
if (item._id == iten._id) {
$.each(item, function (key, value) {
item[key] = iten[key];
})
}
})
})
return list2;
},
addCoreUrl() {
return "/kb-core/"
},
addApiUrl() {
return '/api'
},
getPicUrl() {
return "http://10.170.130.230:9002/core/static"
},
getUserInfo() {
let user = localStorage.getItem("user")
user = JSON.parse(user);
return user.id
},
addLoginUrl() {
return "/login/"
},
/**
* 将list转成map
* @param list 集合
* @param key map 的key
* @param value map 的value
*/
listToMap(list, key, value) {
let map = {}
if (list != null) {
list.forEach(function (item, index) {
map[item[key]] = item[value]
})
}
return map
},
/**
* 给多个查询条件的选项标签添加对应值映射和key。
* @param arr 查询条件数组
* @param dictMap 数据字典Map
*/
initConditionData(arr, dictMap) {
for (let i = 0; i < arr.length; i++) {
var key = arr[i].dict || arr[i].key;
if (key && dictMap[key]) {
this.attachDataMap(arr[i], dictMap[key]);
}
}
},
/**
* 获取字典表Map。
* @param callback 字典获取之后回调执行函数
*
*/
getDictDataMap(callback) {
adapter.queryDictData({}, function (d) {
var tData = d.data || {};
var mData = tData.data || {};
var map = {};
for (var k in mData) {
map[k] = map[k] || {};
for (var i = 0; i < mData[k].length; i++) {
var v = mData[k][i].value;
map[k][v] = mData[k][i].name;
}
}
if (typeof (callback) === "function") {
callback(map);
}
console.log(tData);
});
},
/**
* 给单个查询条件的选项标签添加对应值映射和key。
* @param obj 查询条件对象
* @param dict 数据字典
*/
attachDataMap(obj, dict) {
console.log(dict)
var t = dict.length && obj.dataMap;
if (t) {
obj.items = [];
for (let i = 0; i < dict.length; i++) {
let item = dict[i]
let name = item.name;
if (name) {
obj.items.push(name);
obj.dataMap[name] = item.value;
}
}
}
},
/**
* 获取当前用户输入的查询条件参数。
* @param arr 查询条件数组
*/
getConditionParam(arr) {
let param = {};
for (let i = 0; i < arr.length; i++) {
let key = arr[i].key;
var map = arr[i].dataMap || {};
if (key && !arr[i].flag) {
let value = arr[i].value;
if (value.constructor.name === "Array") {
var tArr = [];
for (let j = 0; j < value.length; j++) {
tArr.push(map[value[j]] || value[j]);
}
param[key] = tArr;
} else {
param[key] = map[value] || value;
}
}
}
var ret = this.transferConditionData(param);
for (var t in ret) {
if (ret[t] && typeof (ret[t]) === "object") {
ret[t] = JSON.stringify(ret[t]);
}
}
return ret
},
transferConditionData(param) {
var dsl = {};
for (let k in param) {
var t = this.produceDSL(k, param[k]);
var type = t.type;
var data = t.data;
dsl[type] = dsl[type] || {};
if (type === "exact_search" && data.value !== "" && data.value !== undefined) {
dsl[type][data.key] = data.value;
} else if (type === "in_search" && data.value.constructor.name === "Array" && data.value.length !== 0) {
dsl[type][data.key] = data.value;
} else if (type === "rang_search" && data.value.start && data.value.end) {
dsl[type][data.key] = data.value;
} else {
}
}
return dsl;
},
produceDSL(key, value) {
var ret = {
type: "exact_search",
data: {
key: key,
value: value
}
}
if (key === "publish_time") {
ret.type = "rang_search";
if (value.constructor.name === "Array") {
ret.data = {
key: "publish_time",
value: {
start: value[0],
end: value[1]
}
}
} else {
ret.data = {
key: "publish_time",
value: ""
}
}
} else if (value.constructor.name === "Array") {
ret.type = "in_search";
} else {}
return ret;
},
downloadItem(fileName, content) {
const blob = new Blob([content]);
const elink = document.createElement("a");
elink.download = fileName;
elink.style.display = "none";
elink.href = URL.createObjectURL(blob);
document.body.appendChild(elink);
elink.click();
URL.revokeObjectURL(elink.href); // 释放URL 对象
document.body.removeChild(elink);
},
checkConditions(dsl, tDSL) {
var ret = false;
if (!tDSL) {
return true;
}
for (var k in dsl) {
if (dsl[k] === "{}" || (dsl[k] && Object.keys(dsl[k]).length === 0)) {
delete dsl[k];
}
}
for (var k in tDSL) {
if (
dsl[k] === "{}" ||
(tDSL[k] && Object.keys(tDSL[k]).length === 0)
) {
delete tDSL[k];
}
}
for (var k in dsl) {
var v = dsl[k];
if (typeof v === "object") {
ret = !(JSON.stringify(v) === JSON.stringify | (tDSL[k]));
} else {
ret = !(v === tDSL[k]);
}
if (ret) {
break;
}
}
return ret;
}
/* function getInervalHour(startDate, endDate) {
var ms = endDate.getTime() - startDate.getTime();
if (ms < 0) return 0;
return Math.floor(ms/1000/60/60);
}
console.log("登录时间："+localStorage.getItem("in | identifier_body |
|
util.js | dragleave", function (event) {
// 当拖动元素离开可放置目标节点，重置其背景
if (event.target.className == "dropzone") {
event.target.style.background = "";
}
}, false);
document.addEventListener("drop", function (event) {
// 阻止默认动作（如打开一些元素的链接）
event.preventDefault();
// 移动拖动的元素到所选择的放置目标节点’
if (event.target.className == "dropzone") {
let name = $(event.target).attr("name");
if (name != 'home') {
// 判断是否已经有拖拽
let html = $(event.target).html();
if (html == null || html == "") {
event.target.style.background = "";
dragged.parentNode.removeChild(dragged);
event.target.appendChild(dragged);
} else {
alert("提示：只能添加一个标签")
//alert_util(host_proxy,'提示：已存在，无须再添加','warning')
}
} else {
event.target.style.background = "";
dragged.parentNode.removeChild(dragged);
event.target.appendChild(dragged);
}
}
}, false);
},
/**
* 将map1 转到 mao2 中
* @param map1
* @param map2
*/
mapToMap: function (map1, map2) {
$.each(map2, function (key, value) {
map2[key] = map1[key];
})
},
/**
* 清空map
* @param map
*/
cleanMap(map) {
$.each(map, function (key, value) {
if (key == 'is_enable') {
map[key] = true;
} else {
map[key] = "";
}
})
},
/**
* 清空map
* @param map
*/
cleaarMap(map) {
$.each(map, function (key, value) {
map[key] = "";
})
},
/**
* 获取复选框中的id
* @param list
* @returns {Array}
*/
getIds(list) {
let ids = [];
$(list).each(function (i, item) {
if ($.inArray(item._id, list) == '-1') {
ids.push(item._id)
}
})
return ids;
},
/**
*
* @param num
* @param str
*/
isNoStr(num) {
let str = "";
if (num == "0") {
str = "否"
} else if (num == "1") {
str = "是"
}
return str;
},
/**
* 转化sex
* @param str
*/
changeSex(str) {
if (str == '0') {
return "男";
} else {
return "女";
}
},
auditFormat(row) {
if (row.is_audit == 0) {
return '待审核'
} else if (row.is_audit == 1) {
return '通过'
} else if (row.is_audit == 2) {
return '退回'
} else if (row.is_audit == 3) {
return '已保存'
} else {
return '已保存'
}
},
auditFormatOrderby(str) {
let map = {};
if (str == 0) {
map.order_by = "2";
map.status = '待审核';
} else if (str == 1) {
map.order_by = "3";
map.status = '通过';
} else if (str == 2) {
map.order_by = "4";
map.status = '退回';
} else if (str == 3) {
map.order_by = "1";
map.status = '已保存';
} else {
map.order_by = "5";
map.status = '其他';
}
return map;
},
//加密
encrypt(word, keyStr) {
keyStr = keyStr ? keyStr : k;
var key = CryptoJS.enc.Utf8.parse(keyStr);
var srcs = CryptoJS.enc.Utf8.parse(word);
var encrypted = CryptoJS.AES.encrypt(srcs, key, {
iv: key,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding
});
return CryptoJS.enc.Base64.stringify(encrypted.ciphertext);
},
//解密
decrypt(word, keyStr) {
keyStr = keyStr ? keyStr : k;
var key = CryptoJS.enc.Utf8.parse(keyStr);
let base64 = CryptoJS.enc.Base64.parse(word);
let src = CryptoJS.enc.Base64.stringify(base64);
var decrypt = CryptoJS.AES.decrypt(src, key, {
iv: key,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding
});
var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
return decryptedStr.toString();
},
/* 数组对象排序,array-数组对象，key-排序字段,status=0-升序，status=1-降序 */
sortByKey(array, key, status) {
return array.sort(function (a, b) {
var x = a[key];
var y = b[key];
if (status === 0) {
return ((x < y) ? -1 : ((x > y) ? 1 : 0));
} else {
return ((x > y) ? -1 : ((x < y) ? 1 : 0));
}
})
},
loginType(row) {
if (row.login_type == "1") {
return '登录'
} else if (row.login_type == "2") {
return '异常'
} else if (row.login_type == "3") {
return '登出'
} else {
return '流程错误'
}
},
replace_all(html_str, name) {
let replace_str = "<span style='color: red'>" + name + "</span>"
let re = new RegExp(name, "g"); //定义正则表达式
//第一个参数是要替换掉的内容，第二个参数"g"表示替换全部（global）。
var Newstr = html_str.replace(re, replace_str); //第一个参数是正则表达式。//本例会将全部匹配项替换为第二个参数。
return Newstr;
},
/**
* 将list1 转到 list2中
* @param list1
* @param list2
*/
listToList: function (list1, list2) {
$.each(list2, function (index, item) {
$.each(list1, function (id, iten) {
if (item._id == iten._id) {
$.each(item, function (key, value) {
item[key] = iten[key];
})
}
})
})
return list2;
},
addCoreUrl() {
return "/kb-core/"
},
addApiUrl() {
return '/api'
},
getPicUrl() {
return "http://10.170.130.230:9002/core/static"
},
getUserInfo() {
let user = localStorage.getItem("user")
user = JSON.parse(user);
return user.id
},
addLoginUrl() {
return "/login/"
},
/**
* 将list转成map
* @param list 集合
* @param key map 的key
* @param value map 的value
*/
listToMap(list, key, value) {
let map = {}
if (list != null) {
list.forEach(funct | 查询条件的选项标签添加对应值映射和key。
* @param arr 查询条件数组
* @param dictMap 数据字典Map
*/
initConditionData(arr, dictMap) {
for (let i = 0; i < arr.length; i++) {
var key = arr[i].dict || arr[i].key;
if (key && dictMap[key]) {
this.attachDataMap(arr[i], dictMap[key]);
}
}
},
/**
* 获取字典表Map。
* @param callback 字典获取之后回调执行函数
*
*/
getDictDataMap(callback) {
adapter.queryDictData({}, function (d) {
var tData = d.data || {};
var mData = tData.data || {};
var map = {};
for (var k in mData) {
map[k] = map[k] || {};
for (var i = 0; i < mData[k].length; i++) {
var v = mData[k][i].value;
map[k][v] = mData[k][i].name;
}
}
if (typeof (callback) === "function") {
callback(map);
}
console.log(tData);
});
},
/**
* 给单个查询条件的选项标签添加对应值映射和 | ion (item, index) {
map[item[key]] = item[value]
})
}
return map
},
/**
* 给多个 | conditional_block |
util.js | ("dragleave", function (event) {
// 当拖动元素离开可放置目标节点，重置其背景
if (event.target.className == "dropzone") {
event.target.style.background = "";
}
}, false);
document.addEventListener("drop", function (event) {
// 阻止默认动作（如打开一些元素的链接）
event.preventDefault();
// 移动拖动的元素到所选择的放置目标节点’
if (event.target.className == "dropzone") {
let name = $(event.target).attr("name");
if (name != 'home') {
// 判断是否已经有拖拽
let html = $(event.target).html();
if (html == null || html == "") {
event.target.style.background = "";
dragged.parentNode.removeChild(dragged);
event.target.appendChild(dragged);
} else {
alert("提示：只能添加一个标签")
//alert_util(host_proxy,'提示：已存在，无须再添加','warning')
}
} else {
event.target.style.background = "";
dragged.parentNode.removeChild(dragged);
event.target.appendChild(dragged);
}
}
}, false);
},
/**
* 将map1 转到 mao2 中
* @param map1
* @param map2
*/
mapToMap: function (map1, map2) {
$.each(map2, function (key, value) {
map2[key] = map1[key];
})
},
/**
* 清空map
* @param map
*/
cleanMap(map) {
$.each(map, function (key, value) {
if (key == 'is_enable') {
map[key] = true;
} else {
map[key] = "";
}
})
},
/**
* 清空map
* @param map
*/
cleaarMap(map) {
$.each(map, function (key, value) {
map[key] = "";
})
},
/**
* 获取复选框中的id
* @param list
* @returns {Array}
*/
getIds(list) {
let ids = [];
$(list).each(function (i, item) {
if ($.inArray(item._id, list) == '-1') {
ids.push(item._id)
}
})
return ids;
},
/**
*
* @param num
* @param str
*/
isNoStr(num) {
let str = "";
if (num == "0") {
str = "否"
} else if (num == "1") {
str = "是"
}
return str;
},
/**
* 转化sex
* @param str
*/
changeSex(str) {
if (str == '0') {
return "男";
} else {
return "女";
}
},
auditFormat(row) {
if (row.is_audit == 0) {
return '待审核'
} else if (row.is_audit == 1) {
return '通过'
} else if (row.is_audit == 2) {
return '退回'
} else if (row.is_audit == 3) {
return '已保存'
} else {
return '已保存'
}
},
auditFormatOrderby(str) {
let map = {};
if (str == 0) {
map.order_by = "2";
map.status = '待审核';
} else if (str == 1) {
map.order_by = "3";
map.status = '通过';
} else if (str == 2) {
map.order_by = "4";
map.status = '退回';
} else if (str == 3) {
map.order_by = "1";
map.status = '已保存';
} else {
map.order_by = "5";
map.status = '其他';
}
return map;
},
//加密
encrypt(word, keyStr) {
keyStr = keyStr ? keyStr : k;
var key = CryptoJS.enc.Utf8.parse(keyStr);
var srcs = CryptoJS.enc.Utf8.parse(word);
var encrypted = CryptoJS.AES.encrypt(srcs, key, {
iv: key,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding
});
return CryptoJS.enc.Base64.stringify(encrypted.ciphertext);
},
//解密
decrypt(word, keyStr) {
keyStr = keyStr ? keyStr : k;
var key = CryptoJS.enc.Utf8.parse(keyStr);
let base64 = CryptoJS.enc.Base64.parse(word);
let src = CryptoJS.enc.Base64.stringify(base64);
var decrypt = CryptoJS.AES.decrypt(src, key, {
iv: key,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding | var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
return decryptedStr.toString();
},
/* 数组对象排序,array-数组对象，key-排序字段,status=0-升序，status=1-降序 */
sortByKey(array, key, status) {
return array.sort(function (a, b) {
var x = a[key];
var y = b[key];
if (status === 0) {
return ((x < y) ? -1 : ((x > y) ? 1 : 0));
} else {
return ((x > y) ? -1 : ((x < y) ? 1 : 0));
}
})
},
loginType(row) {
if (row.login_type == "1") {
return '登录'
} else if (row.login_type == "2") {
return '异常'
} else if (row.login_type == "3") {
return '登出'
} else {
return '流程错误'
}
},
replace_all(html_str, name) {
let replace_str = "<span style='color: red'>" + name + "</span>"
let re = new RegExp(name, "g"); //定义正则表达式
//第一个参数是要替换掉的内容，第二个参数"g"表示替换全部（global）。
var Newstr = html_str.replace(re, replace_str); //第一个参数是正则表达式。//本例会将全部匹配项替换为第二个参数。
return Newstr;
},
/**
* 将list1 转到 list2中
* @param list1
* @param list2
*/
listToList: function (list1, list2) {
$.each(list2, function (index, item) {
$.each(list1, function (id, iten) {
if (item._id == iten._id) {
$.each(item, function (key, value) {
item[key] = iten[key];
})
}
})
})
return list2;
},
addCoreUrl() {
return "/kb-core/"
},
addApiUrl() {
return '/api'
},
getPicUrl() {
return "http://10.170.130.230:9002/core/static"
},
getUserInfo() {
let user = localStorage.getItem("user")
user = JSON.parse(user);
return user.id
},
addLoginUrl() {
return "/login/"
},
/**
* 将list转成map
* @param list 集合
* @param key map 的key
* @param value map 的value
*/
listToMap(list, key, value) {
let map = {}
if (list != null) {
list.forEach(function (item, index) {
map[item[key]] = item[value]
})
}
return map
},
/**
* 给多个查询条件的选项标签添加对应值映射和key。
* @param arr 查询条件数组
* @param dictMap 数据字典Map
*/
initConditionData(arr, dictMap) {
for (let i = 0; i < arr.length; i++) {
var key = arr[i].dict || arr[i].key;
if (key && dictMap[key]) {
this.attachDataMap(arr[i], dictMap[key]);
}
}
},
/**
* 获取字典表Map。
* @param callback 字典获取之后回调执行函数
*
*/
getDictDataMap(callback) {
adapter.queryDictData({}, function (d) {
var tData = d.data || {};
var mData = tData.data || {};
var map = {};
for (var k in mData) {
map[k] = map[k] || {};
for (var i = 0; i < mData[k].length; i++) {
var v = mData[k][i].value;
map[k][v] = mData[k][i].name;
}
}
if (typeof (callback) === "function") {
callback(map);
}
console.log(tData);
});
},
/**
* 给单个查询条件的选项标签添加对应值映射和key。
| });
| random_line_split |
Assembler.py | each translation process.
numOfVariables = 0
def translate_c_command(command):
command_array = command.split("=")
if len(command_array) == 1: # no destination
command_and_jump_array = command_array[0].split(";")
destination_command = ""
else: # if length = 2
destination_command = command_array[0]
command_and_jump_array = command_array[1].split(";")
if len(command_and_jump_array) == 1: # no jump
jump_command = ""
compute_command = command_and_jump_array[0]
else: # if length = 2
compute_command = command_and_jump_array[0]
jump_command = command_and_jump_array[1]
compute_bin = compute_command_to_bin(compute_command)
destination_bin = destination_command_to_bin(destination_command)
jump_bin = jump_command_to_bin(jump_command)
return compute_bin+destination_bin+jump_bin
def compute_command_to_bin(compute_command):
if "*" in compute_command:
return mul_command_to_bin(compute_command)
elif ">>" in compute_command or "<<" in compute_command:
return shift_command_to_bin(compute_command)
elif "M" in compute_command:
return m_command_to_bin(compute_command)
else:
return a_command_to_bin(compute_command)
def mul_command_to_bin(compute_command):
if compute_command == "D*A":
return "1000000000"
elif compute_command == "D*M":
return "1001000000"
def shift_command_to_bin(compute_command):
if compute_command == "D<<":
return "1010110000"
elif compute_command == "A<<":
return "1010100000"
elif compute_command == "M<<":
return "1011100000"
elif compute_command == "D>>":
return "1010010000"
elif compute_command == "A>>":
return "1010000000"
elif compute_command == "M>>":
return "1011000000"
def m_command_to_bin(compute_command):
prefix = "1111"
# replacing the M in the M command to an A,
# this way we can use the A command func
compute_command = compute_command.replace("M", "A")
return a_command_to_bin(compute_command, prefix)
def a_command_to_bin(compute_command, prefix="1110"):
# shared A and M commands
if compute_command == "A":
suffix = "110000"
elif compute_command == "!A":
suffix = "110001"
elif compute_command == "-A":
suffix = "110011"
elif compute_command == "A+1":
suffix = "110111"
elif compute_command == "A-1":
suffix = "110010"
elif compute_command == "D+A":
suffix = "000010"
elif compute_command == "D-A":
suffix = "010011"
elif compute_command == "A-D":
suffix = "000111"
elif compute_command == "D&A":
suffix = "000000"
elif compute_command == "D|A":
suffix = "010101"
# A only commands
elif compute_command == "0":
suffix = "101010"
elif compute_command == "1":
suffix = "111111"
elif compute_command == "-1":
suffix = "111010"
elif compute_command == "D":
suffix = "001100"
elif compute_command == "!D":
suffix = "001101"
elif compute_command == "-D":
suffix = "001111"
elif compute_command == "D+1":
suffix = "011111"
elif compute_command == "D-1":
suffix = "001110"
return prefix+suffix
def destination_command_to_bin(destination_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if "M" in destination_command:
right_bit = "1"
if "D" in destination_command:
middle_bit = "1"
if "A" in destination_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def jump_command_to_bin(jump_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if jump_command == "JMP":
return "111"
if jump_command == "JNE":
return "101"
if "G" in jump_command:
right_bit = "1"
if "E" in jump_command:
middle_bit = "1"
if "L" in jump_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def translate_to_binary(command):
"""
A function that translates a number into binary, and formatting it to fit
the machine code language word length (16 bit)
:param command: an integer to transform into hack binary
:return: hack binary code
"""
int_command = int(command)
binary_command = bin(int_command)[2:]
missing_bits = CMD_LEN - len(binary_command)
cmd_prefix = missing_bits * str(0)
binary_command = str(cmd_prefix) + str(binary_command)
return binary_command + "\n"
def translate_a_command(marker_dictionary, cmd):
"""
A function that gets a assembly command and translated it into machine
code, using a supplied marker dictionary.
This function is designed to update the supplied marker dictionary.
:param marker_dictionary: a dictionary of pointers
:param cmd: an assembly command line
:return: the machine code binary respective to the supplied assembly line
"""
if cmd.isdigit():
return translate_to_binary(cmd)
else:
if cmd in marker_dictionary:
return translate_to_binary(marker_dictionary[cmd])
else:
global numOfVariables
marker_dictionary[cmd] = VAR_FIRST_MEM + numOfVariables
numOfVariables += 1
return translate_to_binary(VAR_FIRST_MEM + numOfVariables - 1)
def write_cmd(hack_file, marker_dictionary, cmd):
"""
This function writes a translated assembly name as hack machine code into
the supplied .hack file. The function uses helper functions to translate
code according to the type of code.
:param hack_file: a .hack file (destination for hack machine code)
:param marker_dictionary: a dictionary of pointers
:param cmd: a command to translate and write into hack_file
:return: None.
"""
if cmd[0] == '@':
hack_file.write(translate_a_command(marker_dictionary, cmd[1:]))
else:
hack_file.write(translate_c_command(cmd) + "\n")
def load_constants():
"""
A function that creates a dictionary containing all the hack assembly
constants and their respective binary values, including I/O and reserved
RAM locations
:return: the created dictionary
"""
marker_dictionary = dict()
marker_dictionary["SP"] = SP
marker_dictionary["LCL"] = LCL
marker_dictionary["ARG"] = ARG
marker_dictionary["THIS"] = THIS
marker_dictionary["THAT"] = THAT
marker_dictionary["SCREEN"] = SCREEN
marker_dictionary["KBD"] = KBD
for i in range(0, RAM_RESERVE_END):
marker_dictionary["R"+str(i)] = i
return marker_dictionary
def pre_process_asm_file(assembly_file):
| if command.startswith('('):
marker_dictionary[command[1:-1]] = line_counter
continue
commands_list.append(command)
line_counter += 1
return commands_list, marker_dictionary
def assemble_file(assembly_file_name, hack_file_name):
"""
A function that receives names of an .asm file and a .hack file.
The function will create the specified .hack file, and using helper
functions | """
This function process an assembly file before it's translation to machine
code. It creates a dictionary, and places into it all markers in the code,
and assigns each one of them it's location in code, allowing to use it as
a reference in future. While doing so, it deletes each marker's
declaration.
The function also clears all whitespaces and comments from the code.
Any line which is not a comment, empty, or a marker declaration is
inserted to a list of ordered commands, later used for creating a hack
machine code binary.
:param assembly_file: an .asm file
:return: the created dictionary and commands list.
"""
line_counter = 0
marker_dictionary = load_constants()
commands_list = list()
for command in assembly_file.readlines():
command = command.split("/")[0] # getting rid of comments
command = "".join(command.split()) # getting rid of whitespaces
if command:
| identifier_body |
Assembler.py | RAM_RESERVE_END = 16
# A constant representing the first place in RAM available for variables
VAR_FIRST_MEM = 16
""" Global variables"""
# A global variable representing the number of variables created in the
# supplied assembly code. When translating multiple files, this variable is
# set to 0 at the beginning of each translation process.
numOfVariables = 0
def translate_c_command(command):
command_array = command.split("=")
if len(command_array) == 1: # no destination
command_and_jump_array = command_array[0].split(";")
destination_command = ""
else: # if length = 2
destination_command = command_array[0]
command_and_jump_array = command_array[1].split(";")
if len(command_and_jump_array) == 1: # no jump
jump_command = ""
compute_command = command_and_jump_array[0]
else: # if length = 2
compute_command = command_and_jump_array[0]
jump_command = command_and_jump_array[1]
compute_bin = compute_command_to_bin(compute_command)
destination_bin = destination_command_to_bin(destination_command)
jump_bin = jump_command_to_bin(jump_command)
return compute_bin+destination_bin+jump_bin
def compute_command_to_bin(compute_command):
if "*" in compute_command:
return mul_command_to_bin(compute_command)
elif ">>" in compute_command or "<<" in compute_command:
return shift_command_to_bin(compute_command)
elif "M" in compute_command:
return m_command_to_bin(compute_command)
else:
return a_command_to_bin(compute_command)
def mul_command_to_bin(compute_command):
if compute_command == "D*A":
return "1000000000"
elif compute_command == "D*M":
return "1001000000"
def shift_command_to_bin(compute_command):
if compute_command == "D<<":
return "1010110000"
elif compute_command == "A<<":
return "1010100000"
elif compute_command == "M<<":
return "1011100000"
elif compute_command == "D>>":
return "1010010000"
elif compute_command == "A>>":
return "1010000000"
elif compute_command == "M>>":
return "1011000000"
def m_command_to_bin(compute_command):
prefix = "1111"
# replacing the M in the M command to an A,
# this way we can use the A command func
compute_command = compute_command.replace("M", "A")
return a_command_to_bin(compute_command, prefix)
def a_command_to_bin(compute_command, prefix="1110"):
# shared A and M commands
if compute_command == "A":
suffix = "110000"
elif compute_command == "!A":
suffix = "110001"
elif compute_command == "-A":
suffix = "110011"
elif compute_command == "A+1":
suffix = "110111"
elif compute_command == "A-1":
suffix = "110010"
elif compute_command == "D+A":
suffix = "000010"
elif compute_command == "D-A":
suffix = "010011"
elif compute_command == "A-D":
suffix = "000111"
elif compute_command == "D&A":
suffix = "000000"
elif compute_command == "D|A":
suffix = "010101"
# A only commands
elif compute_command == "0":
suffix = "101010"
elif compute_command == "1":
suffix = "111111"
elif compute_command == "-1":
suffix = "111010"
elif compute_command == "D":
suffix = "001100"
elif compute_command == "!D":
suffix = "001101"
elif compute_command == "-D":
suffix = "001111"
elif compute_command == "D+1":
suffix = "011111"
elif compute_command == "D-1":
suffix = "001110"
return prefix+suffix
def destination_command_to_bin(destination_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if "M" in destination_command:
right_bit = "1"
if "D" in destination_command:
middle_bit = "1"
if "A" in destination_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def jump_command_to_bin(jump_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if jump_command == "JMP":
return "111"
if jump_command == "JNE":
return "101"
if "G" in jump_command:
right_bit = "1"
if "E" in jump_command:
middle_bit = "1"
if "L" in jump_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def translate_to_binary(command):
"""
A function that translates a number into binary, and formatting it to fit
the machine code language word length (16 bit)
:param command: an integer to transform into hack binary
:return: hack binary code
"""
int_command = int(command)
binary_command = bin(int_command)[2:]
missing_bits = CMD_LEN - len(binary_command)
cmd_prefix = missing_bits * str(0)
binary_command = str(cmd_prefix) + str(binary_command)
return binary_command + "\n"
def translate_a_command(marker_dictionary, cmd):
"""
A function that gets a assembly command and translated it into machine
code, using a supplied marker dictionary.
This function is designed to update the supplied marker dictionary.
:param marker_dictionary: a dictionary of pointers
:param cmd: an assembly command line
:return: the machine code binary respective to the supplied assembly line
"""
if cmd.isdigit():
return translate_to_binary(cmd)
else:
if cmd in marker_dictionary:
return translate_to_binary(marker_dictionary[cmd])
else:
global numOfVariables
marker_dictionary[cmd] = VAR_FIRST_MEM + numOfVariables
numOfVariables += 1
return translate_to_binary(VAR_FIRST_MEM + numOfVariables - 1)
def write_cmd(hack_file, marker_dictionary, cmd):
"""
This function writes a translated assembly name as hack machine code into
the supplied .hack file. The function uses helper functions to translate
code according to the type of code.
:param hack_file: a .hack file (destination for hack machine code)
:param marker_dictionary: a dictionary of pointers
:param cmd: a command to translate and write into hack_file
:return: None.
"""
if cmd[0] == '@':
hack_file.write(translate_a_command(marker_dictionary, cmd[1:]))
else:
hack_file.write(translate_c_command(cmd) + "\n")
def load_constants():
"""
A function that creates a dictionary containing all the hack assembly
constants and their respective binary values, including I/O and reserved
RAM locations
:return: the created dictionary
"""
marker_dictionary = dict()
marker_dictionary["SP"] = SP
marker_dictionary["LCL"] = LCL
marker_dictionary["ARG"] = ARG
marker_dictionary["THIS"] = THIS
marker_dictionary["THAT"] = THAT
marker_dictionary["SCREEN"] = SCREEN
marker_dictionary["KBD"] = KBD
for i in range(0, RAM_RESERVE_END):
marker_dictionary["R"+str(i)] = i
return marker_dictionary
def pre_process_asm_file(assembly_file):
"""
This function process an assembly file before it's translation to machine
code. It creates a dictionary, and places into it all markers in the code,
and assigns each one of them it's location in code, allowing to use it as
a reference in future. While doing so, it deletes each marker's
declaration.
The function also clears all whitespaces and comments from the code.
Any line which is not a comment, empty, or a marker declaration is
inserted to a list of ordered commands, later used for creating a hack
machine code binary.
:param assembly_file: an .asm file
:return: the created dictionary and commands list.
"""
line_counter = 0
marker_dictionary = load_constants()
commands_list = list()
for command in assembly_file.readlines():
command = command.split("/")[0] # getting rid of comments
command = "".join(command.split()) # getting rid of whitespaces | SCREEN = 16384
KBD = 24576
# The last number of RAM to be reserved
| random_line_split |
|
Assembler.py | each translation process.
numOfVariables = 0
def translate_c_command(command):
command_array = command.split("=")
if len(command_array) == 1: # no destination
command_and_jump_array = command_array[0].split(";")
destination_command = ""
else: # if length = 2
destination_command = command_array[0]
command_and_jump_array = command_array[1].split(";")
if len(command_and_jump_array) == 1: # no jump
jump_command = ""
compute_command = command_and_jump_array[0]
else: # if length = 2
compute_command = command_and_jump_array[0]
jump_command = command_and_jump_array[1]
compute_bin = compute_command_to_bin(compute_command)
destination_bin = destination_command_to_bin(destination_command)
jump_bin = jump_command_to_bin(jump_command)
return compute_bin+destination_bin+jump_bin
def compute_command_to_bin(compute_command):
if "*" in compute_command:
return mul_command_to_bin(compute_command)
elif ">>" in compute_command or "<<" in compute_command:
return shift_command_to_bin(compute_command)
elif "M" in compute_command:
return m_command_to_bin(compute_command)
else:
return a_command_to_bin(compute_command)
def mul_command_to_bin(compute_command):
if compute_command == "D*A":
return "1000000000"
elif compute_command == "D*M":
return "1001000000"
def shift_command_to_bin(compute_command):
if compute_command == "D<<":
return "1010110000"
elif compute_command == "A<<":
return "1010100000"
elif compute_command == "M<<":
return "1011100000"
elif compute_command == "D>>":
return "1010010000"
elif compute_command == "A>>":
return "1010000000"
elif compute_command == "M>>":
return "1011000000"
def m_command_to_bin(compute_command):
prefix = "1111"
# replacing the M in the M command to an A,
# this way we can use the A command func
compute_command = compute_command.replace("M", "A")
return a_command_to_bin(compute_command, prefix)
def a_command_to_bin(compute_command, prefix="1110"):
# shared A and M commands
if compute_command == "A":
suffix = "110000"
elif compute_command == "!A":
suffix = "110001"
elif compute_command == "-A":
suffix = "110011"
elif compute_command == "A+1":
suffix = "110111"
elif compute_command == "A-1":
suffix = "110010"
elif compute_command == "D+A":
suffix = "000010"
elif compute_command == "D-A":
suffix = "010011"
elif compute_command == "A-D":
suffix = "000111"
elif compute_command == "D&A":
suffix = "000000"
elif compute_command == "D|A":
|
# A only commands
elif compute_command == "0":
suffix = "101010"
elif compute_command == "1":
suffix = "111111"
elif compute_command == "-1":
suffix = "111010"
elif compute_command == "D":
suffix = "001100"
elif compute_command == "!D":
suffix = "001101"
elif compute_command == "-D":
suffix = "001111"
elif compute_command == "D+1":
suffix = "011111"
elif compute_command == "D-1":
suffix = "001110"
return prefix+suffix
def destination_command_to_bin(destination_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if "M" in destination_command:
right_bit = "1"
if "D" in destination_command:
middle_bit = "1"
if "A" in destination_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def jump_command_to_bin(jump_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if jump_command == "JMP":
return "111"
if jump_command == "JNE":
return "101"
if "G" in jump_command:
right_bit = "1"
if "E" in jump_command:
middle_bit = "1"
if "L" in jump_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def translate_to_binary(command):
"""
A function that translates a number into binary, and formatting it to fit
the machine code language word length (16 bit)
:param command: an integer to transform into hack binary
:return: hack binary code
"""
int_command = int(command)
binary_command = bin(int_command)[2:]
missing_bits = CMD_LEN - len(binary_command)
cmd_prefix = missing_bits * str(0)
binary_command = str(cmd_prefix) + str(binary_command)
return binary_command + "\n"
def translate_a_command(marker_dictionary, cmd):
"""
A function that gets a assembly command and translated it into machine
code, using a supplied marker dictionary.
This function is designed to update the supplied marker dictionary.
:param marker_dictionary: a dictionary of pointers
:param cmd: an assembly command line
:return: the machine code binary respective to the supplied assembly line
"""
if cmd.isdigit():
return translate_to_binary(cmd)
else:
if cmd in marker_dictionary:
return translate_to_binary(marker_dictionary[cmd])
else:
global numOfVariables
marker_dictionary[cmd] = VAR_FIRST_MEM + numOfVariables
numOfVariables += 1
return translate_to_binary(VAR_FIRST_MEM + numOfVariables - 1)
def write_cmd(hack_file, marker_dictionary, cmd):
"""
This function writes a translated assembly name as hack machine code into
the supplied .hack file. The function uses helper functions to translate
code according to the type of code.
:param hack_file: a .hack file (destination for hack machine code)
:param marker_dictionary: a dictionary of pointers
:param cmd: a command to translate and write into hack_file
:return: None.
"""
if cmd[0] == '@':
hack_file.write(translate_a_command(marker_dictionary, cmd[1:]))
else:
hack_file.write(translate_c_command(cmd) + "\n")
def load_constants():
"""
A function that creates a dictionary containing all the hack assembly
constants and their respective binary values, including I/O and reserved
RAM locations
:return: the created dictionary
"""
marker_dictionary = dict()
marker_dictionary["SP"] = SP
marker_dictionary["LCL"] = LCL
marker_dictionary["ARG"] = ARG
marker_dictionary["THIS"] = THIS
marker_dictionary["THAT"] = THAT
marker_dictionary["SCREEN"] = SCREEN
marker_dictionary["KBD"] = KBD
for i in range(0, RAM_RESERVE_END):
marker_dictionary["R"+str(i)] = i
return marker_dictionary
def pre_process_asm_file(assembly_file):
"""
This function process an assembly file before it's translation to machine
code. It creates a dictionary, and places into it all markers in the code,
and assigns each one of them it's location in code, allowing to use it as
a reference in future. While doing so, it deletes each marker's
declaration.
The function also clears all whitespaces and comments from the code.
Any line which is not a comment, empty, or a marker declaration is
inserted to a list of ordered commands, later used for creating a hack
machine code binary.
:param assembly_file: an .asm file
:return: the created dictionary and commands list.
"""
line_counter = 0
marker_dictionary = load_constants()
commands_list = list()
for command in assembly_file.readlines():
command = command.split("/")[0] # getting rid of comments
command = "".join(command.split()) # getting rid of whitespaces
if command:
if command.startswith('('):
marker_dictionary[command[1:-1]] = line_counter
continue
commands_list.append(command)
line_counter += 1
return commands_list, marker_dictionary
def assemble_file(assembly_file_name, hack_file_name):
"""
A function that receives names of an .asm file and a .hack file.
The function will create the specified .hack file, and using helper
functions will | suffix = "010101" | conditional_block |
Assembler.py | each translation process.
numOfVariables = 0
def translate_c_command(command):
command_array = command.split("=")
if len(command_array) == 1: # no destination
command_and_jump_array = command_array[0].split(";")
destination_command = ""
else: # if length = 2
destination_command = command_array[0]
command_and_jump_array = command_array[1].split(";")
if len(command_and_jump_array) == 1: # no jump
jump_command = ""
compute_command = command_and_jump_array[0]
else: # if length = 2
compute_command = command_and_jump_array[0]
jump_command = command_and_jump_array[1]
compute_bin = compute_command_to_bin(compute_command)
destination_bin = destination_command_to_bin(destination_command)
jump_bin = jump_command_to_bin(jump_command)
return compute_bin+destination_bin+jump_bin
def compute_command_to_bin(compute_command):
if "*" in compute_command:
return mul_command_to_bin(compute_command)
elif ">>" in compute_command or "<<" in compute_command:
return shift_command_to_bin(compute_command)
elif "M" in compute_command:
return m_command_to_bin(compute_command)
else:
return a_command_to_bin(compute_command)
def mul_command_to_bin(compute_command):
if compute_command == "D*A":
return "1000000000"
elif compute_command == "D*M":
return "1001000000"
def shift_command_to_bin(compute_command):
if compute_command == "D<<":
return "1010110000"
elif compute_command == "A<<":
return "1010100000"
elif compute_command == "M<<":
return "1011100000"
elif compute_command == "D>>":
return "1010010000"
elif compute_command == "A>>":
return "1010000000"
elif compute_command == "M>>":
return "1011000000"
def m_command_to_bin(compute_command):
prefix = "1111"
# replacing the M in the M command to an A,
# this way we can use the A command func
compute_command = compute_command.replace("M", "A")
return a_command_to_bin(compute_command, prefix)
def a_command_to_bin(compute_command, prefix="1110"):
# shared A and M commands
if compute_command == "A":
suffix = "110000"
elif compute_command == "!A":
suffix = "110001"
elif compute_command == "-A":
suffix = "110011"
elif compute_command == "A+1":
suffix = "110111"
elif compute_command == "A-1":
suffix = "110010"
elif compute_command == "D+A":
suffix = "000010"
elif compute_command == "D-A":
suffix = "010011"
elif compute_command == "A-D":
suffix = "000111"
elif compute_command == "D&A":
suffix = "000000"
elif compute_command == "D|A":
suffix = "010101"
# A only commands
elif compute_command == "0":
suffix = "101010"
elif compute_command == "1":
suffix = "111111"
elif compute_command == "-1":
suffix = "111010"
elif compute_command == "D":
suffix = "001100"
elif compute_command == "!D":
suffix = "001101"
elif compute_command == "-D":
suffix = "001111"
elif compute_command == "D+1":
suffix = "011111"
elif compute_command == "D-1":
suffix = "001110"
return prefix+suffix
def destination_command_to_bin(destination_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if "M" in destination_command:
right_bit = "1"
if "D" in destination_command:
middle_bit = "1"
if "A" in destination_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def jump_command_to_bin(jump_command):
left_bit, middle_bit, right_bit = "0", "0", "0"
if jump_command == "JMP":
return "111"
if jump_command == "JNE":
return "101"
if "G" in jump_command:
right_bit = "1"
if "E" in jump_command:
middle_bit = "1"
if "L" in jump_command:
left_bit = "1"
return left_bit + middle_bit + right_bit
def translate_to_binary(command):
"""
A function that translates a number into binary, and formatting it to fit
the machine code language word length (16 bit)
:param command: an integer to transform into hack binary
:return: hack binary code
"""
int_command = int(command)
binary_command = bin(int_command)[2:]
missing_bits = CMD_LEN - len(binary_command)
cmd_prefix = missing_bits * str(0)
binary_command = str(cmd_prefix) + str(binary_command)
return binary_command + "\n"
def translate_a_command(marker_dictionary, cmd):
"""
A function that gets a assembly command and translated it into machine
code, using a supplied marker dictionary.
This function is designed to update the supplied marker dictionary.
:param marker_dictionary: a dictionary of pointers
:param cmd: an assembly command line
:return: the machine code binary respective to the supplied assembly line
"""
if cmd.isdigit():
return translate_to_binary(cmd)
else:
if cmd in marker_dictionary:
return translate_to_binary(marker_dictionary[cmd])
else:
global numOfVariables
marker_dictionary[cmd] = VAR_FIRST_MEM + numOfVariables
numOfVariables += 1
return translate_to_binary(VAR_FIRST_MEM + numOfVariables - 1)
def | (hack_file, marker_dictionary, cmd):
"""
This function writes a translated assembly name as hack machine code into
the supplied .hack file. The function uses helper functions to translate
code according to the type of code.
:param hack_file: a .hack file (destination for hack machine code)
:param marker_dictionary: a dictionary of pointers
:param cmd: a command to translate and write into hack_file
:return: None.
"""
if cmd[0] == '@':
hack_file.write(translate_a_command(marker_dictionary, cmd[1:]))
else:
hack_file.write(translate_c_command(cmd) + "\n")
def load_constants():
"""
A function that creates a dictionary containing all the hack assembly
constants and their respective binary values, including I/O and reserved
RAM locations
:return: the created dictionary
"""
marker_dictionary = dict()
marker_dictionary["SP"] = SP
marker_dictionary["LCL"] = LCL
marker_dictionary["ARG"] = ARG
marker_dictionary["THIS"] = THIS
marker_dictionary["THAT"] = THAT
marker_dictionary["SCREEN"] = SCREEN
marker_dictionary["KBD"] = KBD
for i in range(0, RAM_RESERVE_END):
marker_dictionary["R"+str(i)] = i
return marker_dictionary
def pre_process_asm_file(assembly_file):
"""
This function process an assembly file before it's translation to machine
code. It creates a dictionary, and places into it all markers in the code,
and assigns each one of them it's location in code, allowing to use it as
a reference in future. While doing so, it deletes each marker's
declaration.
The function also clears all whitespaces and comments from the code.
Any line which is not a comment, empty, or a marker declaration is
inserted to a list of ordered commands, later used for creating a hack
machine code binary.
:param assembly_file: an .asm file
:return: the created dictionary and commands list.
"""
line_counter = 0
marker_dictionary = load_constants()
commands_list = list()
for command in assembly_file.readlines():
command = command.split("/")[0] # getting rid of comments
command = "".join(command.split()) # getting rid of whitespaces
if command:
if command.startswith('('):
marker_dictionary[command[1:-1]] = line_counter
continue
commands_list.append(command)
line_counter += 1
return commands_list, marker_dictionary
def assemble_file(assembly_file_name, hack_file_name):
"""
A function that receives names of an .asm file and a .hack file.
The function will create the specified .hack file, and using helper
functions will | write_cmd | identifier_name |
unqfy.js | ArtistNotFound')
const { Artist, Album, Track, User, Playlist, Listening } = require('./entities/all') // esto hace falta para el framework de persistencia
const {ArtistCreation, TrackCreation, UserCreation} = require('./entities-creation/all') // Method objects
const PlaylistGenerator = require('./PlaylistGenerator.js')
const EntitiesRepository = require('./entities-repositories/EntitiesRepository')
class UNQfy {
constructor(
entitiesRepository = new EntitiesRepository(),
listOfObserbers
)
{
this._entitiesRepository = entitiesRepository
this._nextId = 1
this.lyricsProvider = new LyricFinder();
this.artistObs = new artistObserver();
this.albumObs = new albumObserver();
this.trackObs = new trackObserver();
}
_generateUniqueId() { return this._nextId++ }
get playlists() { return this._entitiesRepository.playlists }
get artists() { return this._entitiesRepository.artists }
get albums() { return this._entitiesRepository.albums }
get tracks() { return this._entitiesRepository.tracks }
get | () { return this._nextId }
/////////////////////
addUser({name, email}) {
const newUser = new UserCreation(this, {name, email}).handle()
this._entitiesRepository.add('user', newUser)
return newUser
}
verifyId(id){
return this._nextId >= id
}
registerListening(userId, trackId) {
const user = this.getUserById(userId)
const track = this.getTrackById(trackId)
const album = this._getAlbumContaining(track)
const artist = this._getAuthorOfAlbum(album)
const newListening = new Listening({listener: user, artist, album, track})
user.addToHistory(newListening)
artist.registerOthersListeningsOfHisArt(newListening)
}
_getAlbumContaining(aTrack) {
return this._entitiesRepository.find('album', album => album.hasTrack(aTrack))
}
createPlaylistFor(userId, playlistName, genresToInclude, maxDuration) {
const newPlaylist = this.createPlaylist(playlistName, genresToInclude, maxDuration)
const user = this.getUserById(userId)
user.registerPlaylist(newPlaylist)
return newPlaylist
}
/* ARTIST */
addArtist({name, country}) {
const newArtist = new ArtistCreation(this, {name, country}).handle()
this._entitiesRepository.add('artist', newArtist);
this.artistObs.update(newArtist.name);
return newArtist
}
removeArtist(artistId) {
const artist = this.getArtistById(artistId)
this._removeFromAllPlaylists(artist.allTracks)
this._entitiesRepository.removeBy('artist' , {prop: 'id', value: artistId})
}
existsArtistWithId(id) {
return this._entitiesRepository.someHas('artist', {prop: 'id', value: id})
}
existsArtistWithName(name){
return this._entitiesRepository.someHas('artist', {prop: 'name', value: name})
}
existSomeoneCalled(aName) {
return this._entitiesRepository.someHas('artist', {prop: 'name', value: aName}) ||
this._entitiesRepository.someHas('user' , {prop: 'name', value: aName})
}
/* ALBUM */
addAlbum(artistId, {name, year}) {
const newAlbum = new Album({ id: this._generateUniqueId(), ...{name, year} })
const artist = this.getArtistById(artistId)
artist.addAlbumByForce(newAlbum);
this.albumObs.update(artist.id, artist.name, newAlbum.name)
return newAlbum
}
verifyAlbum(artistId, name){
return this.getArtistById(artistId);
}
removeAlbum(albumId) {
const album = this.getAlbumById(albumId)
const artist = this._getAuthorOfAlbum(album)
this._removeFromAllPlaylists(album.tracks)
artist.removeAlbum(album)
}
/* TRACK */
addTrack(albumId, {name, duration, genres}) {
const lyricsProvider = this.lyricsProvider;
const newTrack = new TrackCreation(this, {name, duration, genres, lyricsProvider}).handle()
const album = this.getAlbumById(albumId);
const artist = this._getAuthorOfAlbum(album);
artist.addTrackTo(album, newTrack);
this.trackObs.update(album.name, newTrack.name)
return newTrack
}
removeTrack(trackId) {
const track = this.getTrackById(trackId)
const artist = this.getAuthorOfTrack(track)
this._removeFromAllPlaylists([track])
artist.removeTrack(track)
}
/* PLAYLIST */
createPlaylist(name, genresToInclude, maxDuration) {
const newPlaylist = new PlaylistGenerator().generate(this._generateUniqueId(), name, genresToInclude, maxDuration, this.tracks)
this._entitiesRepository.add('playlist', newPlaylist)
return newPlaylist
}
removePlaylist(playlistId) {
this._entitiesRepository.removeBy('playlist', {prop: 'id', value: playlistId})
}
_removeFromAllPlaylists(tracks) {
this._entitiesRepository.forEach('playlist', playlist => playlist.removeAll(tracks))
}
/** BUSQUEDAS **/
searchByName(aName) {return this._entitiesRepository.filterAll(entity => new RegExp(`\\b${aName}\\b`, 'i').test(entity.name))}
searchByNamePartial(aPartialName) { return this._entitiesRepository.filterAll(entity => new RegExp(aPartialName, 'i').test(entity.name)) }
getArtistById(id) { return this._entitiesRepository.findBy('artist' , {prop: 'id', value: id}) }
getAlbumById(id) { return this._entitiesRepository.findBy('album' , {prop: 'id', value: id}) }
getTrackById(id) { return this._entitiesRepository.findBy('track' , {prop: 'id', value: id}) }
getPlaylistById(id) { return this._entitiesRepository.findBy('playlist', {prop: 'id', value: id}) }
getUserById(id) { return this._entitiesRepository.findBy('user' , {prop: 'id', value: id}) }
getArtistByName(aName) { return this._entitiesRepository.findBy('artist', { prop: 'name', value: aName }) }
getUserByName(aName) { return this._entitiesRepository.findBy('user', { prop: 'name', value: aName }) }
getUserByEmail(aEmail) { return this._entitiesRepository.findBy('user', { prop: 'email', value: aEmail }) }
getTracksMatchingGenres(genres) {
return this._entitiesRepository.filter('track', track => track.matchSomeGenreFrom(genres))
}
getTracksMatchingArtist(artist) {
return artist.allTracks
}
getTracksMatchingArtistName(artistName) {
return this.getArtistByName(artistName).allTracks
}
_getAuthorOfAlbum(anAlbum) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfAlbum(anAlbum))
}
isAuthorOfAlbum(id, name){
const artist = this.getArtistById(id)
const album = this.searchByName(name).albums[0]
return artist.isTheAuthorOfAlbum(album)
}
getAuthorOfTrack(aTrack) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfTrack(aTrack))
}
findBy(entityName, {prop, value}) {
return this._entitiesRepository.findBy(entityName, {prop, value})
}
filterAllBy({prop, value}) {
return this._entitiesRepository.filterAllBy({prop, value})}
getPlaylistByQuery(query){
const durationLT = query.durationLT === undefined
const durationGT = query.durationGT === undefined
const name = query.name === undefined
var playlist = this.playlists.filter(playlist =>
((durationLT)||(playlist.duration <= query.durationLT))
&&((durationGT)||(playlist.duration >= query.durationGT))
&&(( name )||(new RegExp(query.name, 'i').test(playlist.name))))
return playlist
}
/** PERSISTENCIA **/
save(filename) {
const listenersBkp = this.listeners
this.listeners = []
const serializedData = picklify.picklify(this)
this.listeners = listenersBkp
fs.writeFileSync(filename, JSON.stringify(serializedData, null, 2))
}
load(filename) {
const serializedData = fs.readFileSync(filename, {encoding: 'utf-8'})
//COMPLETAR POR EL ALUMNO: Agregar a la lista todas las clases que necesitan ser instanciadas
const classes = [UNQfy, Artist, Album, Track, Playlist, EntitiesRepository, LyricFinder];
return picklify.unpicklify(JSON.parse(serializedData), classes)
}
/* VISADO 2 */
getAlbumsForArtist(artistName) {
if(this.existsArtistWithName(artistName)){
this.populateAlbumsForArtist(artistName);
//return this.getArtistByName(artistName).albums
}else{
throw new ArtistNotFound(artistName)
}
}
updateArtist(artistId, artistData) {
const artist = this.getArtistById(artistId)
artist.update(artistData)
| id | identifier_name |
unqfy.js | ArtistNotFound')
const { Artist, Album, Track, User, Playlist, Listening } = require('./entities/all') // esto hace falta para el framework de persistencia
const {ArtistCreation, TrackCreation, UserCreation} = require('./entities-creation/all') // Method objects
const PlaylistGenerator = require('./PlaylistGenerator.js')
const EntitiesRepository = require('./entities-repositories/EntitiesRepository')
class UNQfy {
constructor(
entitiesRepository = new EntitiesRepository(),
listOfObserbers
)
{
this._entitiesRepository = entitiesRepository
this._nextId = 1
this.lyricsProvider = new LyricFinder();
this.artistObs = new artistObserver();
this.albumObs = new albumObserver();
this.trackObs = new trackObserver();
}
_generateUniqueId() { return this._nextId++ }
get playlists() { return this._entitiesRepository.playlists }
get artists() { return this._entitiesRepository.artists }
get albums() { return this._entitiesRepository.albums }
get tracks() { return this._entitiesRepository.tracks }
get id() { return this._nextId }
/////////////////////
addUser({name, email}) {
const newUser = new UserCreation(this, {name, email}).handle()
this._entitiesRepository.add('user', newUser)
return newUser
}
verifyId(id){
return this._nextId >= id
}
registerListening(userId, trackId) {
const user = this.getUserById(userId)
const track = this.getTrackById(trackId)
const album = this._getAlbumContaining(track)
const artist = this._getAuthorOfAlbum(album)
const newListening = new Listening({listener: user, artist, album, track})
user.addToHistory(newListening)
artist.registerOthersListeningsOfHisArt(newListening)
}
_getAlbumContaining(aTrack) {
return this._entitiesRepository.find('album', album => album.hasTrack(aTrack))
}
createPlaylistFor(userId, playlistName, genresToInclude, maxDuration) {
const newPlaylist = this.createPlaylist(playlistName, genresToInclude, maxDuration)
const user = this.getUserById(userId)
user.registerPlaylist(newPlaylist)
return newPlaylist
}
/* ARTIST */
addArtist({name, country}) {
const newArtist = new ArtistCreation(this, {name, country}).handle()
this._entitiesRepository.add('artist', newArtist);
this.artistObs.update(newArtist.name);
return newArtist
}
removeArtist(artistId) {
const artist = this.getArtistById(artistId)
this._removeFromAllPlaylists(artist.allTracks)
this._entitiesRepository.removeBy('artist' , {prop: 'id', value: artistId})
}
existsArtistWithId(id) {
return this._entitiesRepository.someHas('artist', {prop: 'id', value: id})
}
existsArtistWithName(name){
return this._entitiesRepository.someHas('artist', {prop: 'name', value: name})
}
existSomeoneCalled(aName) {
return this._entitiesRepository.someHas('artist', {prop: 'name', value: aName}) ||
this._entitiesRepository.someHas('user' , {prop: 'name', value: aName})
}
/* ALBUM */
addAlbum(artistId, {name, year}) {
const newAlbum = new Album({ id: this._generateUniqueId(), ...{name, year} })
const artist = this.getArtistById(artistId)
artist.addAlbumByForce(newAlbum);
this.albumObs.update(artist.id, artist.name, newAlbum.name)
return newAlbum
}
verifyAlbum(artistId, name){
return this.getArtistById(artistId);
}
removeAlbum(albumId) {
const album = this.getAlbumById(albumId)
const artist = this._getAuthorOfAlbum(album)
this._removeFromAllPlaylists(album.tracks)
artist.removeAlbum(album)
}
/* TRACK */
addTrack(albumId, {name, duration, genres}) {
const lyricsProvider = this.lyricsProvider;
const newTrack = new TrackCreation(this, {name, duration, genres, lyricsProvider}).handle()
const album = this.getAlbumById(albumId);
const artist = this._getAuthorOfAlbum(album);
artist.addTrackTo(album, newTrack);
this.trackObs.update(album.name, newTrack.name)
return newTrack
}
removeTrack(trackId) {
const track = this.getTrackById(trackId)
const artist = this.getAuthorOfTrack(track)
this._removeFromAllPlaylists([track])
artist.removeTrack(track)
}
/* PLAYLIST */
createPlaylist(name, genresToInclude, maxDuration) {
const newPlaylist = new PlaylistGenerator().generate(this._generateUniqueId(), name, genresToInclude, maxDuration, this.tracks)
this._entitiesRepository.add('playlist', newPlaylist)
return newPlaylist
}
removePlaylist(playlistId) {
this._entitiesRepository.removeBy('playlist', {prop: 'id', value: playlistId})
}
_removeFromAllPlaylists(tracks) {
this._entitiesRepository.forEach('playlist', playlist => playlist.removeAll(tracks))
}
/** BUSQUEDAS **/
searchByName(aName) {return this._entitiesRepository.filterAll(entity => new RegExp(`\\b${aName}\\b`, 'i').test(entity.name))}
searchByNamePartial(aPartialName) { return this._entitiesRepository.filterAll(entity => new RegExp(aPartialName, 'i').test(entity.name)) }
getArtistById(id) { return this._entitiesRepository.findBy('artist' , {prop: 'id', value: id}) }
getAlbumById(id) { return this._entitiesRepository.findBy('album' , {prop: 'id', value: id}) }
getTrackById(id) |
getPlaylistById(id) { return this._entitiesRepository.findBy('playlist', {prop: 'id', value: id}) }
getUserById(id) { return this._entitiesRepository.findBy('user' , {prop: 'id', value: id}) }
getArtistByName(aName) { return this._entitiesRepository.findBy('artist', { prop: 'name', value: aName }) }
getUserByName(aName) { return this._entitiesRepository.findBy('user', { prop: 'name', value: aName }) }
getUserByEmail(aEmail) { return this._entitiesRepository.findBy('user', { prop: 'email', value: aEmail }) }
getTracksMatchingGenres(genres) {
return this._entitiesRepository.filter('track', track => track.matchSomeGenreFrom(genres))
}
getTracksMatchingArtist(artist) {
return artist.allTracks
}
getTracksMatchingArtistName(artistName) {
return this.getArtistByName(artistName).allTracks
}
_getAuthorOfAlbum(anAlbum) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfAlbum(anAlbum))
}
isAuthorOfAlbum(id, name){
const artist = this.getArtistById(id)
const album = this.searchByName(name).albums[0]
return artist.isTheAuthorOfAlbum(album)
}
getAuthorOfTrack(aTrack) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfTrack(aTrack))
}
findBy(entityName, {prop, value}) {
return this._entitiesRepository.findBy(entityName, {prop, value})
}
filterAllBy({prop, value}) {
return this._entitiesRepository.filterAllBy({prop, value})}
getPlaylistByQuery(query){
const durationLT = query.durationLT === undefined
const durationGT = query.durationGT === undefined
const name = query.name === undefined
var playlist = this.playlists.filter(playlist =>
((durationLT)||(playlist.duration <= query.durationLT))
&&((durationGT)||(playlist.duration >= query.durationGT))
&&(( name )||(new RegExp(query.name, 'i').test(playlist.name))))
return playlist
}
/** PERSISTENCIA **/
save(filename) {
const listenersBkp = this.listeners
this.listeners = []
const serializedData = picklify.picklify(this)
this.listeners = listenersBkp
fs.writeFileSync(filename, JSON.stringify(serializedData, null, 2))
}
load(filename) {
const serializedData = fs.readFileSync(filename, {encoding: 'utf-8'})
//COMPLETAR POR EL ALUMNO: Agregar a la lista todas las clases que necesitan ser instanciadas
const classes = [UNQfy, Artist, Album, Track, Playlist, EntitiesRepository, LyricFinder];
return picklify.unpicklify(JSON.parse(serializedData), classes)
}
/* VISADO 2 */
getAlbumsForArtist(artistName) {
if(this.existsArtistWithName(artistName)){
this.populateAlbumsForArtist(artistName);
//return this.getArtistByName(artistName).albums
}else{
throw new ArtistNotFound(artistName)
}
}
updateArtist(artistId, artistData) {
const artist = this.getArtistById(artistId)
artist.update(artistData)
| { return this._entitiesRepository.findBy('track' , {prop: 'id', value: id}) } | identifier_body |
unqfy.js | /ArtistNotFound')
const { Artist, Album, Track, User, Playlist, Listening } = require('./entities/all') // esto hace falta para el framework de persistencia
const {ArtistCreation, TrackCreation, UserCreation} = require('./entities-creation/all') // Method objects
const PlaylistGenerator = require('./PlaylistGenerator.js')
const EntitiesRepository = require('./entities-repositories/EntitiesRepository')
class UNQfy {
constructor(
entitiesRepository = new EntitiesRepository(),
listOfObserbers
)
{
this._entitiesRepository = entitiesRepository
this._nextId = 1
this.lyricsProvider = new LyricFinder();
this.artistObs = new artistObserver();
this.albumObs = new albumObserver();
this.trackObs = new trackObserver();
}
_generateUniqueId() { return this._nextId++ }
get playlists() { return this._entitiesRepository.playlists }
get artists() { return this._entitiesRepository.artists }
get albums() { return this._entitiesRepository.albums }
get tracks() { return this._entitiesRepository.tracks }
get id() { return this._nextId }
/////////////////////
addUser({name, email}) {
const newUser = new UserCreation(this, {name, email}).handle()
this._entitiesRepository.add('user', newUser)
return newUser
}
verifyId(id){
return this._nextId >= id
}
registerListening(userId, trackId) {
const user = this.getUserById(userId)
const track = this.getTrackById(trackId)
const album = this._getAlbumContaining(track)
const artist = this._getAuthorOfAlbum(album)
const newListening = new Listening({listener: user, artist, album, track})
user.addToHistory(newListening)
artist.registerOthersListeningsOfHisArt(newListening)
}
_getAlbumContaining(aTrack) {
return this._entitiesRepository.find('album', album => album.hasTrack(aTrack))
}
createPlaylistFor(userId, playlistName, genresToInclude, maxDuration) {
const newPlaylist = this.createPlaylist(playlistName, genresToInclude, maxDuration)
const user = this.getUserById(userId)
user.registerPlaylist(newPlaylist)
return newPlaylist
}
/* ARTIST */
addArtist({name, country}) {
const newArtist = new ArtistCreation(this, {name, country}).handle()
this._entitiesRepository.add('artist', newArtist);
this.artistObs.update(newArtist.name);
return newArtist
}
removeArtist(artistId) {
const artist = this.getArtistById(artistId)
this._removeFromAllPlaylists(artist.allTracks)
this._entitiesRepository.removeBy('artist' , {prop: 'id', value: artistId})
}
existsArtistWithId(id) {
return this._entitiesRepository.someHas('artist', {prop: 'id', value: id})
}
existsArtistWithName(name){
return this._entitiesRepository.someHas('artist', {prop: 'name', value: name})
}
existSomeoneCalled(aName) {
return this._entitiesRepository.someHas('artist', {prop: 'name', value: aName}) ||
this._entitiesRepository.someHas('user' , {prop: 'name', value: aName})
}
/* ALBUM */
addAlbum(artistId, {name, year}) {
const newAlbum = new Album({ id: this._generateUniqueId(), ...{name, year} })
const artist = this.getArtistById(artistId)
artist.addAlbumByForce(newAlbum);
this.albumObs.update(artist.id, artist.name, newAlbum.name)
return newAlbum
}
verifyAlbum(artistId, name){
return this.getArtistById(artistId);
}
| const artist = this._getAuthorOfAlbum(album)
this._removeFromAllPlaylists(album.tracks)
artist.removeAlbum(album)
}
/* TRACK */
addTrack(albumId, {name, duration, genres}) {
const lyricsProvider = this.lyricsProvider;
const newTrack = new TrackCreation(this, {name, duration, genres, lyricsProvider}).handle()
const album = this.getAlbumById(albumId);
const artist = this._getAuthorOfAlbum(album);
artist.addTrackTo(album, newTrack);
this.trackObs.update(album.name, newTrack.name)
return newTrack
}
removeTrack(trackId) {
const track = this.getTrackById(trackId)
const artist = this.getAuthorOfTrack(track)
this._removeFromAllPlaylists([track])
artist.removeTrack(track)
}
/* PLAYLIST */
createPlaylist(name, genresToInclude, maxDuration) {
const newPlaylist = new PlaylistGenerator().generate(this._generateUniqueId(), name, genresToInclude, maxDuration, this.tracks)
this._entitiesRepository.add('playlist', newPlaylist)
return newPlaylist
}
removePlaylist(playlistId) {
this._entitiesRepository.removeBy('playlist', {prop: 'id', value: playlistId})
}
_removeFromAllPlaylists(tracks) {
this._entitiesRepository.forEach('playlist', playlist => playlist.removeAll(tracks))
}
/** BUSQUEDAS **/
searchByName(aName) {return this._entitiesRepository.filterAll(entity => new RegExp(`\\b${aName}\\b`, 'i').test(entity.name))}
searchByNamePartial(aPartialName) { return this._entitiesRepository.filterAll(entity => new RegExp(aPartialName, 'i').test(entity.name)) }
getArtistById(id) { return this._entitiesRepository.findBy('artist' , {prop: 'id', value: id}) }
getAlbumById(id) { return this._entitiesRepository.findBy('album' , {prop: 'id', value: id}) }
getTrackById(id) { return this._entitiesRepository.findBy('track' , {prop: 'id', value: id}) }
getPlaylistById(id) { return this._entitiesRepository.findBy('playlist', {prop: 'id', value: id}) }
getUserById(id) { return this._entitiesRepository.findBy('user' , {prop: 'id', value: id}) }
getArtistByName(aName) { return this._entitiesRepository.findBy('artist', { prop: 'name', value: aName }) }
getUserByName(aName) { return this._entitiesRepository.findBy('user', { prop: 'name', value: aName }) }
getUserByEmail(aEmail) { return this._entitiesRepository.findBy('user', { prop: 'email', value: aEmail }) }
getTracksMatchingGenres(genres) {
return this._entitiesRepository.filter('track', track => track.matchSomeGenreFrom(genres))
}
getTracksMatchingArtist(artist) {
return artist.allTracks
}
getTracksMatchingArtistName(artistName) {
return this.getArtistByName(artistName).allTracks
}
_getAuthorOfAlbum(anAlbum) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfAlbum(anAlbum))
}
isAuthorOfAlbum(id, name){
const artist = this.getArtistById(id)
const album = this.searchByName(name).albums[0]
return artist.isTheAuthorOfAlbum(album)
}
getAuthorOfTrack(aTrack) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfTrack(aTrack))
}
findBy(entityName, {prop, value}) {
return this._entitiesRepository.findBy(entityName, {prop, value})
}
filterAllBy({prop, value}) {
return this._entitiesRepository.filterAllBy({prop, value})}
getPlaylistByQuery(query){
const durationLT = query.durationLT === undefined
const durationGT = query.durationGT === undefined
const name = query.name === undefined
var playlist = this.playlists.filter(playlist =>
((durationLT)||(playlist.duration <= query.durationLT))
&&((durationGT)||(playlist.duration >= query.durationGT))
&&(( name )||(new RegExp(query.name, 'i').test(playlist.name))))
return playlist
}
/** PERSISTENCIA **/
save(filename) {
const listenersBkp = this.listeners
this.listeners = []
const serializedData = picklify.picklify(this)
this.listeners = listenersBkp
fs.writeFileSync(filename, JSON.stringify(serializedData, null, 2))
}
load(filename) {
const serializedData = fs.readFileSync(filename, {encoding: 'utf-8'})
//COMPLETAR POR EL ALUMNO: Agregar a la lista todas las clases que necesitan ser instanciadas
const classes = [UNQfy, Artist, Album, Track, Playlist, EntitiesRepository, LyricFinder];
return picklify.unpicklify(JSON.parse(serializedData), classes)
}
/* VISADO 2 */
getAlbumsForArtist(artistName) {
if(this.existsArtistWithName(artistName)){
this.populateAlbumsForArtist(artistName);
//return this.getArtistByName(artistName).albums
}else{
throw new ArtistNotFound(artistName)
}
}
updateArtist(artistId, artistData) {
const artist = this.getArtistById(artistId)
artist.update(artistData)
| removeAlbum(albumId) {
const album = this.getAlbumById(albumId) | random_line_split |
unqfy.js | ArtistNotFound')
const { Artist, Album, Track, User, Playlist, Listening } = require('./entities/all') // esto hace falta para el framework de persistencia
const {ArtistCreation, TrackCreation, UserCreation} = require('./entities-creation/all') // Method objects
const PlaylistGenerator = require('./PlaylistGenerator.js')
const EntitiesRepository = require('./entities-repositories/EntitiesRepository')
class UNQfy {
constructor(
entitiesRepository = new EntitiesRepository(),
listOfObserbers
)
{
this._entitiesRepository = entitiesRepository
this._nextId = 1
this.lyricsProvider = new LyricFinder();
this.artistObs = new artistObserver();
this.albumObs = new albumObserver();
this.trackObs = new trackObserver();
}
_generateUniqueId() { return this._nextId++ }
get playlists() { return this._entitiesRepository.playlists }
get artists() { return this._entitiesRepository.artists }
get albums() { return this._entitiesRepository.albums }
get tracks() { return this._entitiesRepository.tracks }
get id() { return this._nextId }
/////////////////////
addUser({name, email}) {
const newUser = new UserCreation(this, {name, email}).handle()
this._entitiesRepository.add('user', newUser)
return newUser
}
verifyId(id){
return this._nextId >= id
}
registerListening(userId, trackId) {
const user = this.getUserById(userId)
const track = this.getTrackById(trackId)
const album = this._getAlbumContaining(track)
const artist = this._getAuthorOfAlbum(album)
const newListening = new Listening({listener: user, artist, album, track})
user.addToHistory(newListening)
artist.registerOthersListeningsOfHisArt(newListening)
}
_getAlbumContaining(aTrack) {
return this._entitiesRepository.find('album', album => album.hasTrack(aTrack))
}
createPlaylistFor(userId, playlistName, genresToInclude, maxDuration) {
const newPlaylist = this.createPlaylist(playlistName, genresToInclude, maxDuration)
const user = this.getUserById(userId)
user.registerPlaylist(newPlaylist)
return newPlaylist
}
/* ARTIST */
addArtist({name, country}) {
const newArtist = new ArtistCreation(this, {name, country}).handle()
this._entitiesRepository.add('artist', newArtist);
this.artistObs.update(newArtist.name);
return newArtist
}
removeArtist(artistId) {
const artist = this.getArtistById(artistId)
this._removeFromAllPlaylists(artist.allTracks)
this._entitiesRepository.removeBy('artist' , {prop: 'id', value: artistId})
}
existsArtistWithId(id) {
return this._entitiesRepository.someHas('artist', {prop: 'id', value: id})
}
existsArtistWithName(name){
return this._entitiesRepository.someHas('artist', {prop: 'name', value: name})
}
existSomeoneCalled(aName) {
return this._entitiesRepository.someHas('artist', {prop: 'name', value: aName}) ||
this._entitiesRepository.someHas('user' , {prop: 'name', value: aName})
}
/* ALBUM */
addAlbum(artistId, {name, year}) {
const newAlbum = new Album({ id: this._generateUniqueId(), ...{name, year} })
const artist = this.getArtistById(artistId)
artist.addAlbumByForce(newAlbum);
this.albumObs.update(artist.id, artist.name, newAlbum.name)
return newAlbum
}
verifyAlbum(artistId, name){
return this.getArtistById(artistId);
}
removeAlbum(albumId) {
const album = this.getAlbumById(albumId)
const artist = this._getAuthorOfAlbum(album)
this._removeFromAllPlaylists(album.tracks)
artist.removeAlbum(album)
}
/* TRACK */
addTrack(albumId, {name, duration, genres}) {
const lyricsProvider = this.lyricsProvider;
const newTrack = new TrackCreation(this, {name, duration, genres, lyricsProvider}).handle()
const album = this.getAlbumById(albumId);
const artist = this._getAuthorOfAlbum(album);
artist.addTrackTo(album, newTrack);
this.trackObs.update(album.name, newTrack.name)
return newTrack
}
removeTrack(trackId) {
const track = this.getTrackById(trackId)
const artist = this.getAuthorOfTrack(track)
this._removeFromAllPlaylists([track])
artist.removeTrack(track)
}
/* PLAYLIST */
createPlaylist(name, genresToInclude, maxDuration) {
const newPlaylist = new PlaylistGenerator().generate(this._generateUniqueId(), name, genresToInclude, maxDuration, this.tracks)
this._entitiesRepository.add('playlist', newPlaylist)
return newPlaylist
}
removePlaylist(playlistId) {
this._entitiesRepository.removeBy('playlist', {prop: 'id', value: playlistId})
}
_removeFromAllPlaylists(tracks) {
this._entitiesRepository.forEach('playlist', playlist => playlist.removeAll(tracks))
}
/** BUSQUEDAS **/
searchByName(aName) {return this._entitiesRepository.filterAll(entity => new RegExp(`\\b${aName}\\b`, 'i').test(entity.name))}
searchByNamePartial(aPartialName) { return this._entitiesRepository.filterAll(entity => new RegExp(aPartialName, 'i').test(entity.name)) }
getArtistById(id) { return this._entitiesRepository.findBy('artist' , {prop: 'id', value: id}) }
getAlbumById(id) { return this._entitiesRepository.findBy('album' , {prop: 'id', value: id}) }
getTrackById(id) { return this._entitiesRepository.findBy('track' , {prop: 'id', value: id}) }
getPlaylistById(id) { return this._entitiesRepository.findBy('playlist', {prop: 'id', value: id}) }
getUserById(id) { return this._entitiesRepository.findBy('user' , {prop: 'id', value: id}) }
getArtistByName(aName) { return this._entitiesRepository.findBy('artist', { prop: 'name', value: aName }) }
getUserByName(aName) { return this._entitiesRepository.findBy('user', { prop: 'name', value: aName }) }
getUserByEmail(aEmail) { return this._entitiesRepository.findBy('user', { prop: 'email', value: aEmail }) }
getTracksMatchingGenres(genres) {
return this._entitiesRepository.filter('track', track => track.matchSomeGenreFrom(genres))
}
getTracksMatchingArtist(artist) {
return artist.allTracks
}
getTracksMatchingArtistName(artistName) {
return this.getArtistByName(artistName).allTracks
}
_getAuthorOfAlbum(anAlbum) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfAlbum(anAlbum))
}
isAuthorOfAlbum(id, name){
const artist = this.getArtistById(id)
const album = this.searchByName(name).albums[0]
return artist.isTheAuthorOfAlbum(album)
}
getAuthorOfTrack(aTrack) {
return this._entitiesRepository.find('artist', artist => artist.isTheAuthorOfTrack(aTrack))
}
findBy(entityName, {prop, value}) {
return this._entitiesRepository.findBy(entityName, {prop, value})
}
filterAllBy({prop, value}) {
return this._entitiesRepository.filterAllBy({prop, value})}
getPlaylistByQuery(query){
const durationLT = query.durationLT === undefined
const durationGT = query.durationGT === undefined
const name = query.name === undefined
var playlist = this.playlists.filter(playlist =>
((durationLT)||(playlist.duration <= query.durationLT))
&&((durationGT)||(playlist.duration >= query.durationGT))
&&(( name )||(new RegExp(query.name, 'i').test(playlist.name))))
return playlist
}
/** PERSISTENCIA **/
save(filename) {
const listenersBkp = this.listeners
this.listeners = []
const serializedData = picklify.picklify(this)
this.listeners = listenersBkp
fs.writeFileSync(filename, JSON.stringify(serializedData, null, 2))
}
load(filename) {
const serializedData = fs.readFileSync(filename, {encoding: 'utf-8'})
//COMPLETAR POR EL ALUMNO: Agregar a la lista todas las clases que necesitan ser instanciadas
const classes = [UNQfy, Artist, Album, Track, Playlist, EntitiesRepository, LyricFinder];
return picklify.unpicklify(JSON.parse(serializedData), classes)
}
/* VISADO 2 */
getAlbumsForArtist(artistName) {
if(this.existsArtistWithName(artistName)){
this.populateAlbumsForArtist(artistName);
//return this.getArtistByName(artistName).albums
}else |
}
updateArtist(artistId, artistData) {
const artist = this.getArtistById(artistId)
artist.update(artistData)
| {
throw new ArtistNotFound(artistName)
} | conditional_block |
tag.rs | 0,
0,
pos_bytes[0],
pos_bytes[1],
]);
tag_fst_items.push((key, value));
}
}
}
tag_fst_items.sort_by(|(a, _), (b, _)| a.cmp(b));
let mut word_store_items: Vec<_> = tagger
.word_store
.iter()
.map(|(key, value)| (key.clone(), value.0 as u64))
.collect();
word_store_items.sort_by(|(a, _), (b, _)| a.cmp(b));
let tag_fst = Map::from_iter(tag_fst_items)
.unwrap()
.into_fst()
.as_bytes()
.to_vec();
let word_store_fst = Map::from_iter(word_store_items)
.unwrap()
.into_fst()
.as_bytes()
.to_vec();
TaggerFields {
tag_fst,
word_store_fst,
tag_store: tagger.tag_store,
}
}
}
impl From<TaggerFields> for Tagger {
fn from(data: TaggerFields) -> Self {
let word_store_fst = Map::new(data.word_store_fst).unwrap();
let word_store: BiMap<String, WordIdInt> = word_store_fst
.into_stream()
.into_str_vec()
.unwrap()
.into_iter()
.map(|(key, value)| (key, WordIdInt(value as u32)))
.collect();
let mut tags = DefaultHashMap::new();
let mut groups = DefaultHashMap::new();
let tag_fst = Map::new(data.tag_fst).unwrap();
let mut stream = tag_fst.into_stream();
while let Some((key, value)) = stream.next() {
let word = std::str::from_utf8(&key[..key.len() - 1]).unwrap();
let word_id = *word_store.get_by_left(word).unwrap();
let value_bytes = value.to_be_bytes();
let inflection_id = WordIdInt(u32::from_be_bytes([
value_bytes[0],
value_bytes[1],
value_bytes[2],
value_bytes[3],
]));
let pos_id = PosIdInt(u16::from_be_bytes([value_bytes[6], value_bytes[7]]));
let group = groups.entry(inflection_id).or_insert_with(Vec::new);
if !group.contains(&word_id) {
group.push(word_id);
}
tags.entry(word_id)
.or_insert_with(IndexMap::new)
.entry(inflection_id)
.or_insert_with(Vec::new)
.push(pos_id);
}
Tagger {
tags,
tag_store: data.tag_store,
word_store,
groups,
}
}
}
/// The lexical tagger.
#[derive(Default, Serialize, Deserialize, Clone)]
#[serde(from = "TaggerFields", into = "TaggerFields")]
pub struct Tagger {
tags: DefaultHashMap<WordIdInt, IndexMap<WordIdInt, Vec<PosIdInt>>>,
tag_store: BiMap<String, PosIdInt>,
word_store: BiMap<String, WordIdInt>,
groups: DefaultHashMap<WordIdInt, Vec<WordIdInt>>,
}
impl Tagger {
fn get_lines<S1: AsRef<Path>, S2: AsRef<Path>>(
paths: &[S1],
remove_paths: &[S2],
) -> std::io::Result<Vec<(String, String, String)>> {
let mut output = Vec::new();
let mut disallowed: Vec<String> = Vec::new();
for path in remove_paths {
let file = File::open(path.as_ref())?;
let reader = std::io::BufReader::new(file);
for line in reader.lines() {
let line = line?;
if line.starts_with('#') {
continue;
}
disallowed.push(line.to_string());
}
}
for path in paths {
let file = File::open(path.as_ref())?;
let reader = std::io::BufReader::new(file);
for line in reader.lines() {
let line = line?;
if line.starts_with('#') {
continue;
}
if disallowed.contains(&line) {
continue;
}
let parts: Vec<_> = line.split('\t').collect();
let word = parts[0].to_string();
let inflection = parts[1].to_string();
let tag = parts[2].to_string();
output.push((word, inflection, tag))
}
}
Ok(output)
}
/// Creates a tagger from raw files.
///
/// # Arguments
/// * `paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be added to the tagger.
/// * `remove_paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be removed from the tagger if present in the files from `paths`.
pub fn from_dumps<S1: AsRef<Path>, S2: AsRef<Path>, S3: AsRef<str>>(
paths: &[S1],
remove_paths: &[S2],
extra_tags: &[S3],
common_words: &HashSet<String>,
) -> std::io::Result<Self> {
let mut tags = DefaultHashMap::default();
let mut groups = DefaultHashMap::default();
let mut tag_store = HashSet::new();
let mut word_store = HashSet::new();
// hardcoded special tags
tag_store.insert("");
tag_store.insert("SENT_START");
tag_store.insert("SENT_END");
tag_store.insert("UNKNOWN");
// add language specific special tags
tag_store.extend(extra_tags.iter().map(|x| x.as_ref()));
let lines = Tagger::get_lines(paths, remove_paths)?;
let punct = "!\"#$%&\\'()*+,-./:;<=>?@[\\]^_`{|}~";
for i in 0..punct.len() {
word_store.insert(&punct[i..(i + 1)]);
}
word_store.extend(common_words.iter().map(|x| x.as_str()));
for (word, inflection, tag) in lines.iter() {
word_store.insert(word);
word_store.insert(inflection);
tag_store.insert(tag);
}
// word store ids should be consistent across runs
let mut word_store: Vec<_> = word_store.iter().collect();
word_store.sort();
// tag store ids should be consistent across runs
let mut tag_store: Vec<_> = tag_store.iter().collect();
tag_store.sort();
let word_store: BiMap<_, _> = word_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), WordIdInt(i as u32)))
.collect();
let tag_store: BiMap<_, _> = tag_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), PosIdInt(i as u16)))
.collect();
for (word, inflection, tag) in lines.iter() {
let word_id = word_store.get_by_left(word).unwrap();
let inflection_id = word_store.get_by_left(inflection).unwrap();
let pos_id = tag_store.get_by_left(tag).unwrap();
let group = groups.entry(*inflection_id).or_insert_with(Vec::new);
if !group.contains(word_id) {
group.push(*word_id);
}
tags.entry(*word_id)
.or_insert_with(IndexMap::new)
.entry(*inflection_id)
.or_insert_with(Vec::new)
.push(*pos_id);
}
Ok(Tagger {
tags,
groups,
word_store,
tag_store,
})
}
fn get_raw(&self, word: &str) -> Vec<WordData> {
if let Some(map) = self
.word_store
.get_by_left(word)
.and_then(|x| self.tags.get(x))
{
let mut output = Vec::new();
for (key, value) in map.iter() {
for pos_id in value {
output.push(WordData::new(
self.id_word(self.str_for_word_id(key).into()),
self.id_tag(self.str_for_pos_id(pos_id)),
))
}
}
output
} else {
Vec::new()
}
}
fn | (
&self,
word: &str,
add_lower: bool,
add_lower_if_empty: bool,
) -> Vec<WordData> {
let mut tags = self.get_raw(&word);
let lower = word.to_lowercase();
if (add_lower || (add_lower_if_empty && tags.is_empty()))
&& (word != lower
&& (crate::utils::is_title_case(word) || crate::utils::is_uppercase(word)))
{
tags.extend(self.get_raw(&lower));
}
tags
}
#[allow(dead_code)] // used by compile module
pub(crate) fn tag_store(&self) -> &BiMap<String, PosIdInt> {
&self.tag_store
}
#[allow(dead_code)] // used by compile module
| get_strict_tags | identifier_name |
tag.rs | PosIdInt>,
word_store: BiMap<String, WordIdInt>,
groups: DefaultHashMap<WordIdInt, Vec<WordIdInt>>,
}
impl Tagger {
fn get_lines<S1: AsRef<Path>, S2: AsRef<Path>>(
paths: &[S1],
remove_paths: &[S2],
) -> std::io::Result<Vec<(String, String, String)>> {
let mut output = Vec::new();
let mut disallowed: Vec<String> = Vec::new();
for path in remove_paths {
let file = File::open(path.as_ref())?;
let reader = std::io::BufReader::new(file);
for line in reader.lines() {
let line = line?;
if line.starts_with('#') {
continue;
}
disallowed.push(line.to_string());
}
}
for path in paths {
let file = File::open(path.as_ref())?;
let reader = std::io::BufReader::new(file);
for line in reader.lines() {
let line = line?;
if line.starts_with('#') {
continue;
}
if disallowed.contains(&line) {
continue;
}
let parts: Vec<_> = line.split('\t').collect();
let word = parts[0].to_string();
let inflection = parts[1].to_string();
let tag = parts[2].to_string();
output.push((word, inflection, tag))
}
}
Ok(output)
}
/// Creates a tagger from raw files.
///
/// # Arguments
/// * `paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be added to the tagger.
/// * `remove_paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be removed from the tagger if present in the files from `paths`.
pub fn from_dumps<S1: AsRef<Path>, S2: AsRef<Path>, S3: AsRef<str>>(
paths: &[S1],
remove_paths: &[S2],
extra_tags: &[S3],
common_words: &HashSet<String>,
) -> std::io::Result<Self> {
let mut tags = DefaultHashMap::default();
let mut groups = DefaultHashMap::default();
let mut tag_store = HashSet::new();
let mut word_store = HashSet::new();
// hardcoded special tags
tag_store.insert("");
tag_store.insert("SENT_START");
tag_store.insert("SENT_END");
tag_store.insert("UNKNOWN");
// add language specific special tags
tag_store.extend(extra_tags.iter().map(|x| x.as_ref()));
let lines = Tagger::get_lines(paths, remove_paths)?;
let punct = "!\"#$%&\\'()*+,-./:;<=>?@[\\]^_`{|}~";
for i in 0..punct.len() {
word_store.insert(&punct[i..(i + 1)]);
}
word_store.extend(common_words.iter().map(|x| x.as_str()));
for (word, inflection, tag) in lines.iter() {
word_store.insert(word);
word_store.insert(inflection);
tag_store.insert(tag);
}
// word store ids should be consistent across runs
let mut word_store: Vec<_> = word_store.iter().collect();
word_store.sort();
// tag store ids should be consistent across runs
let mut tag_store: Vec<_> = tag_store.iter().collect();
tag_store.sort();
let word_store: BiMap<_, _> = word_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), WordIdInt(i as u32)))
.collect();
let tag_store: BiMap<_, _> = tag_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), PosIdInt(i as u16)))
.collect();
for (word, inflection, tag) in lines.iter() {
let word_id = word_store.get_by_left(word).unwrap();
let inflection_id = word_store.get_by_left(inflection).unwrap();
let pos_id = tag_store.get_by_left(tag).unwrap();
let group = groups.entry(*inflection_id).or_insert_with(Vec::new);
if !group.contains(word_id) {
group.push(*word_id);
}
tags.entry(*word_id)
.or_insert_with(IndexMap::new)
.entry(*inflection_id)
.or_insert_with(Vec::new)
.push(*pos_id);
}
Ok(Tagger {
tags,
groups,
word_store,
tag_store,
})
}
fn get_raw(&self, word: &str) -> Vec<WordData> {
if let Some(map) = self
.word_store
.get_by_left(word)
.and_then(|x| self.tags.get(x))
{
let mut output = Vec::new();
for (key, value) in map.iter() {
for pos_id in value {
output.push(WordData::new(
self.id_word(self.str_for_word_id(key).into()),
self.id_tag(self.str_for_pos_id(pos_id)),
))
}
}
output
} else {
Vec::new()
}
}
fn get_strict_tags(
&self,
word: &str,
add_lower: bool,
add_lower_if_empty: bool,
) -> Vec<WordData> {
let mut tags = self.get_raw(&word);
let lower = word.to_lowercase();
if (add_lower || (add_lower_if_empty && tags.is_empty()))
&& (word != lower
&& (crate::utils::is_title_case(word) || crate::utils::is_uppercase(word)))
{
tags.extend(self.get_raw(&lower));
}
tags
}
#[allow(dead_code)] // used by compile module
pub(crate) fn tag_store(&self) -> &BiMap<String, PosIdInt> {
&self.tag_store
}
#[allow(dead_code)] // used by compile module
pub(crate) fn word_store(&self) -> &BiMap<String, WordIdInt> {
&self.word_store
}
fn str_for_word_id(&self, id: &WordIdInt) -> &str {
self.word_store
.get_by_right(id)
.expect("only valid word ids are created")
}
fn str_for_pos_id(&self, id: &PosIdInt) -> &str {
self.tag_store
.get_by_right(id)
.expect("only valid pos ids are created")
}
pub fn id_tag<'a>(&self, tag: &'a str) -> PosId<'a> {
PosId(
tag,
*self.tag_store.get_by_left(tag).unwrap_or_else(|| {
error!(
"'{}' not found in tag store, please add it to the `extra_tags`. Using UNKNOWN instead.",
tag
);
self.tag_store.get_by_left("UNKNOWN").expect("UNKNOWN tag must exist in tag store")
}),
)
}
pub fn id_word<'t>(&'t self, text: Cow<'t, str>) -> WordId<'t> {
let id = self.word_store.get_by_left(text.as_ref()).copied();
WordId(text, id)
}
/// Get the tags and lemmas (as [WordData][crate::types::WordData]) for the given word.
///
/// # Arguments
/// * `word`: The word to lookup data for.
/// * `add_lower`: Whether to add data for the lowercase variant of the word.
/// * `use_compound_split_heuristic`: Whether to use a heuristic to split compound words.
/// If true, will attempt to find tags for words which are longer than some cutoff and unknown by looking up tags
/// for substrings from left to right until tags are found or a minimum length reached.
pub fn get_tags(
&self,
word: &str,
add_lower: bool,
use_compound_split_heuristic: bool,
) -> Vec<WordData> {
let mut tags = self.get_strict_tags(word, add_lower, true);
// compound splitting heuristic, seems to work reasonably well
if use_compound_split_heuristic && tags.is_empty() {
let n_chars = word.chars().count() as isize;
if n_chars >= 7 | {
let indices = word
.char_indices()
.take(std::cmp::max(n_chars - 4, 0) as usize)
.skip(1)
.map(|x| x.0);
// the word always has at least one char if the above condition is satisfied
// but semantically this is false if no char exists
let starts_with_uppercase = word.chars().next().map_or(false, |x| x.is_uppercase());
for i in indices {
let next = if starts_with_uppercase {
crate::utils::apply_to_first(&word[i..], |c| c.to_uppercase().collect())
} else {
word[i..].to_string()
};
let next_tags = self.get_strict_tags(&next, add_lower, false);
if !next_tags.is_empty() { | conditional_block |
|
tag.rs | 0,
0,
pos_bytes[0],
pos_bytes[1],
]);
tag_fst_items.push((key, value));
}
}
}
tag_fst_items.sort_by(|(a, _), (b, _)| a.cmp(b));
let mut word_store_items: Vec<_> = tagger
.word_store
.iter()
.map(|(key, value)| (key.clone(), value.0 as u64))
.collect();
word_store_items.sort_by(|(a, _), (b, _)| a.cmp(b));
let tag_fst = Map::from_iter(tag_fst_items)
.unwrap()
.into_fst()
.as_bytes()
.to_vec();
let word_store_fst = Map::from_iter(word_store_items)
.unwrap()
.into_fst()
.as_bytes()
.to_vec();
TaggerFields {
tag_fst,
word_store_fst,
tag_store: tagger.tag_store,
}
}
}
impl From<TaggerFields> for Tagger {
fn from(data: TaggerFields) -> Self {
let word_store_fst = Map::new(data.word_store_fst).unwrap();
let word_store: BiMap<String, WordIdInt> = word_store_fst
.into_stream()
.into_str_vec()
.unwrap()
.into_iter()
.map(|(key, value)| (key, WordIdInt(value as u32)))
.collect();
let mut tags = DefaultHashMap::new();
let mut groups = DefaultHashMap::new();
let tag_fst = Map::new(data.tag_fst).unwrap();
let mut stream = tag_fst.into_stream();
while let Some((key, value)) = stream.next() {
let word = std::str::from_utf8(&key[..key.len() - 1]).unwrap();
let word_id = *word_store.get_by_left(word).unwrap();
let value_bytes = value.to_be_bytes();
let inflection_id = WordIdInt(u32::from_be_bytes([
value_bytes[0],
value_bytes[1],
value_bytes[2],
value_bytes[3],
]));
let pos_id = PosIdInt(u16::from_be_bytes([value_bytes[6], value_bytes[7]]));
let group = groups.entry(inflection_id).or_insert_with(Vec::new);
if !group.contains(&word_id) {
group.push(word_id);
}
tags.entry(word_id)
.or_insert_with(IndexMap::new)
.entry(inflection_id)
.or_insert_with(Vec::new)
.push(pos_id);
}
Tagger {
tags,
tag_store: data.tag_store,
word_store,
groups,
}
}
}
/// The lexical tagger.
#[derive(Default, Serialize, Deserialize, Clone)]
#[serde(from = "TaggerFields", into = "TaggerFields")]
pub struct Tagger {
tags: DefaultHashMap<WordIdInt, IndexMap<WordIdInt, Vec<PosIdInt>>>,
tag_store: BiMap<String, PosIdInt>,
word_store: BiMap<String, WordIdInt>,
groups: DefaultHashMap<WordIdInt, Vec<WordIdInt>>,
}
impl Tagger {
fn get_lines<S1: AsRef<Path>, S2: AsRef<Path>>(
paths: &[S1],
remove_paths: &[S2],
) -> std::io::Result<Vec<(String, String, String)>> {
let mut output = Vec::new();
let mut disallowed: Vec<String> = Vec::new();
for path in remove_paths {
let file = File::open(path.as_ref())?;
let reader = std::io::BufReader::new(file);
for line in reader.lines() {
let line = line?;
if line.starts_with('#') {
continue;
}
disallowed.push(line.to_string());
}
}
for path in paths {
let file = File::open(path.as_ref())?; | let reader = std::io::BufReader::new(file);
for line in reader.lines() {
let line = line?;
if line.starts_with('#') {
continue;
}
if disallowed.contains(&line) {
continue;
}
let parts: Vec<_> = line.split('\t').collect();
let word = parts[0].to_string();
let inflection = parts[1].to_string();
let tag = parts[2].to_string();
output.push((word, inflection, tag))
}
}
Ok(output)
}
/// Creates a tagger from raw files.
///
/// # Arguments
/// * `paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be added to the tagger.
/// * `remove_paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be removed from the tagger if present in the files from `paths`.
pub fn from_dumps<S1: AsRef<Path>, S2: AsRef<Path>, S3: AsRef<str>>(
paths: &[S1],
remove_paths: &[S2],
extra_tags: &[S3],
common_words: &HashSet<String>,
) -> std::io::Result<Self> {
let mut tags = DefaultHashMap::default();
let mut groups = DefaultHashMap::default();
let mut tag_store = HashSet::new();
let mut word_store = HashSet::new();
// hardcoded special tags
tag_store.insert("");
tag_store.insert("SENT_START");
tag_store.insert("SENT_END");
tag_store.insert("UNKNOWN");
// add language specific special tags
tag_store.extend(extra_tags.iter().map(|x| x.as_ref()));
let lines = Tagger::get_lines(paths, remove_paths)?;
let punct = "!\"#$%&\\'()*+,-./:;<=>?@[\\]^_`{|}~";
for i in 0..punct.len() {
word_store.insert(&punct[i..(i + 1)]);
}
word_store.extend(common_words.iter().map(|x| x.as_str()));
for (word, inflection, tag) in lines.iter() {
word_store.insert(word);
word_store.insert(inflection);
tag_store.insert(tag);
}
// word store ids should be consistent across runs
let mut word_store: Vec<_> = word_store.iter().collect();
word_store.sort();
// tag store ids should be consistent across runs
let mut tag_store: Vec<_> = tag_store.iter().collect();
tag_store.sort();
let word_store: BiMap<_, _> = word_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), WordIdInt(i as u32)))
.collect();
let tag_store: BiMap<_, _> = tag_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), PosIdInt(i as u16)))
.collect();
for (word, inflection, tag) in lines.iter() {
let word_id = word_store.get_by_left(word).unwrap();
let inflection_id = word_store.get_by_left(inflection).unwrap();
let pos_id = tag_store.get_by_left(tag).unwrap();
let group = groups.entry(*inflection_id).or_insert_with(Vec::new);
if !group.contains(word_id) {
group.push(*word_id);
}
tags.entry(*word_id)
.or_insert_with(IndexMap::new)
.entry(*inflection_id)
.or_insert_with(Vec::new)
.push(*pos_id);
}
Ok(Tagger {
tags,
groups,
word_store,
tag_store,
})
}
fn get_raw(&self, word: &str) -> Vec<WordData> {
if let Some(map) = self
.word_store
.get_by_left(word)
.and_then(|x| self.tags.get(x))
{
let mut output = Vec::new();
for (key, value) in map.iter() {
for pos_id in value {
output.push(WordData::new(
self.id_word(self.str_for_word_id(key).into()),
self.id_tag(self.str_for_pos_id(pos_id)),
))
}
}
output
} else {
Vec::new()
}
}
fn get_strict_tags(
&self,
word: &str,
add_lower: bool,
add_lower_if_empty: bool,
) -> Vec<WordData> {
let mut tags = self.get_raw(&word);
let lower = word.to_lowercase();
if (add_lower || (add_lower_if_empty && tags.is_empty()))
&& (word != lower
&& (crate::utils::is_title_case(word) || crate::utils::is_uppercase(word)))
{
tags.extend(self.get_raw(&lower));
}
tags
}
#[allow(dead_code)] // used by compile module
pub(crate) fn tag_store(&self) -> &BiMap<String, PosIdInt> {
&self.tag_store
}
#[allow(dead_code)] // used by compile module
| random_line_split |
|
tag.rs | }
disallowed.push(line.to_string());
}
}
for path in paths {
let file = File::open(path.as_ref())?;
let reader = std::io::BufReader::new(file);
for line in reader.lines() {
let line = line?;
if line.starts_with('#') {
continue;
}
if disallowed.contains(&line) {
continue;
}
let parts: Vec<_> = line.split('\t').collect();
let word = parts[0].to_string();
let inflection = parts[1].to_string();
let tag = parts[2].to_string();
output.push((word, inflection, tag))
}
}
Ok(output)
}
/// Creates a tagger from raw files.
///
/// # Arguments
/// * `paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be added to the tagger.
/// * `remove_paths`: Paths to files where each line contains the word, lemma and tag, respectively,
/// separated by tabs, to be removed from the tagger if present in the files from `paths`.
pub fn from_dumps<S1: AsRef<Path>, S2: AsRef<Path>, S3: AsRef<str>>(
paths: &[S1],
remove_paths: &[S2],
extra_tags: &[S3],
common_words: &HashSet<String>,
) -> std::io::Result<Self> {
let mut tags = DefaultHashMap::default();
let mut groups = DefaultHashMap::default();
let mut tag_store = HashSet::new();
let mut word_store = HashSet::new();
// hardcoded special tags
tag_store.insert("");
tag_store.insert("SENT_START");
tag_store.insert("SENT_END");
tag_store.insert("UNKNOWN");
// add language specific special tags
tag_store.extend(extra_tags.iter().map(|x| x.as_ref()));
let lines = Tagger::get_lines(paths, remove_paths)?;
let punct = "!\"#$%&\\'()*+,-./:;<=>?@[\\]^_`{|}~";
for i in 0..punct.len() {
word_store.insert(&punct[i..(i + 1)]);
}
word_store.extend(common_words.iter().map(|x| x.as_str()));
for (word, inflection, tag) in lines.iter() {
word_store.insert(word);
word_store.insert(inflection);
tag_store.insert(tag);
}
// word store ids should be consistent across runs
let mut word_store: Vec<_> = word_store.iter().collect();
word_store.sort();
// tag store ids should be consistent across runs
let mut tag_store: Vec<_> = tag_store.iter().collect();
tag_store.sort();
let word_store: BiMap<_, _> = word_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), WordIdInt(i as u32)))
.collect();
let tag_store: BiMap<_, _> = tag_store
.iter()
.enumerate()
.map(|(i, x)| (x.to_string(), PosIdInt(i as u16)))
.collect();
for (word, inflection, tag) in lines.iter() {
let word_id = word_store.get_by_left(word).unwrap();
let inflection_id = word_store.get_by_left(inflection).unwrap();
let pos_id = tag_store.get_by_left(tag).unwrap();
let group = groups.entry(*inflection_id).or_insert_with(Vec::new);
if !group.contains(word_id) {
group.push(*word_id);
}
tags.entry(*word_id)
.or_insert_with(IndexMap::new)
.entry(*inflection_id)
.or_insert_with(Vec::new)
.push(*pos_id);
}
Ok(Tagger {
tags,
groups,
word_store,
tag_store,
})
}
fn get_raw(&self, word: &str) -> Vec<WordData> {
if let Some(map) = self
.word_store
.get_by_left(word)
.and_then(|x| self.tags.get(x))
{
let mut output = Vec::new();
for (key, value) in map.iter() {
for pos_id in value {
output.push(WordData::new(
self.id_word(self.str_for_word_id(key).into()),
self.id_tag(self.str_for_pos_id(pos_id)),
))
}
}
output
} else {
Vec::new()
}
}
fn get_strict_tags(
&self,
word: &str,
add_lower: bool,
add_lower_if_empty: bool,
) -> Vec<WordData> {
let mut tags = self.get_raw(&word);
let lower = word.to_lowercase();
if (add_lower || (add_lower_if_empty && tags.is_empty()))
&& (word != lower
&& (crate::utils::is_title_case(word) || crate::utils::is_uppercase(word)))
{
tags.extend(self.get_raw(&lower));
}
tags
}
#[allow(dead_code)] // used by compile module
pub(crate) fn tag_store(&self) -> &BiMap<String, PosIdInt> {
&self.tag_store
}
#[allow(dead_code)] // used by compile module
pub(crate) fn word_store(&self) -> &BiMap<String, WordIdInt> {
&self.word_store
}
fn str_for_word_id(&self, id: &WordIdInt) -> &str {
self.word_store
.get_by_right(id)
.expect("only valid word ids are created")
}
fn str_for_pos_id(&self, id: &PosIdInt) -> &str {
self.tag_store
.get_by_right(id)
.expect("only valid pos ids are created")
}
pub fn id_tag<'a>(&self, tag: &'a str) -> PosId<'a> {
PosId(
tag,
*self.tag_store.get_by_left(tag).unwrap_or_else(|| {
error!(
"'{}' not found in tag store, please add it to the `extra_tags`. Using UNKNOWN instead.",
tag
);
self.tag_store.get_by_left("UNKNOWN").expect("UNKNOWN tag must exist in tag store")
}),
)
}
pub fn id_word<'t>(&'t self, text: Cow<'t, str>) -> WordId<'t> {
let id = self.word_store.get_by_left(text.as_ref()).copied();
WordId(text, id)
}
/// Get the tags and lemmas (as [WordData][crate::types::WordData]) for the given word.
///
/// # Arguments
/// * `word`: The word to lookup data for.
/// * `add_lower`: Whether to add data for the lowercase variant of the word.
/// * `use_compound_split_heuristic`: Whether to use a heuristic to split compound words.
/// If true, will attempt to find tags for words which are longer than some cutoff and unknown by looking up tags
/// for substrings from left to right until tags are found or a minimum length reached.
pub fn get_tags(
&self,
word: &str,
add_lower: bool,
use_compound_split_heuristic: bool,
) -> Vec<WordData> {
let mut tags = self.get_strict_tags(word, add_lower, true);
// compound splitting heuristic, seems to work reasonably well
if use_compound_split_heuristic && tags.is_empty() {
let n_chars = word.chars().count() as isize;
if n_chars >= 7 {
let indices = word
.char_indices()
.take(std::cmp::max(n_chars - 4, 0) as usize)
.skip(1)
.map(|x| x.0);
// the word always has at least one char if the above condition is satisfied
// but semantically this is false if no char exists
let starts_with_uppercase = word.chars().next().map_or(false, |x| x.is_uppercase());
for i in indices {
let next = if starts_with_uppercase {
crate::utils::apply_to_first(&word[i..], |c| c.to_uppercase().collect())
} else {
word[i..].to_string()
};
let next_tags = self.get_strict_tags(&next, add_lower, false);
if !next_tags.is_empty() {
tags = next_tags
.into_iter()
.map(|mut x| {
x.lemma = self.id_word(
format!("{}{}", &word[..i], x.lemma.as_ref().to_lowercase())
.into(),
);
x
})
.collect();
break;
}
}
}
}
tags
}
/// Get the words with the same lemma as the given lemma.
pub fn get_group_members(&self, lemma: &str) -> Vec<&str> | {
self.word_store
.get_by_left(lemma)
.and_then(|x| self.groups.get(x))
.map(|vec| vec.iter().map(|x| self.str_for_word_id(x)).collect())
.unwrap_or_else(Vec::new)
} | identifier_body |
|
base.py | {}
# Map of reverse relation
self.reverse_rel = {}
# Map of related classes and the field associated
self.rel_class = {}
def add_field(self, field):
"""
Add a field to the class. It makes sure all related variables are
up to date
"""
if field.name in self.fields:
print("WARNING: Field {0} already in model {1}"
.format(field.name, self.table_name))
return
self.fields[field.name] = field
self.sorted_fields.append(field)
self.sorted_fields_names.append(field.name)
class BaseModel(type):
"""
Metaclass for all models.
"""
def __new__(cls, name, bases, attrs):
if name == _METACLASS_ or bases[0].__name__ == _METACLASS_:
return super(BaseModel, cls).__new__(cls, name, bases, attrs)
# Get all variable defined in the meta class of each model.
meta_options = {}
meta = attrs.pop('Meta', None)
if meta:
for k, v in meta.__dict__.items():
if not k.startswith('_'):
meta_options[k] = v
# Create Model class and its options
cls = super(BaseModel, cls).__new__(cls, name, bases, attrs)
cls._meta = ModelOptions(cls, **meta_options)
# If many to many initialize the links between the two tables.
if cls._meta.many_to_many:
links = []
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
links.append((attr, attrs[attr]))
else:
for key, value in attrs.items():
if not key.startswith('_'):
links.append((key, value))
links[0][1].related_name = links[1][0]
links[0][1].add_to_model(cls, links[0][0])
links[1][1].related_name = links[0][0]
links[1][1].add_to_model(cls, links[1][0])
# Else it is a basic model.
else:
# If primary key
if cls._meta.primary_key:
# Create primary key field
cls.id = fields.PrimaryKeyField()
# Add field to the model
cls.id.add_to_model(cls, PrimaryKeyField.name)
# Add each field to the model
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
attrs[attr].add_to_model(cls, attr)
else:
for key, value in attrs.items():
if not key.startswith('_'):
value.add_to_model(cls, key)
return cls
class Model(with_metaclass(BaseModel)):
"""
Represents a model in the database with all its fields and current values
"""
def __init__(self, **kwargs):
# Map of all fields and associated values
self.dictValues = {}
# Initialize each field. If no value set it to None
for k, v in self._meta.fields.items():
if k in kwargs:
self.dictValues[k] = kwargs[k]
setattr(self, k, kwargs[k])
else:
self.dictValues[k] = None
setattr(self, k, None)
# Set primary key to None if no value provided
if self._meta.primary_key and not "id" in self.dictValues:
self.dictValues["id"] = None
object.__setattr__(self, "id", None)
# Initialize reverse relation as empty list.
for field in self._meta.reverse_rel:
object.__setattr__(self, field, [])
if self._meta.propagate and self._meta.database.subscribe:
self._subscribe()
def __setattr__(self, name, value):
"""
Overide __setattr__ to update dict value and field value at once
"""
object.__setattr__(self, name, value)
if name in self.dictValues: # If updating a field value
if self._meta.fields[name].salt: # field is salt
# If field is already salt do nothing.
# XXX Could create a security issue. What happend is value
# starts with $2b$ but it's not encrypted. Not critical for now
if not ("$2b$" in value and value[:4] == "$2b$"):
value = bcrypt.hashpw(value.encode('utf8'), bcrypt.gensalt())
object.__setattr__(self, name, value)
# If value is an instance of model class and has a relation.
# Append it to the corresponding field list
if hasattr(value, "_meta") and self.isForeignKey(self._meta.fields[name]):
self.dictValues[name] = getattr(value, self._meta.fields[name].reference.name)
return
self.dictValues[name] = value
@classmethod
def isForeignKey(cls, _field):
"""
Is the field an instance of ForeignKeyField
"""
return isinstance(_field, fields.ForeignKeyField)
@classmethod
def isReferenceField(cls, _field):
"""
Is the field an instance of ReferenceField
"""
return isinstance(_field, fields.ReferenceField)
@classmethod
@inlineCallbacks
def create_table(cls, *args, **kwargs):
"""
Creates a table in the database.
"""
init = cls._meta.database.create_table_title(cls._meta.table_name)
i = 1
fields = zip(cls._meta.sorted_fields_names, cls._meta.sorted_fields)
for field in fields:
field_string = field[1].create_field(field[0])
if i == len(fields):
if cls._meta.unique:
init = cls._meta.database.create_unique(init, cls._meta.unique)
init = cls._meta.database.create_table_field_end(init, field_string)
if cls._meta.hypertable:
init = cls._meta.database.create_hypertable(init,
cls._meta)
else:
init = cls._meta.database.create_table_field(init, field_string)
i+=1
yield cls._meta.database.runOperation(init)
@classmethod
@inlineCallbacks
def delete_table(cls, *args, **kwargs):
"""
Deletes table from database
"""
operation = cls._meta.database.delete_table(cls._meta.table_name)
yield cls._meta.database.runOperation(operation)
@classmethod
@inlineCallbacks
def insert(cls, values):
"""
Insert a row to the table with the given values
"""
result = yield InsertQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def update(cls, values):
"""
Update values in row
"""
result = yield UpdateQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def create(cls, **kwargs):
"""
Instanciates a model class object and save it into the database.
"""
inst = cls(**kwargs)
yield inst.save()
returnValue(inst)
@classmethod
def all(cls):
"""
Get all rows from a table
"""
return SelectQuery(cls)
@classmethod
@inlineCallbacks
def add(cls, obj1, obj2):
"""
Add a link between two model
"""
if not cls._meta.many_to_many:
raise Exception("ERROR: Add called on non many to many model")
query = AddQuery(cls, obj1, obj2)
yield query.execute()
if not getattr(obj1, obj2._meta.name):
setattr(obj1, obj2._meta.name, [obj2])
else:
getattr(obj1, obj2._meta.name).append(obj2)
if not getattr(obj2, obj1._meta.name):
setattr(obj2, obj1._meta.name, [obj1])
else:
getattr(obj2, obj1._meta.name).append(obj1)
@classmethod
@inlineCallbacks
def remove(cls, obj1, obj2):
"""
Remove a link between two model
"""
if not cls._meta.many_to_many:
raise Exception("ERROR: Remove called on non many to many model")
query = RemoveQuery(cls, obj1, obj2)
yield query.execute()
if obj2 in getattr(obj1, obj2._meta.name):
getattr(obj1, obj2._meta.name).remove(obj2)
if obj1 in getattr(obj2, obj1._meta.name):
getattr(obj2, obj1._meta.name).remove(obj1)
@classmethod
def delete(cls):
"""
Delete a row in the database
"""
query_instance = DeleteQuery(cls)
return query_instance
@inlineCallbacks
def save(self):
| """
Save a row
"""
# For each field get the value to insert
values = {key : self._meta.fields[key].insert_format(value) for key, value in self.dictValues.items()}
if self._meta.primary_key:
# If an id exist then we should update
if self.id:
pk = yield self.update(values)
if self._meta.propagate:
self._meta.database.propagate(self)
# Else it means we should create the row
else:
# XXX To Do: What happen if insert failed. What should we return
del values["id"]
pk = yield self.insert(values)
# Update id value
self.id = pk | identifier_body |
|
base.py | {}
# Map of reverse relation
self.reverse_rel = {}
# Map of related classes and the field associated
self.rel_class = {}
def add_field(self, field):
"""
Add a field to the class. It makes sure all related variables are
up to date
"""
if field.name in self.fields:
print("WARNING: Field {0} already in model {1}"
.format(field.name, self.table_name))
return
self.fields[field.name] = field
self.sorted_fields.append(field)
self.sorted_fields_names.append(field.name)
class BaseModel(type):
"""
Metaclass for all models.
"""
def __new__(cls, name, bases, attrs):
if name == _METACLASS_ or bases[0].__name__ == _METACLASS_:
return super(BaseModel, cls).__new__(cls, name, bases, attrs)
# Get all variable defined in the meta class of each model.
meta_options = {}
meta = attrs.pop('Meta', None)
if meta:
for k, v in meta.__dict__.items():
if not k.startswith('_'):
meta_options[k] = v
# Create Model class and its options
cls = super(BaseModel, cls).__new__(cls, name, bases, attrs)
cls._meta = ModelOptions(cls, **meta_options)
# If many to many initialize the links between the two tables.
if cls._meta.many_to_many:
links = []
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
links.append((attr, attrs[attr]))
else:
for key, value in attrs.items():
if not key.startswith('_'):
links.append((key, value))
links[0][1].related_name = links[1][0]
links[0][1].add_to_model(cls, links[0][0])
links[1][1].related_name = links[0][0]
links[1][1].add_to_model(cls, links[1][0])
# Else it is a basic model.
else:
# If primary key
if cls._meta.primary_key:
# Create primary key field
cls.id = fields.PrimaryKeyField()
# Add field to the model
cls.id.add_to_model(cls, PrimaryKeyField.name)
# Add each field to the model
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
attrs[attr].add_to_model(cls, attr)
else:
for key, value in attrs.items():
if not key.startswith('_'):
value.add_to_model(cls, key)
return cls
class Model(with_metaclass(BaseModel)):
"""
Represents a model in the database with all its fields and current values
"""
def __init__(self, **kwargs):
# Map of all fields and associated values
self.dictValues = {}
# Initialize each field. If no value set it to None
for k, v in self._meta.fields.items():
if k in kwargs:
self.dictValues[k] = kwargs[k]
setattr(self, k, kwargs[k])
else:
self.dictValues[k] = None
setattr(self, k, None)
# Set primary key to None if no value provided
if self._meta.primary_key and not "id" in self.dictValues:
self.dictValues["id"] = None
object.__setattr__(self, "id", None)
# Initialize reverse relation as empty list.
for field in self._meta.reverse_rel:
object.__setattr__(self, field, [])
if self._meta.propagate and self._meta.database.subscribe:
self._subscribe()
def __setattr__(self, name, value):
"""
Overide __setattr__ to update dict value and field value at once
"""
object.__setattr__(self, name, value)
if name in self.dictValues: # If updating a field value
if self._meta.fields[name].salt: # field is salt
# If field is already salt do nothing.
# XXX Could create a security issue. What happend is value
# starts with $2b$ but it's not encrypted. Not critical for now
if not ("$2b$" in value and value[:4] == "$2b$"):
value = bcrypt.hashpw(value.encode('utf8'), bcrypt.gensalt())
object.__setattr__(self, name, value)
# If value is an instance of model class and has a relation.
# Append it to the corresponding field list
if hasattr(value, "_meta") and self.isForeignKey(self._meta.fields[name]):
self.dictValues[name] = getattr(value, self._meta.fields[name].reference.name)
return
self.dictValues[name] = value
@classmethod
def isForeignKey(cls, _field):
"""
Is the field an instance of ForeignKeyField
"""
return isinstance(_field, fields.ForeignKeyField)
@classmethod
def isReferenceField(cls, _field):
"""
Is the field an instance of ReferenceField
"""
return isinstance(_field, fields.ReferenceField)
@classmethod
@inlineCallbacks
def create_table(cls, *args, **kwargs):
"""
Creates a table in the database.
"""
init = cls._meta.database.create_table_title(cls._meta.table_name)
i = 1
fields = zip(cls._meta.sorted_fields_names, cls._meta.sorted_fields)
for field in fields:
field_string = field[1].create_field(field[0])
if i == len(fields):
if cls._meta.unique:
init = cls._meta.database.create_unique(init, cls._meta.unique)
init = cls._meta.database.create_table_field_end(init, field_string)
if cls._meta.hypertable:
init = cls._meta.database.create_hypertable(init,
cls._meta)
else:
init = cls._meta.database.create_table_field(init, field_string)
i+=1
yield cls._meta.database.runOperation(init)
@classmethod
@inlineCallbacks
def delete_table(cls, *args, **kwargs):
"""
Deletes table from database
"""
operation = cls._meta.database.delete_table(cls._meta.table_name)
yield cls._meta.database.runOperation(operation)
@classmethod
@inlineCallbacks
def insert(cls, values):
"""
Insert a row to the table with the given values
"""
result = yield InsertQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def update(cls, values):
"""
Update values in row
"""
result = yield UpdateQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def create(cls, **kwargs):
"""
Instanciates a model class object and save it into the database.
"""
inst = cls(**kwargs)
yield inst.save()
returnValue(inst)
@classmethod
def all(cls):
"""
Get all rows from a table
"""
return SelectQuery(cls)
@classmethod
@inlineCallbacks
def add(cls, obj1, obj2):
"""
Add a link between two model
"""
if not cls._meta.many_to_many:
raise Exception("ERROR: Add called on non many to many model")
query = AddQuery(cls, obj1, obj2)
yield query.execute()
if not getattr(obj1, obj2._meta.name):
setattr(obj1, obj2._meta.name, [obj2])
else:
getattr(obj1, obj2._meta.name).append(obj2)
if not getattr(obj2, obj1._meta.name):
setattr(obj2, obj1._meta.name, [obj1])
else:
getattr(obj2, obj1._meta.name).append(obj1)
@classmethod
@inlineCallbacks
def remove(cls, obj1, obj2):
"""
Remove a link between two model
"""
if not cls._meta.many_to_many:
raise Exception("ERROR: Remove called on non many to many model")
query = RemoveQuery(cls, obj1, obj2)
yield query.execute()
if obj2 in getattr(obj1, obj2._meta.name):
getattr(obj1, obj2._meta.name).remove(obj2)
if obj1 in getattr(obj2, obj1._meta.name):
getattr(obj2, obj1._meta.name).remove(obj1)
@classmethod
def delete(cls):
"""
Delete a row in the database
"""
query_instance = DeleteQuery(cls)
return query_instance
@inlineCallbacks
def save(self):
"""
Save a row
"""
# For each field get the value to insert
values = {key : self._meta.fields[key].insert_format(value) for key, value in self.dictValues.items()}
if self._meta.primary_key:
# If an id exist then we should update
| if self.id:
pk = yield self.update(values)
if self._meta.propagate:
self._meta.database.propagate(self)
# Else it means we should create the row
else:
# XXX To Do: What happen if insert failed. What should we return
del values["id"]
pk = yield self.insert(values)
# Update id value
self.id = pk | conditional_block |
|
base.py | import inlineCallbacks, returnValue
from fields import PrimaryKeyField
from query import SelectQuery, \
InsertQuery, \
AddQuery, \
RemoveQuery, \
UpdateQuery, \
DeleteQuery
"""
Metaclass enables to have a set of variable for each class Model.
This set of variable is represented by the class ModelOptions
"""
_METACLASS_ = '_metaclass_helper_'
def with_metaclass(meta, base=object):
return meta(_METACLASS_, (base,), {})
class ModelOptions(object):
"""
Represents all the options associated to a model.
They are accesible using the _meta variable from a Model object
"""
def __init__(self, cls,
table_name = None,
database = None,
primary_key = True,
on_conflict = [],
unique = [],
many_to_many = False,
order = [],
propagate = False,
hypertable = []):
# Model class
self.model_class = cls
# Model name
self.name = cls.__name__.lower()
# Table name. Either set by the user or derivated from name
self.table_name = table_name.lower() if table_name else self.name
# Database to use
self.database = database
# Does the models have a primary key. If so it will be set by Kameleon
self.primary_key = primary_key
# XXX
self.on_conflict = on_conflict
# List of field which association should be unique.
# XXX #3 Today it receive a string.
# It should be receiving a list of fields
self.unique = unique
# Is this model a middle table for a many to many link
self.many_to_many = many_to_many
# Map of links represented by this table. Filled by the class
self.links = {}
# Order to respect. Useful if table not created by the ORM
self.order = order
# Should any change on a model be propagate
self.propagate = propagate
# Should the table change to hyper table.
self.hypertable = hypertable
# Map of fields
self.fields = {}
# Map of reverse relation fields
self.reverse_fields = {}
# List of fields sorted in order
self.sorted_fields = []
# Fields name sorted in order
self.sorted_fields_names = []
# Map of direct relation
self.rel = {}
# Map of reverse relation
self.reverse_rel = {}
# Map of related classes and the field associated
self.rel_class = {}
def add_field(self, field):
"""
Add a field to the class. It makes sure all related variables are
up to date
"""
if field.name in self.fields:
print("WARNING: Field {0} already in model {1}"
.format(field.name, self.table_name))
return
self.fields[field.name] = field
self.sorted_fields.append(field)
self.sorted_fields_names.append(field.name)
class BaseModel(type):
"""
Metaclass for all models.
"""
def __new__(cls, name, bases, attrs):
if name == _METACLASS_ or bases[0].__name__ == _METACLASS_:
return super(BaseModel, cls).__new__(cls, name, bases, attrs)
# Get all variable defined in the meta class of each model.
meta_options = {}
meta = attrs.pop('Meta', None)
if meta:
for k, v in meta.__dict__.items():
if not k.startswith('_'):
meta_options[k] = v
# Create Model class and its options
cls = super(BaseModel, cls).__new__(cls, name, bases, attrs)
cls._meta = ModelOptions(cls, **meta_options)
# If many to many initialize the links between the two tables.
if cls._meta.many_to_many:
links = []
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
links.append((attr, attrs[attr]))
else:
for key, value in attrs.items():
if not key.startswith('_'):
links.append((key, value))
links[0][1].related_name = links[1][0]
links[0][1].add_to_model(cls, links[0][0])
links[1][1].related_name = links[0][0]
links[1][1].add_to_model(cls, links[1][0])
# Else it is a basic model.
else:
# If primary key
if cls._meta.primary_key:
# Create primary key field
cls.id = fields.PrimaryKeyField()
# Add field to the model
cls.id.add_to_model(cls, PrimaryKeyField.name)
# Add each field to the model
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
attrs[attr].add_to_model(cls, attr)
else:
for key, value in attrs.items():
if not key.startswith('_'):
value.add_to_model(cls, key)
return cls
class Model(with_metaclass(BaseModel)):
"""
Represents a model in the database with all its fields and current values
"""
def __init__(self, **kwargs):
# Map of all fields and associated values
self.dictValues = {}
# Initialize each field. If no value set it to None
for k, v in self._meta.fields.items():
if k in kwargs:
self.dictValues[k] = kwargs[k]
setattr(self, k, kwargs[k])
else:
self.dictValues[k] = None
setattr(self, k, None)
# Set primary key to None if no value provided
if self._meta.primary_key and not "id" in self.dictValues:
self.dictValues["id"] = None
object.__setattr__(self, "id", None)
# Initialize reverse relation as empty list.
for field in self._meta.reverse_rel:
object.__setattr__(self, field, [])
if self._meta.propagate and self._meta.database.subscribe:
self._subscribe()
def | (self, name, value):
"""
Overide __setattr__ to update dict value and field value at once
"""
object.__setattr__(self, name, value)
if name in self.dictValues: # If updating a field value
if self._meta.fields[name].salt: # field is salt
# If field is already salt do nothing.
# XXX Could create a security issue. What happend is value
# starts with $2b$ but it's not encrypted. Not critical for now
if not ("$2b$" in value and value[:4] == "$2b$"):
value = bcrypt.hashpw(value.encode('utf8'), bcrypt.gensalt())
object.__setattr__(self, name, value)
# If value is an instance of model class and has a relation.
# Append it to the corresponding field list
if hasattr(value, "_meta") and self.isForeignKey(self._meta.fields[name]):
self.dictValues[name] = getattr(value, self._meta.fields[name].reference.name)
return
self.dictValues[name] = value
@classmethod
def isForeignKey(cls, _field):
"""
Is the field an instance of ForeignKeyField
"""
return isinstance(_field, fields.ForeignKeyField)
@classmethod
def isReferenceField(cls, _field):
"""
Is the field an instance of ReferenceField
"""
return isinstance(_field, fields.ReferenceField)
@classmethod
@inlineCallbacks
def create_table(cls, *args, **kwargs):
"""
Creates a table in the database.
"""
init = cls._meta.database.create_table_title(cls._meta.table_name)
i = 1
fields = zip(cls._meta.sorted_fields_names, cls._meta.sorted_fields)
for field in fields:
field_string = field[1].create_field(field[0])
if i == len(fields):
if cls._meta.unique:
init = cls._meta.database.create_unique(init, cls._meta.unique)
init = cls._meta.database.create_table_field_end(init, field_string)
if cls._meta.hypertable:
init = cls._meta.database.create_hypertable(init,
cls._meta)
else:
init = cls._meta.database.create_table_field(init, field_string)
i+=1
yield cls._meta.database.runOperation(init)
@classmethod
@inlineCallbacks
def delete_table(cls, *args, **kwargs):
"""
Deletes table from database
"""
operation = cls._meta.database.delete_table(cls._meta.table_name)
yield cls._meta.database.runOperation(operation)
@classmethod
@inlineCallbacks
def insert(cls, values):
"""
Insert a row to the table with the given values
"""
result = yield InsertQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def update(cls, values):
"""
Update values in row
"""
result = yield UpdateQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def create(cls, **kwargs):
"""
Instanciates a model class object and save it into the database.
"""
inst = cls(**kwargs)
yield inst.save()
returnValue(inst)
@classmethod | __setattr__ | identifier_name |
base.py |
up to date
"""
if field.name in self.fields:
print("WARNING: Field {0} already in model {1}"
.format(field.name, self.table_name))
return
self.fields[field.name] = field
self.sorted_fields.append(field)
self.sorted_fields_names.append(field.name)
class BaseModel(type):
"""
Metaclass for all models.
"""
def __new__(cls, name, bases, attrs):
if name == _METACLASS_ or bases[0].__name__ == _METACLASS_:
return super(BaseModel, cls).__new__(cls, name, bases, attrs)
# Get all variable defined in the meta class of each model.
meta_options = {}
meta = attrs.pop('Meta', None)
if meta:
for k, v in meta.__dict__.items():
if not k.startswith('_'):
meta_options[k] = v
# Create Model class and its options
cls = super(BaseModel, cls).__new__(cls, name, bases, attrs)
cls._meta = ModelOptions(cls, **meta_options)
# If many to many initialize the links between the two tables.
if cls._meta.many_to_many:
links = []
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
links.append((attr, attrs[attr]))
else:
for key, value in attrs.items():
if not key.startswith('_'):
links.append((key, value))
links[0][1].related_name = links[1][0]
links[0][1].add_to_model(cls, links[0][0])
links[1][1].related_name = links[0][0]
links[1][1].add_to_model(cls, links[1][0])
# Else it is a basic model.
else:
# If primary key
if cls._meta.primary_key:
# Create primary key field
cls.id = fields.PrimaryKeyField()
# Add field to the model
cls.id.add_to_model(cls, PrimaryKeyField.name)
# Add each field to the model
if cls._meta.order:
for attr in cls._meta.order:
if attr in attrs:
attrs[attr].add_to_model(cls, attr)
else:
for key, value in attrs.items():
if not key.startswith('_'):
value.add_to_model(cls, key)
return cls
class Model(with_metaclass(BaseModel)):
"""
Represents a model in the database with all its fields and current values
"""
def __init__(self, **kwargs):
# Map of all fields and associated values
self.dictValues = {}
# Initialize each field. If no value set it to None
for k, v in self._meta.fields.items():
if k in kwargs:
self.dictValues[k] = kwargs[k]
setattr(self, k, kwargs[k])
else:
self.dictValues[k] = None
setattr(self, k, None)
# Set primary key to None if no value provided
if self._meta.primary_key and not "id" in self.dictValues:
self.dictValues["id"] = None
object.__setattr__(self, "id", None)
# Initialize reverse relation as empty list.
for field in self._meta.reverse_rel:
object.__setattr__(self, field, [])
if self._meta.propagate and self._meta.database.subscribe:
self._subscribe()
def __setattr__(self, name, value):
"""
Overide __setattr__ to update dict value and field value at once
"""
object.__setattr__(self, name, value)
if name in self.dictValues: # If updating a field value
if self._meta.fields[name].salt: # field is salt
# If field is already salt do nothing.
# XXX Could create a security issue. What happend is value
# starts with $2b$ but it's not encrypted. Not critical for now
if not ("$2b$" in value and value[:4] == "$2b$"):
value = bcrypt.hashpw(value.encode('utf8'), bcrypt.gensalt())
object.__setattr__(self, name, value)
# If value is an instance of model class and has a relation.
# Append it to the corresponding field list
if hasattr(value, "_meta") and self.isForeignKey(self._meta.fields[name]):
self.dictValues[name] = getattr(value, self._meta.fields[name].reference.name)
return
self.dictValues[name] = value
@classmethod
def isForeignKey(cls, _field):
"""
Is the field an instance of ForeignKeyField
"""
return isinstance(_field, fields.ForeignKeyField)
@classmethod
def isReferenceField(cls, _field):
"""
Is the field an instance of ReferenceField
"""
return isinstance(_field, fields.ReferenceField)
@classmethod
@inlineCallbacks
def create_table(cls, *args, **kwargs):
"""
Creates a table in the database.
"""
init = cls._meta.database.create_table_title(cls._meta.table_name)
i = 1
fields = zip(cls._meta.sorted_fields_names, cls._meta.sorted_fields)
for field in fields:
field_string = field[1].create_field(field[0])
if i == len(fields):
if cls._meta.unique:
init = cls._meta.database.create_unique(init, cls._meta.unique)
init = cls._meta.database.create_table_field_end(init, field_string)
if cls._meta.hypertable:
init = cls._meta.database.create_hypertable(init,
cls._meta)
else:
init = cls._meta.database.create_table_field(init, field_string)
i+=1
yield cls._meta.database.runOperation(init)
@classmethod
@inlineCallbacks
def delete_table(cls, *args, **kwargs):
"""
Deletes table from database
"""
operation = cls._meta.database.delete_table(cls._meta.table_name)
yield cls._meta.database.runOperation(operation)
@classmethod
@inlineCallbacks
def insert(cls, values):
"""
Insert a row to the table with the given values
"""
result = yield InsertQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def update(cls, values):
"""
Update values in row
"""
result = yield UpdateQuery(cls, values).execute()
returnValue(result)
@classmethod
@inlineCallbacks
def create(cls, **kwargs):
"""
Instanciates a model class object and save it into the database.
"""
inst = cls(**kwargs)
yield inst.save()
returnValue(inst)
@classmethod
def all(cls):
"""
Get all rows from a table
"""
return SelectQuery(cls)
@classmethod
@inlineCallbacks
def add(cls, obj1, obj2):
"""
Add a link between two model
"""
if not cls._meta.many_to_many:
raise Exception("ERROR: Add called on non many to many model")
query = AddQuery(cls, obj1, obj2)
yield query.execute()
if not getattr(obj1, obj2._meta.name):
setattr(obj1, obj2._meta.name, [obj2])
else:
getattr(obj1, obj2._meta.name).append(obj2)
if not getattr(obj2, obj1._meta.name):
setattr(obj2, obj1._meta.name, [obj1])
else:
getattr(obj2, obj1._meta.name).append(obj1)
@classmethod
@inlineCallbacks
def remove(cls, obj1, obj2):
"""
Remove a link between two model
"""
if not cls._meta.many_to_many:
raise Exception("ERROR: Remove called on non many to many model")
query = RemoveQuery(cls, obj1, obj2)
yield query.execute()
if obj2 in getattr(obj1, obj2._meta.name):
getattr(obj1, obj2._meta.name).remove(obj2)
if obj1 in getattr(obj2, obj1._meta.name):
getattr(obj2, obj1._meta.name).remove(obj1)
@classmethod
def delete(cls):
"""
Delete a row in the database
"""
query_instance = DeleteQuery(cls)
return query_instance
@inlineCallbacks
def save(self):
"""
Save a row
"""
# For each field get the value to insert
values = {key : self._meta.fields[key].insert_format(value) for key, value in self.dictValues.items()}
if self._meta.primary_key:
# If an id exist then we should update
if self.id:
pk = yield self.update(values)
if self._meta.propagate:
self._meta.database.propagate(self)
# Else it means we should create the row
else:
# XXX To Do: What happen if insert failed. What should we return
del values["id"]
pk = yield self.insert(values)
# Update id value
self.id = pk
else:
yield self.insert(values)
def _subscribe(self):
self._meta.database.connection.subscribe(self.propagate_update, u"wamp.postgresql.propagadate.{0}".format(self._meta.name)) |
def propagate_update(self, dictValues): | random_line_split |
|
rca.rs | is rolled up by aggregate fn (e.g. sum)
// - 2nd drill is rolled up by groupArray, which just collects all the values into an array in
// order.
// - the original measure is also rolled up by groupArray.
//
// Then the pivoted table is melted using Array Join on the 2nd drill and the original measure
// (which would be a or c), while preserving the aggregated measure (c or d) from the pivoted
// table.
//
// An example (not accounting for external cuts or dims) would be
// select drill_1_id, drill_2_id, a, c from (
// select drill_1_id, groupArray(drill_2_id) as drill_2_id_s, groupArray(a) a_s, sum(a) as c from (
// select * from a_table
// )
// group by drill_1_id
// )
// array join drill_2_id_s as drill_2_id, a_s as a
use itertools::join;
use crate::sql::primary_agg::primary_agg;
use super::{
TableSql,
CutSql,
DrilldownSql,
MeasureSql,
RcaSql,
};
pub fn | (
table: &TableSql,
cuts: &[CutSql],
drills: &[DrilldownSql],
meas: &[MeasureSql],
rca: &RcaSql,
) -> (String, String)
{
// append the correct rca drill to drilldowns
// for a, both
// for b, d2
// for c, d1
// for d, none
let mut a_drills = drills.to_vec();
let mut b_drills = drills.to_vec();
let mut c_drills = drills.to_vec();
let d_drills = drills.to_vec();
a_drills.extend_from_slice(&rca.drill_1);
a_drills.extend_from_slice(&rca.drill_2);
b_drills.extend_from_slice(&rca.drill_2);
c_drills.extend_from_slice(&rca.drill_1);
println!("a: {:?}", a_drills);
println!("b: {:?}", b_drills);
println!("c: {:?}", c_drills);
println!("d: {:?}", d_drills);
// prepend the rca sql to meas
let all_meas = {
let mut temp = vec![rca.mea.clone()];
temp.extend_from_slice(meas);
temp
};
// for cuts,
// - a can be cut on d1 and ext
// - b cannot be int cut, only ext
// - c can be cut on d1 and ext
// - d cannot be int cut, only ext
//
// In the future, would I allow more cuts? Maybe depending on use case
//
// The blacklist is the drilldowns contained in each of a, b, c, d
//
// Note: parent of rca drills are not filtered, because they are meant
// to limit the rca calculation space!
//
// don't need to worry about aliases, because cuts don't use aliases,
// and are just matching against drill key col
let ac_cut_cols_blacklist: Vec<_> = rca.drill_2.iter()
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let bd_cut_cols_blacklist: Vec<_> = rca.drill_1.iter().chain(rca.drill_2.iter())
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let ac_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
ac_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
let bd_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
bd_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
println!("{:#?}", cuts);
println!("{:#?}", ac_cuts);
println!("{:#?}", bd_cuts);
// now aggregate each component
//
// As an optimization, c is calculated from a, and d is calculated from b
// If there's no internal cuts, then b, c, d are calculated from a.
// First do aggregation for part a, b
let (a, a_final_drills) = primary_agg(table, &ac_cuts, &a_drills, &all_meas, None);
let (b, b_final_drills) = primary_agg(table, &bd_cuts, &b_drills, &all_meas, None);
// replace final_m0 with letter name.
// I put the rca measure at the beginning of the drills, so it should
// always be m0
let a = a.replace("final_m0", "a");
let b = b.replace("final_m0", "b");
// for clickhouse, need to make groupArray and Array Join clauses for drill_1 for when
// aggregating a to c, and b to d.
// (drill_2 would be needed if going from a to b)
// TODO refacto these lines out to helpers
let group_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column {
format!("groupArray({key_col}_{alias_postfix}) as {key_col}_{alias_postfix}_s, groupArray({name_col}_{alias_postfix}) as {name_col}_{alias_postfix}_s", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} else {
format!("groupArray({col}_{alias_postfix}) as {col}_{alias_postfix}_s", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let group_array_rca_drill_2 = join(group_array_rca_drill_2, ", ");
let join_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column {
format!("{key_col}_{alias_postfix}_s as {key_col}_{alias_postfix}, {name_col}_{alias_postfix}_s as {name_col}_{alias_postfix}", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} else {
format!("{col}_{alias_postfix}_s as {col}_{alias_postfix}", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let join_array_rca_drill_2 = join(join_array_rca_drill_2, ", ");
// Do GroupArray and Array Join clauses for external measures, also
let mea_cols = (1..=meas.len())
.map(|m_idx| format!("final_m{col}", col=m_idx));
let mea_cols = join(mea_cols, ", ");
let group_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("groupArray(final_m{col}) as final_m{col}_s", col=m_idx));
let group_array_ext_mea = join(group_array_ext_mea, ", ");
let join_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("final_m{col}_s as final_m{col}", col=m_idx));
let join_array_ext_mea = join(join_array_ext_mea, ", ");
// groupArray cols (the drill_2 from rca) can't be included in the group by or select
let c_drills_minus_rca_drill_2 = c_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let c_drills_minus_rca_drill_2 = join(c_drills_minus_rca_drill_2, ", ");
let d_drills_minus_rca_drill_2 = d_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let d_drills_minus_rca_drill_2 = join(d_drills_minus_rca_drill_2, ", ");
// a and c drills are kept as-is
let a_drills_str = a_drills.iter()
.map(|d| d.col_alias_only_string());
let a_drills_str = join(a_drills_str, ", ");
let b_drills_str = b_drills.iter()
.map(|d| d.col_alias_only_string());
let b_drills_str = join(b_drills_str, ", ");
// Now add part c
let ac = format!("select {}, {}{} a, c from \
(select {}, {}, {}{} groupArray(a) as a_s, sum(a) as c from ({}) group by {}) \
Array Join {}, | calculate | identifier_name |
rca.rs | is rolled up by aggregate fn (e.g. sum)
// - 2nd drill is rolled up by groupArray, which just collects all the values into an array in
// order.
// - the original measure is also rolled up by groupArray.
//
// Then the pivoted table is melted using Array Join on the 2nd drill and the original measure
// (which would be a or c), while preserving the aggregated measure (c or d) from the pivoted
// table.
//
// An example (not accounting for external cuts or dims) would be
// select drill_1_id, drill_2_id, a, c from (
// select drill_1_id, groupArray(drill_2_id) as drill_2_id_s, groupArray(a) a_s, sum(a) as c from (
// select * from a_table
// )
// group by drill_1_id
// )
// array join drill_2_id_s as drill_2_id, a_s as a
use itertools::join;
use crate::sql::primary_agg::primary_agg;
use super::{
TableSql,
CutSql,
DrilldownSql,
MeasureSql,
RcaSql,
};
pub fn calculate(
table: &TableSql,
cuts: &[CutSql],
drills: &[DrilldownSql],
meas: &[MeasureSql],
rca: &RcaSql,
) -> (String, String)
{
// append the correct rca drill to drilldowns
// for a, both
// for b, d2
// for c, d1
// for d, none
let mut a_drills = drills.to_vec();
let mut b_drills = drills.to_vec();
let mut c_drills = drills.to_vec();
let d_drills = drills.to_vec();
a_drills.extend_from_slice(&rca.drill_1);
a_drills.extend_from_slice(&rca.drill_2);
b_drills.extend_from_slice(&rca.drill_2);
c_drills.extend_from_slice(&rca.drill_1);
println!("a: {:?}", a_drills);
println!("b: {:?}", b_drills);
println!("c: {:?}", c_drills);
println!("d: {:?}", d_drills);
// prepend the rca sql to meas
let all_meas = {
let mut temp = vec![rca.mea.clone()];
temp.extend_from_slice(meas);
temp
};
// for cuts,
// - a can be cut on d1 and ext
// - b cannot be int cut, only ext
// - c can be cut on d1 and ext
// - d cannot be int cut, only ext
//
// In the future, would I allow more cuts? Maybe depending on use case
//
// The blacklist is the drilldowns contained in each of a, b, c, d
//
// Note: parent of rca drills are not filtered, because they are meant
// to limit the rca calculation space!
//
// don't need to worry about aliases, because cuts don't use aliases,
// and are just matching against drill key col
let ac_cut_cols_blacklist: Vec<_> = rca.drill_2.iter()
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let bd_cut_cols_blacklist: Vec<_> = rca.drill_1.iter().chain(rca.drill_2.iter())
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let ac_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
ac_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
let bd_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
bd_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
println!("{:#?}", cuts);
println!("{:#?}", ac_cuts);
println!("{:#?}", bd_cuts);
// now aggregate each component
//
// As an optimization, c is calculated from a, and d is calculated from b
// If there's no internal cuts, then b, c, d are calculated from a.
// First do aggregation for part a, b
let (a, a_final_drills) = primary_agg(table, &ac_cuts, &a_drills, &all_meas, None);
let (b, b_final_drills) = primary_agg(table, &bd_cuts, &b_drills, &all_meas, None);
// replace final_m0 with letter name.
// I put the rca measure at the beginning of the drills, so it should
// always be m0
let a = a.replace("final_m0", "a");
let b = b.replace("final_m0", "b");
// for clickhouse, need to make groupArray and Array Join clauses for drill_1 for when
// aggregating a to c, and b to d.
// (drill_2 would be needed if going from a to b)
// TODO refacto these lines out to helpers
let group_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column | else {
format!("groupArray({col}_{alias_postfix}) as {col}_{alias_postfix}_s", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let group_array_rca_drill_2 = join(group_array_rca_drill_2, ", ");
let join_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column {
format!("{key_col}_{alias_postfix}_s as {key_col}_{alias_postfix}, {name_col}_{alias_postfix}_s as {name_col}_{alias_postfix}", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} else {
format!("{col}_{alias_postfix}_s as {col}_{alias_postfix}", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let join_array_rca_drill_2 = join(join_array_rca_drill_2, ", ");
// Do GroupArray and Array Join clauses for external measures, also
let mea_cols = (1..=meas.len())
.map(|m_idx| format!("final_m{col}", col=m_idx));
let mea_cols = join(mea_cols, ", ");
let group_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("groupArray(final_m{col}) as final_m{col}_s", col=m_idx));
let group_array_ext_mea = join(group_array_ext_mea, ", ");
let join_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("final_m{col}_s as final_m{col}", col=m_idx));
let join_array_ext_mea = join(join_array_ext_mea, ", ");
// groupArray cols (the drill_2 from rca) can't be included in the group by or select
let c_drills_minus_rca_drill_2 = c_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let c_drills_minus_rca_drill_2 = join(c_drills_minus_rca_drill_2, ", ");
let d_drills_minus_rca_drill_2 = d_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let d_drills_minus_rca_drill_2 = join(d_drills_minus_rca_drill_2, ", ");
// a and c drills are kept as-is
let a_drills_str = a_drills.iter()
.map(|d| d.col_alias_only_string());
let a_drills_str = join(a_drills_str, ", ");
let b_drills_str = b_drills.iter()
.map(|d| d.col_alias_only_string());
let b_drills_str = join(b_drills_str, ", ");
// Now add part c
let ac = format!("select {}, {}{} a, c from \
(select {}, {}, {}{} groupArray(a) as a_s, sum(a) as c from ({}) group by {}) \
Array Join {}, | {
format!("groupArray({key_col}_{alias_postfix}) as {key_col}_{alias_postfix}_s, groupArray({name_col}_{alias_postfix}) as {name_col}_{alias_postfix}_s", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} | conditional_block |
rca.rs | //
// The optimization is to derive the c and d aggregates from a and b. Since cuts are allowed on the
// first drill in the rca, both a and b have to be scanned (b cannot be cut on the first drill).
//
// In clickhouse there is no partition, so it's trickier to do what looks like two different group
// by.
//
// The general idea is to do one group by, in which both the measure and the 2nd drill are rolled
// up.
// - measure is rolled up by aggregate fn (e.g. sum)
// - 2nd drill is rolled up by groupArray, which just collects all the values into an array in
// order.
// - the original measure is also rolled up by groupArray.
//
// Then the pivoted table is melted using Array Join on the 2nd drill and the original measure
// (which would be a or c), while preserving the aggregated measure (c or d) from the pivoted
// table.
//
// An example (not accounting for external cuts or dims) would be
// select drill_1_id, drill_2_id, a, c from (
// select drill_1_id, groupArray(drill_2_id) as drill_2_id_s, groupArray(a) a_s, sum(a) as c from (
// select * from a_table
// )
// group by drill_1_id
// )
// array join drill_2_id_s as drill_2_id, a_s as a
use itertools::join;
use crate::sql::primary_agg::primary_agg;
use super::{
TableSql,
CutSql,
DrilldownSql,
MeasureSql,
RcaSql,
};
pub fn calculate(
table: &TableSql,
cuts: &[CutSql],
drills: &[DrilldownSql],
meas: &[MeasureSql],
rca: &RcaSql,
) -> (String, String)
{
// append the correct rca drill to drilldowns
// for a, both
// for b, d2
// for c, d1
// for d, none
let mut a_drills = drills.to_vec();
let mut b_drills = drills.to_vec();
let mut c_drills = drills.to_vec();
let d_drills = drills.to_vec();
a_drills.extend_from_slice(&rca.drill_1);
a_drills.extend_from_slice(&rca.drill_2);
b_drills.extend_from_slice(&rca.drill_2);
c_drills.extend_from_slice(&rca.drill_1);
println!("a: {:?}", a_drills);
println!("b: {:?}", b_drills);
println!("c: {:?}", c_drills);
println!("d: {:?}", d_drills);
// prepend the rca sql to meas
let all_meas = {
let mut temp = vec![rca.mea.clone()];
temp.extend_from_slice(meas);
temp
};
// for cuts,
// - a can be cut on d1 and ext
// - b cannot be int cut, only ext
// - c can be cut on d1 and ext
// - d cannot be int cut, only ext
//
// In the future, would I allow more cuts? Maybe depending on use case
//
// The blacklist is the drilldowns contained in each of a, b, c, d
//
// Note: parent of rca drills are not filtered, because they are meant
// to limit the rca calculation space!
//
// don't need to worry about aliases, because cuts don't use aliases,
// and are just matching against drill key col
let ac_cut_cols_blacklist: Vec<_> = rca.drill_2.iter()
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let bd_cut_cols_blacklist: Vec<_> = rca.drill_1.iter().chain(rca.drill_2.iter())
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let ac_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
ac_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
let bd_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
bd_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
println!("{:#?}", cuts);
println!("{:#?}", ac_cuts);
println!("{:#?}", bd_cuts);
// now aggregate each component
//
// As an optimization, c is calculated from a, and d is calculated from b
// If there's no internal cuts, then b, c, d are calculated from a.
// First do aggregation for part a, b
let (a, a_final_drills) = primary_agg(table, &ac_cuts, &a_drills, &all_meas, None);
let (b, b_final_drills) = primary_agg(table, &bd_cuts, &b_drills, &all_meas, None);
// replace final_m0 with letter name.
// I put the rca measure at the beginning of the drills, so it should
// always be m0
let a = a.replace("final_m0", "a");
let b = b.replace("final_m0", "b");
// for clickhouse, need to make groupArray and Array Join clauses for drill_1 for when
// aggregating a to c, and b to d.
// (drill_2 would be needed if going from a to b)
// TODO refacto these lines out to helpers
let group_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column {
format!("groupArray({key_col}_{alias_postfix}) as {key_col}_{alias_postfix}_s, groupArray({name_col}_{alias_postfix}) as {name_col}_{alias_postfix}_s", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} else {
format!("groupArray({col}_{alias_postfix}) as {col}_{alias_postfix}_s", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let group_array_rca_drill_2 = join(group_array_rca_drill_2, ", ");
let join_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column {
format!("{key_col}_{alias_postfix}_s as {key_col}_{alias_postfix}, {name_col}_{alias_postfix}_s as {name_col}_{alias_postfix}", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} else {
format!("{col}_{alias_postfix}_s as {col}_{alias_postfix}", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let join_array_rca_drill_2 = join(join_array_rca_drill_2, ", ");
// Do GroupArray and Array Join clauses for external measures, also
let mea_cols = (1..=meas.len())
.map(|m_idx| format!("final_m{col}", col=m_idx));
let mea_cols = join(mea_cols, ", ");
let group_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("groupArray(final_m{col}) as final_m{col}_s", col=m_idx));
let group_array_ext_mea = join(group_array_ext_mea, ", ");
let join_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("final_m{col}_s as final_m{col}", col=m_idx));
let join_array_ext_mea = join(join_array_ext_mea, ", ");
// groupArray cols (the drill_2 from rca) can't be included in the group by or select
let c_drills_minus_rca_drill_2 = c_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let c_drills_minus_rca_drill_2 = join(c_drills_minus_rca_drill_2, ", ");
let d_drills_minus_rca_drill_2 = d_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let d_drills_minus_rca_drill_2 = join(d_drills_minus_rca_drill_2, ", ");
// a and c drills are kept as-is
let a_drills_str = a_drills.iter()
.map(|d| d.col | // drill dim). | random_line_split |
|
rca.rs | measure is rolled up by aggregate fn (e.g. sum)
// - 2nd drill is rolled up by groupArray, which just collects all the values into an array in
// order.
// - the original measure is also rolled up by groupArray.
//
// Then the pivoted table is melted using Array Join on the 2nd drill and the original measure
// (which would be a or c), while preserving the aggregated measure (c or d) from the pivoted
// table.
//
// An example (not accounting for external cuts or dims) would be
// select drill_1_id, drill_2_id, a, c from (
// select drill_1_id, groupArray(drill_2_id) as drill_2_id_s, groupArray(a) a_s, sum(a) as c from (
// select * from a_table
// )
// group by drill_1_id
// )
// array join drill_2_id_s as drill_2_id, a_s as a
use itertools::join;
use crate::sql::primary_agg::primary_agg;
use super::{
TableSql,
CutSql,
DrilldownSql,
MeasureSql,
RcaSql,
};
pub fn calculate(
table: &TableSql,
cuts: &[CutSql],
drills: &[DrilldownSql],
meas: &[MeasureSql],
rca: &RcaSql,
) -> (String, String)
| println!("c: {:?}", c_drills);
println!("d: {:?}", d_drills);
// prepend the rca sql to meas
let all_meas = {
let mut temp = vec![rca.mea.clone()];
temp.extend_from_slice(meas);
temp
};
// for cuts,
// - a can be cut on d1 and ext
// - b cannot be int cut, only ext
// - c can be cut on d1 and ext
// - d cannot be int cut, only ext
//
// In the future, would I allow more cuts? Maybe depending on use case
//
// The blacklist is the drilldowns contained in each of a, b, c, d
//
// Note: parent of rca drills are not filtered, because they are meant
// to limit the rca calculation space!
//
// don't need to worry about aliases, because cuts don't use aliases,
// and are just matching against drill key col
let ac_cut_cols_blacklist: Vec<_> = rca.drill_2.iter()
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let bd_cut_cols_blacklist: Vec<_> = rca.drill_1.iter().chain(rca.drill_2.iter())
.flat_map(|d| d.level_columns.iter().map(|l| l.key_column.clone()))
.collect();
let ac_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
ac_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
let bd_cuts: Vec<_> = cuts.iter()
.filter(|cut| {
bd_cut_cols_blacklist.iter().find(|k| **k == cut.column).is_none()
})
.cloned()
.collect();
println!("{:#?}", cuts);
println!("{:#?}", ac_cuts);
println!("{:#?}", bd_cuts);
// now aggregate each component
//
// As an optimization, c is calculated from a, and d is calculated from b
// If there's no internal cuts, then b, c, d are calculated from a.
// First do aggregation for part a, b
let (a, a_final_drills) = primary_agg(table, &ac_cuts, &a_drills, &all_meas, None);
let (b, b_final_drills) = primary_agg(table, &bd_cuts, &b_drills, &all_meas, None);
// replace final_m0 with letter name.
// I put the rca measure at the beginning of the drills, so it should
// always be m0
let a = a.replace("final_m0", "a");
let b = b.replace("final_m0", "b");
// for clickhouse, need to make groupArray and Array Join clauses for drill_1 for when
// aggregating a to c, and b to d.
// (drill_2 would be needed if going from a to b)
// TODO refacto these lines out to helpers
let group_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column {
format!("groupArray({key_col}_{alias_postfix}) as {key_col}_{alias_postfix}_s, groupArray({name_col}_{alias_postfix}) as {name_col}_{alias_postfix}_s", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} else {
format!("groupArray({col}_{alias_postfix}) as {col}_{alias_postfix}_s", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let group_array_rca_drill_2 = join(group_array_rca_drill_2, ", ");
let join_array_rca_drill_2 = rca.drill_2.iter()
.flat_map(|d| {
let alias_postfix = &d.alias_postfix;
d.level_columns.iter().map(move |l| {
if let Some(ref name_col) = l.name_column {
format!("{key_col}_{alias_postfix}_s as {key_col}_{alias_postfix}, {name_col}_{alias_postfix}_s as {name_col}_{alias_postfix}", key_col=l.key_column, name_col=name_col, alias_postfix=alias_postfix)
} else {
format!("{col}_{alias_postfix}_s as {col}_{alias_postfix}", col=l.key_column, alias_postfix=alias_postfix)
}
})
});
let join_array_rca_drill_2 = join(join_array_rca_drill_2, ", ");
// Do GroupArray and Array Join clauses for external measures, also
let mea_cols = (1..=meas.len())
.map(|m_idx| format!("final_m{col}", col=m_idx));
let mea_cols = join(mea_cols, ", ");
let group_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("groupArray(final_m{col}) as final_m{col}_s", col=m_idx));
let group_array_ext_mea = join(group_array_ext_mea, ", ");
let join_array_ext_mea = (1..=meas.len())
.map(|m_idx| format!("final_m{col}_s as final_m{col}", col=m_idx));
let join_array_ext_mea = join(join_array_ext_mea, ", ");
// groupArray cols (the drill_2 from rca) can't be included in the group by or select
let c_drills_minus_rca_drill_2 = c_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let c_drills_minus_rca_drill_2 = join(c_drills_minus_rca_drill_2, ", ");
let d_drills_minus_rca_drill_2 = d_drills.iter()
.filter(|d| !rca.drill_2.contains(&d))
.map(|d| d.col_alias_only_string());
let d_drills_minus_rca_drill_2 = join(d_drills_minus_rca_drill_2, ", ");
// a and c drills are kept as-is
let a_drills_str = a_drills.iter()
.map(|d| d.col_alias_only_string());
let a_drills_str = join(a_drills_str, ", ");
let b_drills_str = b_drills.iter()
.map(|d| d.col_alias_only_string());
let b_drills_str = join(b_drills_str, ", ");
// Now add part c
let ac = format!("select {}, {}{} a, c from \
(select {}, {}, {}{} groupArray(a) as a_s, sum(a) as c from ({}) group by {}) \
Array Join {}, | {
// append the correct rca drill to drilldowns
// for a, both
// for b, d2
// for c, d1
// for d, none
let mut a_drills = drills.to_vec();
let mut b_drills = drills.to_vec();
let mut c_drills = drills.to_vec();
let d_drills = drills.to_vec();
a_drills.extend_from_slice(&rca.drill_1);
a_drills.extend_from_slice(&rca.drill_2);
b_drills.extend_from_slice(&rca.drill_2);
c_drills.extend_from_slice(&rca.drill_1);
println!("a: {:?}", a_drills);
println!("b: {:?}", b_drills); | identifier_body |
acss.go | , secret)
if err != nil {
return a.broadcastImplicate(err, msgs)
}
a.outS = myShare
a.tryOutput() // Maybe the READY messages are already received.
return a.handleImplicateRecoverPending(a.broadcastVote(msgVoteOK, msgs))
}
// > on receiving <OK> from n-f parties:
// > send <READY> to all parties
func (a *acssImpl) handleVoteOK(msg *msgVote) gpa.OutMessages {
a.voteOKRecv[msg.Sender()] = true
count := len(a.voteOKRecv)
if !a.voteREADYSent && count >= (a.n-a.f) {
a.voteREADYSent = true
return a.broadcastVote(msgVoteREADY, gpa.NoMessages())
}
return nil
}
// > on receiving <READY> from f+1 parties:
// > send <READY> to all parties
// >
// > on receiving <READY> from n-f parties:
// > if sᵢ is valid:
// > out = true
// > output sᵢ
func (a *acssImpl) handleVoteREADY(msg *msgVote) gpa.OutMessages {
a.voteREADYRecv[msg.Sender()] = true
count := len(a.voteREADYRecv)
msgs := gpa.NoMessages()
if !a.voteREADYSent && count >= (a.f+1) {
msgs = a.broadcastVote(msgVoteREADY, msgs)
a.voteREADYSent = true
}
a.tryOutput()
return a.handleImplicateRecoverPending(msgs)
}
// It is possible that we are receiving IMPLICATE/RECOVER messages before our RBC is completed.
// We store these messages for processing after that, if RBC is not done and process it otherwise.
func (a *acssImpl) handleImplicateRecoverReceived(msg *msgImplicateRecover) gpa.OutMessages {
if a.rbcOut == nil {
a.pendingIRMsgs = append(a.pendingIRMsgs, msg)
return nil
}
switch msg.kind {
case msgImplicateRecoverKindIMPLICATE:
return a.handleImplicate(msg)
case msgImplicateRecoverKindRECOVER:
return a.handleRecover(msg)
default:
panic(fmt.Errorf("handleImplicateRecoverReceived: unexpected msgImplicateRecover.kind=%v, message: %+v", msg.kind, msg))
}
}
func (a *acssImpl) handleImplicateRecoverPending(msgs gpa.OutMessages) gpa.OutMessages {
//
// Only process the IMPLICATE/RECOVER messages, if this node has RBC completed.
if a.rbcOut == nil {
return msgs
}
postponedIRMsgs := []*msgImplicateRecover{}
for _, m := range a.pendingIRMsgs {
switch m.kind {
case msgImplicateRecoverKindIMPLICATE:
// Only handle the IMPLICATE messages when output is already produced to implement the following:
//
// > if out == true:
// > send <RECOVER, i, skᵢ> to all parties
// > return
//
if a.output {
msgs.AddAll(a.handleImplicate(m))
} else {
postponedIRMsgs = append(postponedIRMsgs, m)
}
case msgImplicateRecoverKindRECOVER:
msgs.AddAll(a.handleRecover(m))
default:
panic(fmt.Errorf("handleImplicateRecoverReceived: unexpected msgImplicateRecover.kind=%v, message: %+v", m.kind, m))
}
}
a.pendingIRMsgs = postponedIRMsgs
return msgs
}
// Here the RBC is assumed to be completed already, OUT is set and the private key is checked.
//
// > on receiving <IMPLICATE, j, skⱼ>:
// > sⱼ := PKI.Dec(eⱼ, skⱼ)
// > if decrypt fails or VSS.Verify(C, j, sⱼ) == false:
// > if out == true:
// > send <RECOVER, i, skᵢ> to all parties
// > return
//
// NOTE: We assume `if out == true:` stands for a wait for such condition.
func (a *acssImpl) handleImplicate(msg *msgImplicateRecover) gpa.OutMessages {
peerIndex := a.peerIndex(msg.sender)
if peerIndex == -1 {
a.log.Warnf("implicate received from unknown peer: %v", msg.sender)
return nil
}
//
// Check message duplicates.
if _, ok := a.implicateRecv[msg.sender]; ok {
// Received the implicate before, just ignore it.
return nil
}
a.implicateRecv[msg.sender] = true
//
// Check implicate.
secret, err := crypto.CheckImplicate(a.suite, a.rbcOut.PubKey, a.peerPKs[msg.sender], msg.data)
if err != nil {
a.log.Warnf("Invalid implication received: %v", err)
return nil
}
_, err = crypto.DecryptShare(a.suite, a.rbcOut, peerIndex, secret)
if err == nil {
// if we are able to decrypt the share, the implication is not correct
a.log.Warn("encrypted share is valid")
return nil
}
//
// Create the reveal message.
return a.broadcastRecover(gpa.NoMessages())
}
// Here the RBC is assumed to be completed already and the private key is checked.
//
// > on receiving <RECOVER, j, skⱼ>:
// > sⱼ := PKI.Dec(eⱼ, skⱼ)
// > if VSS.Verify(C, j, sⱼ): T = T ∪ {sⱼ}
// >
// > wait until len(T) >= f+1:
// > sᵢ = SSS.Recover(T, f+1, n)(i)
// > out = true
// > output sᵢ
func (a *acssImpl) handleRecover(msg *msgImplicateRecover) gpa.OutMessages {
if a.output {
// Ignore the RECOVER messages, if we are done with the output.
return nil
}
peerIndex := a.peerIndex(msg.sender)
if peerIndex == -1 {
a.log.Warnf("Recover received from unexpected sender: %v", msg.sender)
return nil
}
if _, ok := a.recoverRecv[msg.sender]; ok {
a.log.Warnf("Recover was already received from %v", msg.sender)
return nil
}
peerSecret, err := crypto.DecryptShare(a.suite, a.rbcOut, peerIndex, msg.data)
if err != nil {
a.log.Warn("invalid secret revealed")
return nil
}
a.recoverRecv[msg.sender] = peerSecret
// > wait until len(T) >= f+1:
// > sᵢ = SSS.Recover(T, f+1, n)(i)
// > out = true
// > output sᵢ
if len(a.recoverRecv) >= a.f+1 {
priShares := []*share.PriShare{}
for i := range a.recoverRecv {
priShares = append(priShares, a.recoverRecv[i])
}
myPriShare, err := crypto.InterpolateShare(a.suite, priShares, a.n, a.myIdx)
if err != nil {
a.log.Warnf("Failed to recover pri-poly: %v", err)
}
a.outS = myPriShare
a.output = true
return nil
}
return nil
}
func (a *acssImpl) broadcastVote(voteKind msgVoteKind, msgs gpa.OutMessages) gpa.OutMessages {
for i := range a.peerIdx {
msg := &msgVote{
BasicMessage: gpa.NewBasicMessage(a.peerIdx[i]),
kind: voteKind,
}
msg.SetSender(a.me)
msgs.Add(msg)
}
return msgs
}
func (a *acssImpl) broadcastImplicate(reason error, msgs gpa.OutMessages) gpa.OutMessages {
a.log.Warnf("Sending implicate because of: %v", reason)
implicate := crypto.Implicate(a.suite, a.rbcOut.PubKey, a.mySK)
return a.broadcastImplicateRecover(msgImplicateRecoverKindIMPLICATE, implicate, msgs)
}
func (a *acssImpl) broadcastRecover(msgs gpa.OutMessages) gpa.OutMessages {
secret := crypto.Secret(a.suite, a.rbcOut.PubKey, a.mySK)
return a.broadcastImplicateRecover(msgImplicateRecoverKindRECOVER, secret, msgs)
}
func (a *acssImpl) broadcastImplicateRecover(kind msgImplicateKind, data []byte, msgs gpa.OutMessages) gpa.OutMessages {
for i := range a.peerIdx {
msgs.Add(&msgImplicateRecover{kind: kind, recipient: a.peerIdx[i], i: a.myIdx, data: data})
}
return msgs
}
func (a *acssImpl) tryOutput() {
count := len(a.voteREADYRecv)
if count >= (a.n-a.f) && a.outS != nil {
a.output = true |
}
}
fu | identifier_name |
|
acss.go | It can be provided by the dealer only.
func (a *acssImpl) Input(input gpa.Input) gpa.OutMessages {
if a.me != a.dealer {
panic(errors.New("only dealer can initiate the sharing"))
}
if input == nil {
panic(errors.New("we expect kyber.Scalar as input"))
}
return a.handleInput(input.(kyber.Scalar))
}
// Receive all the messages and route them to the appropriate handlers.
func (a *acssImpl) Message(msg gpa.Message) gpa.OutMessages {
switch m := msg.(type) {
case *gpa.WrappingMsg:
switch m.Subsystem() {
case subsystemRBC:
return a.handleRBCMessage(m)
default:
panic(fmt.Errorf("unexpected wrapped message: %+v", m))
}
case *msgVote:
switch m.kind {
case msgVoteOK:
return a.handleVoteOK(m)
case msgVoteREADY:
return a.handleVoteREADY(m)
default:
panic(fmt.Errorf("unexpected vote message: %+v", m))
}
case *msgImplicateRecover:
return a.handleImplicateRecoverReceived(m)
default:
panic(fmt.Errorf("unexpected message: %+v", msg))
}
}
// > // dealer with input s
// > sample random polynomial ϕ such that ϕ(0) = s
// > C, S := VSS.Share(ϕ, f+1, n)
// > E := [PKI.Enc(S[i], pkᵢ) for each party i]
// >
// > // party i (including the dealer)
// > RBC(C||E)
func (a *acssImpl) handleInput(secretToShare kyber.Scalar) gpa.OutMessages {
pubKeys := make([]kyber.Point, 0)
for _, peerID := range a.peerIdx {
pubKeys = append(pubKeys, a.peerPKs[peerID])
}
deal := crypto.NewDeal(a.suite, pubKeys, secretToShare)
data, err := deal.MarshalBinary()
if err != nil {
panic(fmt.Sprintf("acss: internal error: %v", err))
}
// > RBC(C||E)
rbcCEPayloadBytes := rwutil.WriteToBytes(&msgRBCCEPayload{suite: a.suite, data: data})
msgs := a.msgWrapper.WrapMessages(subsystemRBC, 0, a.rbc.Input(rbcCEPayloadBytes))
return a.tryHandleRBCTermination(false, msgs)
}
// Delegate received messages to the RBC and handle its output.
//
// > // party i (including the dealer)
// > RBC(C||E)
func (a *acssImpl) handleRBCMessage(m *gpa.WrappingMsg) gpa.OutMessages {
wasOut := a.rbc.Output() != nil // To send the msgRBCCEOutput message once (for perf reasons).
msgs := a.msgWrapper.WrapMessages(subsystemRBC, 0, a.rbc.Message(m.Wrapped()))
return a.tryHandleRBCTermination(wasOut, msgs)
}
func (a *acssImpl) tryHandleRBCTermination(wasOut bool, msgs gpa.OutMessages) gpa.OutMessages {
if out := a.rbc.Output(); !wasOut && out != nil {
// Send the result for self as a message (maybe the code will look nicer this way).
outParsed, err := rwutil.ReadFromBytes(out.([]byte), &msgRBCCEPayload{suite: a.suite})
if err != nil {
panic(fmt.Errorf("cannot unmarshal msgRBCCEPayload: %w", err))
}
msgs.AddAll(a.handleRBCOutput(outParsed))
}
return msgs
}
// Upon receiving the RBC output...
//
// > sᵢ := PKI.Dec(eᵢ, skᵢ)
// > if decrypt fails or VSS.Verify(C, i, sᵢ) == false:
// > send <IMPLICATE, i, skᵢ> to all parties
// > else:
// > send <OK>
func (a *acssImpl) handleRBCOutput(rbcOutput *msgRBCCEPayload) gpa.OutMessages {
if a.outS != nil || a.rbcOut != nil {
// Take the first RBC output only.
return nil
}
//
// Store the broadcast result and process pending IMPLICATE/RECOVER messages, if any.
deal, err := crypto.DealUnmarshalBinary(a.suite, a.n, rbcOutput.data)
if err != nil {
panic(errors.New("cannot unmarshal msgRBCCEPayload.data"))
}
a.rbcOut = deal
msgs := a.handleImplicateRecoverPending(gpa.NoMessages())
//
// Process the RBC output, as described above.
secret := crypto.Secret(a.suite, a.rbcOut.PubKey, a.mySK)
myShare, err := crypto.DecryptShare(a.suite, a.rbcOut, a.myIdx, secret)
if err != nil {
return a.broadcastImplicate(err, msgs)
}
a.outS = myShare
a.tryOutput() // Maybe the READY messages are already received.
return a.handleImplicateRecoverPending(a.broadcastVote(msgVoteOK, msgs))
}
// > on receiving <OK> from n-f parties:
// > send <READY> to all parties
func (a *acssImpl) handleVoteOK(msg *msgVote) gpa.OutMessages {
a.voteOKRecv[msg.Sender()] = true
count := len(a.voteOKRecv)
if !a.voteREADYSent && count >= (a.n-a.f) {
a.voteREADYSent = true
return a.broadcastVote(msgVoteREADY, gpa.NoMessages())
}
return nil
}
// > on receiving <READY> from f+1 parties:
// > send <READY> to all parties
// >
// > on receiving <READY> from n-f parties:
// > if sᵢ is valid:
// > out = true
// > output sᵢ
func (a *acssImpl) handleVoteREADY(msg *msgVote) gpa.OutMessages {
a.voteREADYRecv[msg.Sender()] = true
count := len(a.voteREADYRecv)
msgs := gpa.NoMessages()
if !a.voteREADYSent && count >= (a.f+1) {
msgs = a.broadcastVote(msgVoteREADY, msgs)
a.voteREADYSent = true
}
a.tryOutput()
return a.handleImplicateRecoverPending(msgs)
}
// It is possible that we are receiving IMPLICATE/RECOVER messages before our RBC is completed.
// We store these messages for processing after that, if RBC is not done and process it otherwise.
func (a *acssImpl) handleImplicateRecoverReceived(msg *msgImplicateRecover) gpa.OutMessages {
if a.rbcOut == nil {
a.pendingIRMsgs = append(a.pendingIRMsgs, msg)
return nil
}
switch msg.kind {
case msgImplicateRecoverKindIMPLICATE:
return a.handleImplicate(msg)
case msgImplicateRecoverKindRECOVER:
return a.handleRecover(msg)
default:
panic(fmt.Errorf("handleImplicateRecoverReceived: unexpected msgImplicateRecover.kind=%v, message: %+v", msg.kind, msg))
}
}
func (a *acssImpl) handleImplicateRecoverPending(msgs gpa.OutMessages) gpa.OutMessages {
//
// Only process the IMPLICATE/RECOVER messages, if this node has RBC completed.
if a.rbcOut == nil {
return msgs
}
postponedIRMsgs := []*msgImplicateRecover{}
for _, m := range a.pendingIRMsgs {
switch m.kind {
case msgImplicateRecoverKindIMPLICATE:
// Only handle the IMPLICATE messages when output is already produced to implement the following:
//
// > if out == true:
// > send <RECOVER, i, skᵢ> to all parties
// > return
//
if a.output {
msgs.AddAll(a.handleImplicate(m))
} else {
postponedIRMsgs = append(postponedIRMsgs, m)
}
case msgImplicateRecoverKindRECOVER:
msgs.AddAll(a.handleRecover(m))
default:
panic(fmt.Errorf("handleImplicateRecoverReceived: unexpected msgImplicateRecover.kind=%v, message: %+v", m.kind, m))
}
}
a.pendingIRMsgs = postponedIRMsgs
return msgs
}
// Here the RBC is assumed to be completed already, OUT is set and the private key is checked.
//
// > on receiving <IMPLICATE, j, skⱼ>:
// > sⱼ := PKI.Dec(eⱼ, skⱼ)
// > if decrypt fails or VSS.Verify(C, j, sⱼ) == false:
// > if out == true:
// > send <RECOVER, i, skᵢ> to all parties
// > return
// | // NOTE: We assume `if out == true:` stands for a wait for such condition.
func (a *acssImpl) handleImplicate(msg *msgImplicateRecover) gpa.OutMessages {
peerIndex := a.peerIndex(msg.sender)
if peerIndex == -1 { | random_line_split |
|
acss.go | dealer.
voteOKRecv map[gpa.NodeID]bool // A set of received OK votes.
voteREADYRecv map[gpa.NodeID]bool // A set of received READY votes.
voteREADYSent bool // Have we sent our READY vote?
pendingIRMsgs []*msgImplicateRecover // I/R messages are buffered, if the RBC is not completed yet.
implicateRecv map[gpa.NodeID]bool // To check, that implicate only received once from a node.
recoverRecv map[gpa.NodeID]*share.PriShare // Private shares from the RECOVER messages.
outS *share.PriShare // Our share of the secret (decrypted from rbcOutE).
output bool
msgWrapper *gpa.MsgWrapper
log *logger.Logger
}
var _ gpa.GPA = &acssImpl{}
func New(
suite suites.Suite, // Ed25519
peers []gpa.NodeID, // Participating nodes in a specific order.
peerPKs map[gpa.NodeID]kyber.Point, // Public keys for all the peers.
f int, // Max number of expected faulty nodes.
me gpa.NodeID, // ID of this node.
mySK kyber.Scalar, // Secret Key of this node.
dealer gpa.NodeID, // The dealer node for this protocol instance.
dealCB func(int, []byte) []byte, // For tests only: interceptor for the deal to be shared.
log *logger.Logger, // A logger to use.
) gpa.GPA {
n := len(peers)
if dealCB == nil {
dealCB = func(i int, b []byte) []byte { return b }
}
a := acssImpl{
suite: suite,
n: n,
f: f,
me: me,
mySK: mySK,
myPK: peerPKs[me],
myIdx: -1, // Updated bellow.
dealer: dealer,
dealCB: dealCB,
peerPKs: peerPKs,
peerIdx: peers,
rbc: rbc.New(peers, f, me, dealer, math.MaxInt, func(b []byte) bool { return true }), // TODO: Provide meaningful maxMsgSize
rbcOut: nil, // Will be set on output from the RBC.
voteOKRecv: map[gpa.NodeID]bool{},
voteREADYRecv: map[gpa.NodeID]bool{},
voteREADYSent: false,
pendingIRMsgs: []*msgImplicateRecover{},
implicateRecv: map[gpa.NodeID]bool{},
recoverRecv: map[gpa.NodeID]*share.PriShare{},
outS: nil,
output: false,
log: log,
}
a.msgWrapper = gpa.NewMsgWrapper(msgTypeWrapped, func(subsystem byte, index int) (gpa.GPA, error) {
if subsystem == subsystemRBC {
if index != 0 {
return nil, fmt.Errorf("unknown rbc index: %v", index)
}
return a.rbc, nil
}
return nil, fmt.Errorf("unknown subsystem: %v", subsystem)
})
if a.myIdx = a.peerIndex(me); a.myIdx == -1 {
panic("i'm not in the peer list")
}
return gpa.NewOwnHandler(me, &a)
}
// Input for the algorithm is the secret to share.
// It can be provided by the dealer only.
func (a *acssImpl) Input(input gpa.Input) gpa.OutMessages {
if a.me != a.dealer {
panic(errors.New("only dealer can initiate the sharing"))
}
if input == nil {
panic(errors.New("we expect kyber.Scalar as input"))
}
return a.handleInput(input.(kyber.Scalar))
}
// Receive all the messages and route them to the appropriate handlers.
func (a *acssImpl) Message(msg gpa.Message) gpa.OutMessages {
switch m := msg.(type) {
case *gpa.WrappingMsg:
switch m.Subsystem() {
case subsystemRBC:
return a.handleRBCMessage(m)
default:
panic(fmt.Errorf("unexpected wrapped message: %+v", m))
}
case *msgVote:
switch m.kind {
case msgVoteOK:
return a.handleVoteOK(m)
case msgVoteREADY:
return a.handleVoteREADY(m)
default:
panic(fmt.Errorf("unexpected vote message: %+v", m))
}
case *msgImplicateRecover:
return a.handleImplicateRecoverReceived(m)
default:
panic(fmt.Errorf("unexpected message: %+v", msg))
}
}
// > // dealer with input s
// > sample random polynomial ϕ such that ϕ(0) = s
// > C, S := VSS.Share(ϕ, f+1, n)
// > E := [PKI.Enc(S[i], pkᵢ) for each party i]
// >
// > // party i (including the dealer)
// > RBC(C||E)
func (a *acssImpl) handleInput(secretToShare kyber.Scalar) gpa.OutMessages {
pubKeys := make([]kyber.Point, 0)
for _, peerID := range a.peerIdx {
pubKeys = append(pubKeys, a.peerPKs[peerID])
}
deal := crypto.NewDeal(a.suite, pubKeys, secretToShare)
data, err := deal.MarshalBinary()
if err != nil {
panic(fmt.Sprintf("acss: internal error: %v", err))
}
// > RBC(C||E)
rbcCEPayloadBytes := rwutil.WriteToBytes(&msgRBCCEPayload{suite: a.suite, data: data})
msgs := a.msgWrapper.WrapMessages(subsystemRBC, 0, a.rbc.Input(rbcCEPayloadBytes))
return a.tryHandleRBCTermination(false, msgs)
}
// Delegate received messages to the RBC and handle its output.
//
// > // party i (including the dealer)
// > RBC(C||E)
func (a *acssImpl) handleRBCMessage(m *gpa.WrappingMsg) gpa.OutMessages {
wasOut := a.rbc.Output() != nil // To send the msgRBCCEOutput message once (for perf reasons).
msgs := a.msgWrapper.WrapMessages(subsystemRBC, 0, a.rbc.Message(m.Wrapped()))
return a.tryHandleRBCTermination(wasOut, msgs)
}
func (a *acssImpl) tryHandleRBCTermination(wasOut bool, msgs gpa.OutMessages) gpa.OutMessages {
if out := a.rbc.Output(); !wasOut && out != nil {
// Send the result for self as a message (maybe the code will look nicer this way).
outParsed, err := rwutil.ReadFromBytes(out.([]byte), &msgRBCCEPayload{suite: a.suite})
if err != nil {
panic(fmt.Errorf("cannot unmarshal msgRBCCEPayload: %w", err))
}
msgs.AddAll(a.handleRBCOutput(outParsed))
}
return msgs
}
// Upon receiving the RBC output...
//
// > sᵢ := PKI.Dec(eᵢ, skᵢ)
// > if decrypt fails or VSS.Verify(C, i, sᵢ) == false:
// > send <IMPLICATE, i, skᵢ> to all parties
// > else:
// > send <OK>
func (a *acssImpl) handleRBCOutput(rbcOutput *msgRBCCEPayload) gpa.OutMessages {
if a.outS != nil || a.rbcOut != nil {
// Take the first RBC output only.
return nil
}
//
// Store the broadcast result and process pending IMPLICATE/RECOVER messages, if any.
deal, err := crypto.DealUnmarshalBinary(a.suite, a.n, rbcOutput.data)
if err != nil {
panic(errors.New("cannot unmarshal msgRBCCEPayload.data"))
}
a.rbcOut = deal
msgs := a.handleImplicateRecoverPending(gpa.NoMessages())
//
// Process the RBC output, as described above.
secret := crypto.Secret(a.suite, a.rbcOut.PubKey, a.mySK)
myShare, err := crypto.DecryptShare(a.suite, a.rbcOut, a.myIdx, secret)
if err != nil {
return a.broadcastImplicate(err, msgs)
}
a.outS = myShare
a.tryOutput() // Maybe the READY messages are already received.
return a.handleImplicateRecoverPending(a.broadcastVote(msgVoteOK, msgs))
}
// > on receiving <OK> from n-f parties:
// > send <READY> to all parties
func (a *acssImpl) handleVoteOK(msg *msgVote) gpa.OutMessages {
a.voteOKRecv[msg.Sender()] = true
count := len(a.voteOKRecv) |
if !a.voteREADYSent && count >= (a.n-a.f) {
a.voteREADYSent = true
return a.broadcastVote(msgVoteREADY, gpa.NoMessages())
}
return nil
}
// > on receiving <READY> from f+1 parties:
// > send <READY | identifier_body |
|
acss.go | github.com/tyurek/hbACSS
//
// A PoC implementation: <https://github.com/Wollac/async.go>.
//
// The Crypto part shown the pseudo-code above is replaced in the implementation with the
// scheme allowing to keep the private keys secret. The scheme implementation is taken
// from the PoC mentioned above. It is described in <https://hackmd.io/@CcRtfCBnRbW82-AdbFJUig/S1qcPiUN5>.
package acss
import (
"errors"
"fmt"
"math"
"go.dedis.ch/kyber/v3"
"go.dedis.ch/kyber/v3/share"
"go.dedis.ch/kyber/v3/suites"
"github.com/iotaledger/hive.go/logger"
"github.com/iotaledger/wasp/packages/gpa"
"github.com/iotaledger/wasp/packages/gpa/acss/crypto"
rbc "github.com/iotaledger/wasp/packages/gpa/rbc/bracha"
"github.com/iotaledger/wasp/packages/util/rwutil"
)
const (
subsystemRBC byte = iota
)
type Output struct {
PriShare *share.PriShare // Private share, received by this instance.
Commits []kyber.Point // Feldman's commitment to the shared polynomial.
}
type acssImpl struct {
suite suites.Suite
n int
f int
me gpa.NodeID
mySK kyber.Scalar
myPK kyber.Point
myIdx int
dealer gpa.NodeID // A node that is recognized as a dealer.
dealCB func(int, []byte) []byte // Callback to be called on the encrypted deals (for tests actually).
peerPKs map[gpa.NodeID]kyber.Point // Peer public keys.
peerIdx []gpa.NodeID // Particular order of the nodes (position in the polynomial).
rbc gpa.GPA // RBC to share `C||E`.
rbcOut *crypto.Deal // Deal broadcasted by the dealer.
voteOKRecv map[gpa.NodeID]bool // A set of received OK votes.
voteREADYRecv map[gpa.NodeID]bool // A set of received READY votes.
voteREADYSent bool // Have we sent our READY vote?
pendingIRMsgs []*msgImplicateRecover // I/R messages are buffered, if the RBC is not completed yet.
implicateRecv map[gpa.NodeID]bool // To check, that implicate only received once from a node.
recoverRecv map[gpa.NodeID]*share.PriShare // Private shares from the RECOVER messages.
outS *share.PriShare // Our share of the secret (decrypted from rbcOutE).
output bool
msgWrapper *gpa.MsgWrapper
log *logger.Logger
}
var _ gpa.GPA = &acssImpl{}
func New(
suite suites.Suite, // Ed25519
peers []gpa.NodeID, // Participating nodes in a specific order.
peerPKs map[gpa.NodeID]kyber.Point, // Public keys for all the peers.
f int, // Max number of expected faulty nodes.
me gpa.NodeID, // ID of this node.
mySK kyber.Scalar, // Secret Key of this node.
dealer gpa.NodeID, // The dealer node for this protocol instance.
dealCB func(int, []byte) []byte, // For tests only: interceptor for the deal to be shared.
log *logger.Logger, // A logger to use.
) gpa.GPA {
n := len(peers)
if dealCB == nil {
dealCB = func(i int, b []byte) []byte { return b }
}
a := acssImpl{
suite: suite,
n: n,
f: f,
me: me,
mySK: mySK,
myPK: peerPKs[me],
myIdx: -1, // Updated bellow.
dealer: dealer,
dealCB: dealCB,
peerPKs: peerPKs,
peerIdx: peers,
rbc: rbc.New(peers, f, me, dealer, math.MaxInt, func(b []byte) bool { return true }), // TODO: Provide meaningful maxMsgSize
rbcOut: nil, // Will be set on output from the RBC.
voteOKRecv: map[gpa.NodeID]bool{},
voteREADYRecv: map[gpa.NodeID]bool{},
voteREADYSent: false,
pendingIRMsgs: []*msgImplicateRecover{},
implicateRecv: map[gpa.NodeID]bool{},
recoverRecv: map[gpa.NodeID]*share.PriShare{},
outS: nil,
output: false,
log: log,
}
a.msgWrapper = gpa.NewMsgWrapper(msgTypeWrapped, func(subsystem byte, index int) (gpa.GPA, error) {
if subsystem == subsystemRBC {
if index != 0 {
return nil, fmt.Errorf("unknown rbc index: %v", index)
}
return a.rbc, nil
}
return nil, fmt.Errorf("unknown subsystem: %v", subsystem)
})
if a.myIdx = a.peerIndex(me); a.myIdx == -1 {
panic("i'm not in the peer list")
}
return | r the algorithm is the secret to share.
// It can be provided by the dealer only.
func (a *acssImpl) Input(input gpa.Input) gpa.OutMessages {
if a.me != a.dealer {
panic(errors.New("only dealer can initiate the sharing"))
}
if input == nil {
panic(errors.New("we expect kyber.Scalar as input"))
}
return a.handleInput(input.(kyber.Scalar))
}
// Receive all the messages and route them to the appropriate handlers.
func (a *acssImpl) Message(msg gpa.Message) gpa.OutMessages {
switch m := msg.(type) {
case *gpa.WrappingMsg:
switch m.Subsystem() {
case subsystemRBC:
return a.handleRBCMessage(m)
default:
panic(fmt.Errorf("unexpected wrapped message: %+v", m))
}
case *msgVote:
switch m.kind {
case msgVoteOK:
return a.handleVoteOK(m)
case msgVoteREADY:
return a.handleVoteREADY(m)
default:
panic(fmt.Errorf("unexpected vote message: %+v", m))
}
case *msgImplicateRecover:
return a.handleImplicateRecoverReceived(m)
default:
panic(fmt.Errorf("unexpected message: %+v", msg))
}
}
// > // dealer with input s
// > sample random polynomial ϕ such that ϕ(0) = s
// > C, S := VSS.Share(ϕ, f+1, n)
// > E := [PKI.Enc(S[i], pkᵢ) for each party i]
// >
// > // party i (including the dealer)
// > RBC(C||E)
func (a *acssImpl) handleInput(secretToShare kyber.Scalar) gpa.OutMessages {
pubKeys := make([]kyber.Point, 0)
for _, peerID := range a.peerIdx {
pubKeys = append(pubKeys, a.peerPKs[peerID])
}
deal := crypto.NewDeal(a.suite, pubKeys, secretToShare)
data, err := deal.MarshalBinary()
if err != nil {
panic(fmt.Sprintf("acss: internal error: %v", err))
}
// > RBC(C||E)
rbcCEPayloadBytes := rwutil.WriteToBytes(&msgRBCCEPayload{suite: a.suite, data: data})
msgs := a.msgWrapper.WrapMessages(subsystemRBC, 0, a.rbc.Input(rbcCEPayloadBytes))
return a.tryHandleRBCTermination(false, msgs)
}
// Delegate received messages to the RBC and handle its output.
//
// > // party i (including the dealer)
// > RBC(C||E)
func (a *acssImpl) handleRBCMessage(m *gpa.WrappingMsg) gpa.OutMessages {
wasOut := a.rbc.Output() != nil // To send the msgRBCCEOutput message once (for perf reasons).
msgs := a.msgWrapper.WrapMessages(subsystemRBC, 0, a.rbc.Message(m.Wrapped()))
return a.tryHandleRBCTermination(wasOut, msgs)
}
func (a *acssImpl) tryHandleRBCTermination(wasOut bool, msgs gpa.OutMessages) gpa.OutMessages {
if out := a.rbc.Output(); !wasOut && out != nil {
// Send the result for self as a message (maybe the code will look nicer this way).
outParsed, err := rwutil.ReadFromBytes(out.([]byte), &msgRBCCEPayload{suite: a.suite})
if err != nil {
panic(fmt.Errorf("cannot unmarshal msgRBCCEPayload: %w", err))
}
msgs.AddAll(a.handleRBCOutput(outParsed))
}
return msgs
}
// Upon receiving the RBC output | gpa.NewOwnHandler(me, &a)
}
// Input fo | conditional_block |
discord.go | bot.state.Open(); discordErr != nil {
return nil, discordErr
}
// Get our Discord user
self, discordErr := bot.state.Me()
if discordErr != nil {
return nil, discordErr
}
// Set our data and create the Minecraft watcher
bot.id = self.ID
bot.name = self.Username
bot.avatarURL = self.AvatarURL()
if Config.Discord.ChannelID != "" {
snowflake, discordErr := discord.ParseSnowflake(Config.Discord.ChannelID)
if discordErr != nil |
bot.channel = discord.ChannelID(snowflake)
} else {
return nil, errors.New("no channel ID configured")
}
bot.watcher = NewWatcher(self.Username, *Config.Minecraft.CustomDeathKeywords)
return bot, discordErr
}
// Close cleans up the watcher and closes the Discord session.
func (bot *DiscordBot) Close() error {
var closeErr error
if err := bot.watcher.Close(); err != nil {
closeErr = err
}
if err := bot.state.Session.Close(); err != nil {
closeErr = err
}
return closeErr
}
// WaitForMessages starts the Minecraft log watcher and waits for messages
// on a messages channel.
func (bot *DiscordBot) WaitForMessages() {
// Make our messages channel
mc := make(chan *MinecraftMessage)
// Start our Minecraft watcher
go bot.watcher.Watch(mc)
for {
// Read message from the channel
msg := <-mc
Log.Debugf("Received a line from Minecraft: Username='%s', Text='%s'\n", msg.Username, msg.Message)
// Don't send messages that are disabled
switch msg.Type {
case AdvancementMessage:
{
if !Config.Discord.MessageOptions.ShowAdvancements {
continue
}
}
case DeathMessage:
{
if !Config.Discord.MessageOptions.ShowDeaths {
continue
}
}
case JoinLeaveMessage:
{
if !Config.Discord.MessageOptions.ShowJoinsLeaves {
continue
}
}
}
// Send the message to the Discord channel
bot.sendToDiscord(msg)
}
}
// onReady sets the bot's Discord status.
func (bot *DiscordBot) onReady(e *gateway.ReadyEvent) {
// Set the bot gaming status
err := bot.state.Gateway.UpdateStatus(gateway.UpdateStatusData{
Game: &discord.Activity{
Name: "Bridging the Minecraft/Discord gap",
},
})
if err != nil {
Log.Errorf("Unable to update Discord status: %s\n", err)
}
}
// onGuildCreate handles when the bot joins or connects to a Guild.
func (bot *DiscordBot) onGuildCreate(e *gateway.GuildCreateEvent) {
// Make sure the guild is available
if e.Unavailable {
Log.Warnf("Attempted to join Guild '%s', but it was unavailable\n", e.Guild.Name)
return
}
if bot.guildID.String() != "" {
Log.Warnf("Received a Guild join event for '%s', but we've already joined one\n", e.Guild.Name)
return
}
Log.Infof("Connected to guild named '%s'\n", e.Guild.Name)
bot.guildID = e.Guild.ID
}
// onMessageCreate handles messages that the bot receives, and sends them
// to Minecraft via RCON.
func (bot *DiscordBot) onMessageCreate(e *gateway.MessageCreateEvent) {
// Ignore messages from ourselves
if e.Author.ID != bot.id && e.Message.WebhookID.String() == "" {
// Check if the message is a bot command
if strings.HasPrefix(e.Message.Content, "!") {
c := make(chan bool)
go parser.Parse(e.Message, bot.state, c)
// Don't go any further if the command was found and ran
if <-c {
return
}
}
// Not a command, so ignore messages from other channels
if e.ChannelID.String() == Config.Discord.ChannelID {
Log.Debugln("Received a message from Discord")
// Get the name to use
var name string
if Config.Discord.UseMemberNicks {
name = bot.getNickname(e.Author.ID)
} else {
name = e.Author.Username
}
// Print the URL if message contains an attachement but no message content
if len(e.Message.Attachments) > 0 {
if len(e.Content) == 0 {
e.Content = e.Message.Attachments[0].URL
if err := sendToMinecraft(e.Content, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
return
}
}
content := formatMessage(bot.state, e.Message)
lines := strings.Split(content, "\n")
// Send a separate message for each line
for i := 0; i < len(lines); i++ {
line := lines[i]
// Split long lines into additional messages
if len(line) > 100 {
lines = append(lines, "")
copy(lines[i+2:], lines[i+1:])
lines[i+1] = line[100:]
line = line[:100]
}
if err := sendToMinecraft(line, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
}
}
}
}
// sendToDiscord sends a message from Minecraft to the configured
// Discord channel.
func (bot *DiscordBot) sendToDiscord(m *MinecraftMessage) {
// Insert Discord mentions if configured and present
if Config.Discord.AllowMentions {
// Insert Discord mentions
m.Message = bot.insertMentions(m.Message)
}
// Send the message to Discord either via webhook or normal channel message
if Config.Discord.Webhook.Enabled {
// Get the configured webhook
id, token := matchWebhookURL(Config.Discord.Webhook.URL)
if id == "" || token == "" {
Log.Warnln("Invalid or undefined Discord webhook URL")
return
}
// Attempt to get the webhook
snowflake, err := discord.ParseSnowflake(id)
if err != nil {
Log.Errorf("Error parsing Webhook Snowflake: %s\n", err.Error())
}
webhookID := discord.WebhookID(snowflake)
// Form our webhook params
params := bot.setWebhookParams(m)
// Send to the webhook
Log.Debugf("Sending to webhook: id='%s', token='%s'\n", id, token)
if err := webhook.Execute(webhookID, token, params); err != nil {
Log.Errorf("Error sending data to Discord webhook: %s\n", err.Error())
}
} else {
// Format the message for Discord
formatted := fmt.Sprintf("**%s**: %s", m.Username, m.Message)
// Send to the configured Discord channel
if _, err := bot.state.Client.SendMessage(bot.channel, formatted, nil); err != nil {
Log.Errorf("Error sending a message to Discord: %s\n", err.Error())
}
}
}
// getNickname gets the nickname of a Discord user in a Guild.
func (bot *DiscordBot) getNickname(id discord.UserID) string {
var m *discord.Member
// Look in the cached state for the Member
m, _ = bot.state.Member(bot.guildID, id)
// Make sure we do have a user
if m == nil {
return ""
}
if m.Nick == "" {
return m.User.Username
}
return m.Nick
}
// getUserFromName gets the Discord user from a mention or username. The username
// can be only a partial username.
func (bot *DiscordBot) getUserFromName(text string) (target *discord.User) {
// Look through all guild members in the state
members, _ := bot.state.Members(bot.guildID)
for _, u := range members {
// Check if the name matches, case-insensitive
if strings.EqualFold(u.User.Username, text) {
target = &u.User
break
}
}
return target
}
// insertMentions looks for potential Discord mentions in a Minecraft chat
// message. If there are any, we will attempt to get the user being mentioned
// to get their mention string to put into the chat message.
func (bot *DiscordBot) insertMentions(msg string) string {
// Split the message into words
words := strings.Split(msg, " ")
// Iterate over each word
for _, word := range words {
// Check if the word might be a mention
if strings.HasPrefix(word, "@") {
// Attempt to get the user
user := bot.getUserFromName(word[1:])
if user != nil {
// Replace the word with the mention
msg = strings.Replace(msg, word, user.Mention(), 1)
}
}
}
return msg
}
func matchWebhookURL(url string) (string, string) {
wm := webhookRegex.FindStringSubmatch(url)
| {
return nil, discordErr
} | conditional_block |
discord.go | bot.state.Open(); discordErr != nil {
return nil, discordErr
}
// Get our Discord user
self, discordErr := bot.state.Me()
if discordErr != nil {
return nil, discordErr
}
// Set our data and create the Minecraft watcher
bot.id = self.ID
bot.name = self.Username
bot.avatarURL = self.AvatarURL()
if Config.Discord.ChannelID != "" {
snowflake, discordErr := discord.ParseSnowflake(Config.Discord.ChannelID)
if discordErr != nil {
return nil, discordErr
}
bot.channel = discord.ChannelID(snowflake)
} else {
return nil, errors.New("no channel ID configured")
}
bot.watcher = NewWatcher(self.Username, *Config.Minecraft.CustomDeathKeywords)
return bot, discordErr
}
// Close cleans up the watcher and closes the Discord session.
func (bot *DiscordBot) Close() error {
var closeErr error
if err := bot.watcher.Close(); err != nil {
closeErr = err
}
if err := bot.state.Session.Close(); err != nil {
closeErr = err
}
return closeErr
}
// WaitForMessages starts the Minecraft log watcher and waits for messages
// on a messages channel.
func (bot *DiscordBot) | () {
// Make our messages channel
mc := make(chan *MinecraftMessage)
// Start our Minecraft watcher
go bot.watcher.Watch(mc)
for {
// Read message from the channel
msg := <-mc
Log.Debugf("Received a line from Minecraft: Username='%s', Text='%s'\n", msg.Username, msg.Message)
// Don't send messages that are disabled
switch msg.Type {
case AdvancementMessage:
{
if !Config.Discord.MessageOptions.ShowAdvancements {
continue
}
}
case DeathMessage:
{
if !Config.Discord.MessageOptions.ShowDeaths {
continue
}
}
case JoinLeaveMessage:
{
if !Config.Discord.MessageOptions.ShowJoinsLeaves {
continue
}
}
}
// Send the message to the Discord channel
bot.sendToDiscord(msg)
}
}
// onReady sets the bot's Discord status.
func (bot *DiscordBot) onReady(e *gateway.ReadyEvent) {
// Set the bot gaming status
err := bot.state.Gateway.UpdateStatus(gateway.UpdateStatusData{
Game: &discord.Activity{
Name: "Bridging the Minecraft/Discord gap",
},
})
if err != nil {
Log.Errorf("Unable to update Discord status: %s\n", err)
}
}
// onGuildCreate handles when the bot joins or connects to a Guild.
func (bot *DiscordBot) onGuildCreate(e *gateway.GuildCreateEvent) {
// Make sure the guild is available
if e.Unavailable {
Log.Warnf("Attempted to join Guild '%s', but it was unavailable\n", e.Guild.Name)
return
}
if bot.guildID.String() != "" {
Log.Warnf("Received a Guild join event for '%s', but we've already joined one\n", e.Guild.Name)
return
}
Log.Infof("Connected to guild named '%s'\n", e.Guild.Name)
bot.guildID = e.Guild.ID
}
// onMessageCreate handles messages that the bot receives, and sends them
// to Minecraft via RCON.
func (bot *DiscordBot) onMessageCreate(e *gateway.MessageCreateEvent) {
// Ignore messages from ourselves
if e.Author.ID != bot.id && e.Message.WebhookID.String() == "" {
// Check if the message is a bot command
if strings.HasPrefix(e.Message.Content, "!") {
c := make(chan bool)
go parser.Parse(e.Message, bot.state, c)
// Don't go any further if the command was found and ran
if <-c {
return
}
}
// Not a command, so ignore messages from other channels
if e.ChannelID.String() == Config.Discord.ChannelID {
Log.Debugln("Received a message from Discord")
// Get the name to use
var name string
if Config.Discord.UseMemberNicks {
name = bot.getNickname(e.Author.ID)
} else {
name = e.Author.Username
}
// Print the URL if message contains an attachement but no message content
if len(e.Message.Attachments) > 0 {
if len(e.Content) == 0 {
e.Content = e.Message.Attachments[0].URL
if err := sendToMinecraft(e.Content, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
return
}
}
content := formatMessage(bot.state, e.Message)
lines := strings.Split(content, "\n")
// Send a separate message for each line
for i := 0; i < len(lines); i++ {
line := lines[i]
// Split long lines into additional messages
if len(line) > 100 {
lines = append(lines, "")
copy(lines[i+2:], lines[i+1:])
lines[i+1] = line[100:]
line = line[:100]
}
if err := sendToMinecraft(line, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
}
}
}
}
// sendToDiscord sends a message from Minecraft to the configured
// Discord channel.
func (bot *DiscordBot) sendToDiscord(m *MinecraftMessage) {
// Insert Discord mentions if configured and present
if Config.Discord.AllowMentions {
// Insert Discord mentions
m.Message = bot.insertMentions(m.Message)
}
// Send the message to Discord either via webhook or normal channel message
if Config.Discord.Webhook.Enabled {
// Get the configured webhook
id, token := matchWebhookURL(Config.Discord.Webhook.URL)
if id == "" || token == "" {
Log.Warnln("Invalid or undefined Discord webhook URL")
return
}
// Attempt to get the webhook
snowflake, err := discord.ParseSnowflake(id)
if err != nil {
Log.Errorf("Error parsing Webhook Snowflake: %s\n", err.Error())
}
webhookID := discord.WebhookID(snowflake)
// Form our webhook params
params := bot.setWebhookParams(m)
// Send to the webhook
Log.Debugf("Sending to webhook: id='%s', token='%s'\n", id, token)
if err := webhook.Execute(webhookID, token, params); err != nil {
Log.Errorf("Error sending data to Discord webhook: %s\n", err.Error())
}
} else {
// Format the message for Discord
formatted := fmt.Sprintf("**%s**: %s", m.Username, m.Message)
// Send to the configured Discord channel
if _, err := bot.state.Client.SendMessage(bot.channel, formatted, nil); err != nil {
Log.Errorf("Error sending a message to Discord: %s\n", err.Error())
}
}
}
// getNickname gets the nickname of a Discord user in a Guild.
func (bot *DiscordBot) getNickname(id discord.UserID) string {
var m *discord.Member
// Look in the cached state for the Member
m, _ = bot.state.Member(bot.guildID, id)
// Make sure we do have a user
if m == nil {
return ""
}
if m.Nick == "" {
return m.User.Username
}
return m.Nick
}
// getUserFromName gets the Discord user from a mention or username. The username
// can be only a partial username.
func (bot *DiscordBot) getUserFromName(text string) (target *discord.User) {
// Look through all guild members in the state
members, _ := bot.state.Members(bot.guildID)
for _, u := range members {
// Check if the name matches, case-insensitive
if strings.EqualFold(u.User.Username, text) {
target = &u.User
break
}
}
return target
}
// insertMentions looks for potential Discord mentions in a Minecraft chat
// message. If there are any, we will attempt to get the user being mentioned
// to get their mention string to put into the chat message.
func (bot *DiscordBot) insertMentions(msg string) string {
// Split the message into words
words := strings.Split(msg, " ")
// Iterate over each word
for _, word := range words {
// Check if the word might be a mention
if strings.HasPrefix(word, "@") {
// Attempt to get the user
user := bot.getUserFromName(word[1:])
if user != nil {
// Replace the word with the mention
msg = strings.Replace(msg, word, user.Mention(), 1)
}
}
}
return msg
}
func matchWebhookURL(url string) (string, string) {
wm := webhookRegex.FindStringSubmatch(url)
| WaitForMessages | identifier_name |
discord.go | (bot *DiscordBot) onGuildCreate(e *gateway.GuildCreateEvent) {
// Make sure the guild is available
if e.Unavailable {
Log.Warnf("Attempted to join Guild '%s', but it was unavailable\n", e.Guild.Name)
return
}
if bot.guildID.String() != "" {
Log.Warnf("Received a Guild join event for '%s', but we've already joined one\n", e.Guild.Name)
return
}
Log.Infof("Connected to guild named '%s'\n", e.Guild.Name)
bot.guildID = e.Guild.ID
}
// onMessageCreate handles messages that the bot receives, and sends them
// to Minecraft via RCON.
func (bot *DiscordBot) onMessageCreate(e *gateway.MessageCreateEvent) {
// Ignore messages from ourselves
if e.Author.ID != bot.id && e.Message.WebhookID.String() == "" {
// Check if the message is a bot command
if strings.HasPrefix(e.Message.Content, "!") {
c := make(chan bool)
go parser.Parse(e.Message, bot.state, c)
// Don't go any further if the command was found and ran
if <-c {
return
}
}
// Not a command, so ignore messages from other channels
if e.ChannelID.String() == Config.Discord.ChannelID {
Log.Debugln("Received a message from Discord")
// Get the name to use
var name string
if Config.Discord.UseMemberNicks {
name = bot.getNickname(e.Author.ID)
} else {
name = e.Author.Username
}
// Print the URL if message contains an attachement but no message content
if len(e.Message.Attachments) > 0 {
if len(e.Content) == 0 {
e.Content = e.Message.Attachments[0].URL
if err := sendToMinecraft(e.Content, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
return
}
}
content := formatMessage(bot.state, e.Message)
lines := strings.Split(content, "\n")
// Send a separate message for each line
for i := 0; i < len(lines); i++ {
line := lines[i]
// Split long lines into additional messages
if len(line) > 100 {
lines = append(lines, "")
copy(lines[i+2:], lines[i+1:])
lines[i+1] = line[100:]
line = line[:100]
}
if err := sendToMinecraft(line, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
}
}
}
}
// sendToDiscord sends a message from Minecraft to the configured
// Discord channel.
func (bot *DiscordBot) sendToDiscord(m *MinecraftMessage) {
// Insert Discord mentions if configured and present
if Config.Discord.AllowMentions {
// Insert Discord mentions
m.Message = bot.insertMentions(m.Message)
}
// Send the message to Discord either via webhook or normal channel message
if Config.Discord.Webhook.Enabled {
// Get the configured webhook
id, token := matchWebhookURL(Config.Discord.Webhook.URL)
if id == "" || token == "" {
Log.Warnln("Invalid or undefined Discord webhook URL")
return
}
// Attempt to get the webhook
snowflake, err := discord.ParseSnowflake(id)
if err != nil {
Log.Errorf("Error parsing Webhook Snowflake: %s\n", err.Error())
}
webhookID := discord.WebhookID(snowflake)
// Form our webhook params
params := bot.setWebhookParams(m)
// Send to the webhook
Log.Debugf("Sending to webhook: id='%s', token='%s'\n", id, token)
if err := webhook.Execute(webhookID, token, params); err != nil {
Log.Errorf("Error sending data to Discord webhook: %s\n", err.Error())
}
} else {
// Format the message for Discord
formatted := fmt.Sprintf("**%s**: %s", m.Username, m.Message)
// Send to the configured Discord channel
if _, err := bot.state.Client.SendMessage(bot.channel, formatted, nil); err != nil {
Log.Errorf("Error sending a message to Discord: %s\n", err.Error())
}
}
}
// getNickname gets the nickname of a Discord user in a Guild.
func (bot *DiscordBot) getNickname(id discord.UserID) string {
var m *discord.Member
// Look in the cached state for the Member
m, _ = bot.state.Member(bot.guildID, id)
// Make sure we do have a user
if m == nil {
return ""
}
if m.Nick == "" {
return m.User.Username
}
return m.Nick
}
// getUserFromName gets the Discord user from a mention or username. The username
// can be only a partial username.
func (bot *DiscordBot) getUserFromName(text string) (target *discord.User) {
// Look through all guild members in the state
members, _ := bot.state.Members(bot.guildID)
for _, u := range members {
// Check if the name matches, case-insensitive
if strings.EqualFold(u.User.Username, text) {
target = &u.User
break
}
}
return target
}
// insertMentions looks for potential Discord mentions in a Minecraft chat
// message. If there are any, we will attempt to get the user being mentioned
// to get their mention string to put into the chat message.
func (bot *DiscordBot) insertMentions(msg string) string {
// Split the message into words
words := strings.Split(msg, " ")
// Iterate over each word
for _, word := range words {
// Check if the word might be a mention
if strings.HasPrefix(word, "@") {
// Attempt to get the user
user := bot.getUserFromName(word[1:])
if user != nil {
// Replace the word with the mention
msg = strings.Replace(msg, word, user.Mention(), 1)
}
}
}
return msg
}
func matchWebhookURL(url string) (string, string) {
wm := webhookRegex.FindStringSubmatch(url)
// Make sure we have the correct number of parts (ID and token)
if len(wm) != 3 {
return "", ""
}
// Return the webhook ID and token
return wm[1], wm[2]
}
// setWebhookParams sets the avater, username, and message for a webhook request.
func (bot *DiscordBot) setWebhookParams(m *MinecraftMessage) api.ExecuteWebhookData {
// Get the avatar to use for this message
var avatarURL string
if m.Username == bot.name {
// Use the bot's avatar
avatarURL = bot.avatarURL
} else {
// Player's Minecraft head as the avatar
avatarURL = fmt.Sprintf("https://minotar.net/helm/%s/256.png", m.Username)
}
return api.ExecuteWebhookData{
Content: m.Message,
Username: m.Username,
AvatarURL: avatarURL,
}
}
func formatMessage(state *state.State, message discord.Message) string {
content := message.Content
// Replace mentions
for _, word := range strings.Split(content, " ") {
if strings.HasPrefix(word, "<#") && strings.HasSuffix(word, ">") {
// Get the ID from the mention string
id := word[2 : len(word)-1]
snowflake, _ := discord.ParseSnowflake(id)
channelID := discord.ChannelID(snowflake)
channel, err := state.Channel(channelID)
if err != nil {
Log.Warnf("Error while getting channel from Discord: %s\n", err)
continue
}
content = strings.Replace(content, fmt.Sprintf("<#%s>", id), fmt.Sprintf("#%s", channel.Name), -1)
}
}
for _, member := range message.Mentions {
content = strings.Replace(content, fmt.Sprintf("<@!%s>", member.ID), fmt.Sprintf("@%s", member.Username), -1)
}
// Escape quote characters
content = strings.Replace(content, "\"", "\\\"", -1)
return content
}
func sendToMinecraft(content, username string) error | {
// Format command to send to the Minecraft server
command := fmt.Sprintf("tellraw @a %s", Config.Minecraft.TellrawTemplate)
command = strings.Replace(command, "%username%", username, -1)
command = strings.Replace(command, "%message%", content, -1)
// Create RCON connection
conn, err := rcon.Dial(Config.Minecraft.RconIP, Config.Minecraft.RconPort, Config.Minecraft.RconPassword)
if err != nil {
return err
}
defer conn.Close()
// Authenticate to RCON
if err = conn.Authenticate(); err != nil {
return err
}
// Send the command to Minecraft
if _, err := conn.SendCommand(command); err != nil { | identifier_body |
|
discord.go | ancementMessage:
{
if !Config.Discord.MessageOptions.ShowAdvancements {
continue
}
}
case DeathMessage:
{
if !Config.Discord.MessageOptions.ShowDeaths {
continue
}
}
case JoinLeaveMessage:
{
if !Config.Discord.MessageOptions.ShowJoinsLeaves {
continue
}
}
}
// Send the message to the Discord channel
bot.sendToDiscord(msg)
}
}
// onReady sets the bot's Discord status.
func (bot *DiscordBot) onReady(e *gateway.ReadyEvent) {
// Set the bot gaming status
err := bot.state.Gateway.UpdateStatus(gateway.UpdateStatusData{
Game: &discord.Activity{
Name: "Bridging the Minecraft/Discord gap",
},
})
if err != nil {
Log.Errorf("Unable to update Discord status: %s\n", err)
}
}
// onGuildCreate handles when the bot joins or connects to a Guild.
func (bot *DiscordBot) onGuildCreate(e *gateway.GuildCreateEvent) {
// Make sure the guild is available
if e.Unavailable {
Log.Warnf("Attempted to join Guild '%s', but it was unavailable\n", e.Guild.Name)
return
}
if bot.guildID.String() != "" {
Log.Warnf("Received a Guild join event for '%s', but we've already joined one\n", e.Guild.Name)
return
}
Log.Infof("Connected to guild named '%s'\n", e.Guild.Name)
bot.guildID = e.Guild.ID
}
// onMessageCreate handles messages that the bot receives, and sends them
// to Minecraft via RCON.
func (bot *DiscordBot) onMessageCreate(e *gateway.MessageCreateEvent) {
// Ignore messages from ourselves
if e.Author.ID != bot.id && e.Message.WebhookID.String() == "" {
// Check if the message is a bot command
if strings.HasPrefix(e.Message.Content, "!") {
c := make(chan bool)
go parser.Parse(e.Message, bot.state, c)
// Don't go any further if the command was found and ran
if <-c {
return
}
}
// Not a command, so ignore messages from other channels
if e.ChannelID.String() == Config.Discord.ChannelID {
Log.Debugln("Received a message from Discord")
// Get the name to use
var name string
if Config.Discord.UseMemberNicks {
name = bot.getNickname(e.Author.ID)
} else {
name = e.Author.Username
}
// Print the URL if message contains an attachement but no message content
if len(e.Message.Attachments) > 0 {
if len(e.Content) == 0 {
e.Content = e.Message.Attachments[0].URL
if err := sendToMinecraft(e.Content, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
return
}
}
content := formatMessage(bot.state, e.Message)
lines := strings.Split(content, "\n")
// Send a separate message for each line
for i := 0; i < len(lines); i++ {
line := lines[i]
// Split long lines into additional messages
if len(line) > 100 {
lines = append(lines, "")
copy(lines[i+2:], lines[i+1:])
lines[i+1] = line[100:]
line = line[:100]
}
if err := sendToMinecraft(line, name); err != nil {
Log.Errorf("Error sending command to RCON: %s\n", err)
}
}
}
}
}
// sendToDiscord sends a message from Minecraft to the configured
// Discord channel.
func (bot *DiscordBot) sendToDiscord(m *MinecraftMessage) {
// Insert Discord mentions if configured and present
if Config.Discord.AllowMentions {
// Insert Discord mentions
m.Message = bot.insertMentions(m.Message)
}
// Send the message to Discord either via webhook or normal channel message
if Config.Discord.Webhook.Enabled {
// Get the configured webhook
id, token := matchWebhookURL(Config.Discord.Webhook.URL)
if id == "" || token == "" {
Log.Warnln("Invalid or undefined Discord webhook URL")
return
}
// Attempt to get the webhook
snowflake, err := discord.ParseSnowflake(id)
if err != nil {
Log.Errorf("Error parsing Webhook Snowflake: %s\n", err.Error())
}
webhookID := discord.WebhookID(snowflake)
// Form our webhook params
params := bot.setWebhookParams(m)
// Send to the webhook
Log.Debugf("Sending to webhook: id='%s', token='%s'\n", id, token)
if err := webhook.Execute(webhookID, token, params); err != nil {
Log.Errorf("Error sending data to Discord webhook: %s\n", err.Error())
}
} else {
// Format the message for Discord
formatted := fmt.Sprintf("**%s**: %s", m.Username, m.Message)
// Send to the configured Discord channel
if _, err := bot.state.Client.SendMessage(bot.channel, formatted, nil); err != nil {
Log.Errorf("Error sending a message to Discord: %s\n", err.Error())
}
}
}
// getNickname gets the nickname of a Discord user in a Guild.
func (bot *DiscordBot) getNickname(id discord.UserID) string {
var m *discord.Member
// Look in the cached state for the Member
m, _ = bot.state.Member(bot.guildID, id)
// Make sure we do have a user
if m == nil {
return ""
}
if m.Nick == "" {
return m.User.Username
}
return m.Nick
}
// getUserFromName gets the Discord user from a mention or username. The username
// can be only a partial username.
func (bot *DiscordBot) getUserFromName(text string) (target *discord.User) {
// Look through all guild members in the state
members, _ := bot.state.Members(bot.guildID)
for _, u := range members {
// Check if the name matches, case-insensitive
if strings.EqualFold(u.User.Username, text) {
target = &u.User
break
}
}
return target
}
// insertMentions looks for potential Discord mentions in a Minecraft chat
// message. If there are any, we will attempt to get the user being mentioned
// to get their mention string to put into the chat message.
func (bot *DiscordBot) insertMentions(msg string) string {
// Split the message into words
words := strings.Split(msg, " ")
// Iterate over each word
for _, word := range words {
// Check if the word might be a mention
if strings.HasPrefix(word, "@") {
// Attempt to get the user
user := bot.getUserFromName(word[1:])
if user != nil {
// Replace the word with the mention
msg = strings.Replace(msg, word, user.Mention(), 1)
}
}
}
return msg
}
func matchWebhookURL(url string) (string, string) {
wm := webhookRegex.FindStringSubmatch(url)
// Make sure we have the correct number of parts (ID and token)
if len(wm) != 3 {
return "", ""
}
// Return the webhook ID and token
return wm[1], wm[2]
}
// setWebhookParams sets the avater, username, and message for a webhook request.
func (bot *DiscordBot) setWebhookParams(m *MinecraftMessage) api.ExecuteWebhookData {
// Get the avatar to use for this message
var avatarURL string
if m.Username == bot.name {
// Use the bot's avatar
avatarURL = bot.avatarURL
} else {
// Player's Minecraft head as the avatar
avatarURL = fmt.Sprintf("https://minotar.net/helm/%s/256.png", m.Username)
}
return api.ExecuteWebhookData{
Content: m.Message,
Username: m.Username,
AvatarURL: avatarURL,
}
}
func formatMessage(state *state.State, message discord.Message) string {
content := message.Content
// Replace mentions
for _, word := range strings.Split(content, " ") {
if strings.HasPrefix(word, "<#") && strings.HasSuffix(word, ">") {
// Get the ID from the mention string
id := word[2 : len(word)-1]
snowflake, _ := discord.ParseSnowflake(id)
channelID := discord.ChannelID(snowflake)
channel, err := state.Channel(channelID)
if err != nil {
Log.Warnf("Error while getting channel from Discord: %s\n", err)
continue
} |
content = strings.Replace(content, fmt.Sprintf("<#%s>", id), fmt.Sprintf("#%s", channel.Name), -1)
} | random_line_split |
|
mod.rs | 32,
pub h: u32,
}
impl From<Rect> for AtlasRect {
fn from(rect: Rect) -> AtlasRect {
AtlasRect {
x: rect.x,
y: rect.y,
w: rect.w,
h: rect.h,
}
}
}
pub type AtlasTextureRegion = (f32, f32, f32, f32);
pub enum TileShape {
Static,
Autotile,
Wall,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AtlasTileData {
pub offset: (u32, u32),
pub is_autotile: bool,
pub tile_kind: TileKind,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AtlasTile {
pub data: AtlasTileData,
pub cached_rect: RefCell<Option<AtlasTextureRegion>>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AtlasFrame {
tile_size: (u32, u32),
texture_idx: usize,
rect: AtlasRect,
offsets: HashMap<String, AtlasTile>,
}
impl AtlasFrame {
pub fn new(texture_idx: usize, rect: Rect, tile_size: (u32, u32)) -> Self {
AtlasFrame {
tile_size: tile_size,
texture_idx: texture_idx,
rect: AtlasRect::from(rect),
offsets: HashMap::new(),
}
}
}
pub type TilePacker<'a> = TexturePacker<'a, DynamicImage, SkylinePacker<Rgba<u8>>>;
pub struct TileAtlas {
config: TileAtlasConfig,
textures: Vec<Texture2d>,
indices: Vec<String>,
}
pub struct TileAtlasBuilder<'a> {
locations: HashMap<String, String>,
frames: HashMap<String, AtlasFrame>,
packers: Vec<TilePacker<'a>>,
pub file_hash: String,
}
impl <'a> TileAtlasBuilder<'a> {
pub fn new() -> Self {
let mut builder = TileAtlasBuilder {
locations: HashMap::new(),
frames: HashMap::new(),
packers: Vec::new(),
file_hash: String::new(),
};
builder.add_packer();
builder
}
pub fn add_tile(&mut self, path_str: &str, index: String, tile_data: AtlasTileData) {
let key = path_str.to_string();
assert!(self.frames.contains_key(&path_str.to_string()));
{
let mut frame = self.frames.get_mut(&key).unwrap();
assert!(!frame.offsets.contains_key(&index));
let tile = AtlasTile {
data: tile_data,
cached_rect: RefCell::new(None),
};
frame.offsets.insert(index.clone(), tile);
self.locations.insert(index, key);
}
}
pub fn add_frame(&mut self, path_string: &str, tile_size: (u32, u32)) {
if self.frames.contains_key(path_string) {
return;
}
let path = Path::new(&path_string);
let texture = ImageImporter::import_from_file(path).unwrap();
for (idx, packer) in self.packers.iter_mut().enumerate() {
if packer.can_pack(&texture) {
packer.pack_own(path_string.to_string(), texture).unwrap();
let rect = packer.get_frame(path_string).unwrap().frame;
self.frames.insert(path_string.to_string(), AtlasFrame::new(idx, rect, tile_size));
// cannot return self here, since self already borrowed, so
// cannot use builder pattern.
return;
}
}
self.add_packer();
{
// complains that borrow doesn't last long enough
// len mut packer = self.newest_packer_mut();
let packer_idx = self.packers.len() - 1;
let mut packer = &mut self.packers[packer_idx];
packer.pack_own(path_string.to_string(), texture).unwrap();
let rect = packer.get_frame(&path_string).unwrap().frame;
self.frames.insert(path_string.to_string(), AtlasFrame::new(packer_idx, rect, tile_size));
}
}
fn add_packer(&mut self) {
let config = TexturePackerConfig {
max_width: 2048,
max_height: 2048,
allow_rotation: false,
texture_outlines: false,
trim: false,
texture_padding: 0,
..Default::default()
};
self.packers.push(TexturePacker::new_skyline(config));
}
pub fn build<F: Facade>(&self, display: &F, packed_tex_folder: &str) -> TileAtlas {
let mut textures = Vec::new();
let packed_folder_path = config::get_config_cache_path(packed_tex_folder);
if Path::exists(packed_folder_path.as_path()) {
fs::remove_dir_all(packed_folder_path.as_path()).unwrap();
}
fs::create_dir_all(packed_folder_path.as_path()).unwrap();
for (idx, packer) in self.packers.iter().enumerate() {
let image = ImageExporter::export(packer).unwrap();
let mut file_path = packed_folder_path.clone();
file_path.push(&format!("{}.png", idx));
let mut file = File::create(file_path).unwrap();
image.save(&mut file, image::PNG).unwrap();
textures.push(make_texture(display, image));
}
println!("Saved {}", packed_tex_folder);
let config = TileAtlasConfig {
locations: self.locations.clone(),
frames: self.frames.clone(),
file_hash: self.file_hash.clone(),
};
config::write_tile_atlas_config(&config, packed_tex_folder);
TileAtlas::new(config, textures)
}
}
impl TileAtlas {
pub fn new(config: TileAtlasConfig, textures: Vec<Texture2d>) -> Self {
let mut atlas = TileAtlas {
config: config,
textures: textures,
indices: Vec::new(),
};
atlas.cache_tile_regions();
atlas
}
/// Precalculates the UV rectangles for individual tiles to avoid the
/// overhead of recalculationg them on lookup. It must be done before the
/// tile atlas can be used.
fn cache_tile_regions(&mut self) {
for frame in self.config.frames.values() {
let (frame_w, frame_h) = self.frame_size(frame);
for (tile_type, tile) in frame.offsets.iter() {
let tex_ratio = self.get_sprite_tex_ratio(tile_type);
let add_offset = get_add_offset(&frame.rect, &frame.tile_size);
let ratio = if tile.data.is_autotile {
2
} else {
1
};
let tx = ((tile.data.offset.0 + add_offset.0) * ratio) as f32 * tex_ratio[0];
let ty = ((tile.data.offset.1 + add_offset.1) * ratio) as f32 * tex_ratio[1];
let tw = (frame.tile_size.0 * ratio) as f32 / frame_w as f32;
let th = (frame.tile_size.1 * ratio) as f32 / frame_h as f32;
*tile.cached_rect.borrow_mut() = Some((tx, ty, tw, th));
}
}
self.indices = self.config.locations.keys().map(|l| l.to_string()).collect();
}
fn frame_size(&self, frame: &AtlasFrame) -> (u32, u32) |
fn texture_size(&self, texture_idx: usize) -> (u32, u32) {
self.textures[texture_idx].dimensions()
}
fn get_frame(&self, tile_type: &str) -> &AtlasFrame {
let tex_name = &self.config.locations[tile_type];
&self.config.frames[tex_name]
}
pub fn get_tile_texture_idx(&self, tile_type: &str) -> usize {
self.get_frame(tile_type).texture_idx
}
pub fn get_tilemap_tex_ratio(&self, texture_idx: usize) -> [f32; 2] {
let dimensions = self.texture_size(texture_idx);
let cols: u32 = dimensions.0 / 24;
let rows: u32 = dimensions.1 / 24;
[1.0 / cols as f32, 1.0 / rows as f32]
}
pub fn get_sprite_tex_ratio(&self, tile_type: &str) -> [f32; 2] {
let frame = self.get_frame(tile_type);
let (mut sx, mut sy) = frame.tile_size;
if frame.offsets[tile_type].data.is_autotile {
// divide the autotile into 24x24 from 48x48
sx /= 2;
sy /= 2;
}
let dimensions = self.frame_size(frame);
let cols: f32 = dimensions.0 as f32 / sx as f32;
let rows: f32 = dimensions.1 as f32 / sy as f32;
[1.0 / cols, 1.0 / rows]
}
pub fn get_tile_texture_size(&self, tile_type: &str) -> (u32, u32) {
self.get_frame(tile_type | {
self.texture_size(frame.texture_idx)
} | identifier_body |
mod.rs | : texture_idx,
rect: AtlasRect::from(rect),
offsets: HashMap::new(),
}
}
}
pub type TilePacker<'a> = TexturePacker<'a, DynamicImage, SkylinePacker<Rgba<u8>>>;
pub struct TileAtlas {
config: TileAtlasConfig,
textures: Vec<Texture2d>,
indices: Vec<String>,
}
pub struct TileAtlasBuilder<'a> {
locations: HashMap<String, String>,
frames: HashMap<String, AtlasFrame>,
packers: Vec<TilePacker<'a>>,
pub file_hash: String,
}
impl <'a> TileAtlasBuilder<'a> {
pub fn new() -> Self {
let mut builder = TileAtlasBuilder {
locations: HashMap::new(),
frames: HashMap::new(),
packers: Vec::new(),
file_hash: String::new(),
};
builder.add_packer();
builder
}
pub fn add_tile(&mut self, path_str: &str, index: String, tile_data: AtlasTileData) {
let key = path_str.to_string();
assert!(self.frames.contains_key(&path_str.to_string()));
{
let mut frame = self.frames.get_mut(&key).unwrap();
assert!(!frame.offsets.contains_key(&index));
let tile = AtlasTile {
data: tile_data,
cached_rect: RefCell::new(None),
};
frame.offsets.insert(index.clone(), tile);
self.locations.insert(index, key);
}
}
pub fn add_frame(&mut self, path_string: &str, tile_size: (u32, u32)) {
if self.frames.contains_key(path_string) {
return;
}
let path = Path::new(&path_string);
let texture = ImageImporter::import_from_file(path).unwrap();
for (idx, packer) in self.packers.iter_mut().enumerate() {
if packer.can_pack(&texture) {
packer.pack_own(path_string.to_string(), texture).unwrap();
let rect = packer.get_frame(path_string).unwrap().frame;
self.frames.insert(path_string.to_string(), AtlasFrame::new(idx, rect, tile_size));
// cannot return self here, since self already borrowed, so
// cannot use builder pattern.
return;
}
}
self.add_packer();
{
// complains that borrow doesn't last long enough
// len mut packer = self.newest_packer_mut();
let packer_idx = self.packers.len() - 1;
let mut packer = &mut self.packers[packer_idx];
packer.pack_own(path_string.to_string(), texture).unwrap();
let rect = packer.get_frame(&path_string).unwrap().frame;
self.frames.insert(path_string.to_string(), AtlasFrame::new(packer_idx, rect, tile_size));
}
}
fn add_packer(&mut self) {
let config = TexturePackerConfig {
max_width: 2048,
max_height: 2048,
allow_rotation: false,
texture_outlines: false,
trim: false,
texture_padding: 0,
..Default::default()
};
self.packers.push(TexturePacker::new_skyline(config));
}
pub fn build<F: Facade>(&self, display: &F, packed_tex_folder: &str) -> TileAtlas {
let mut textures = Vec::new();
let packed_folder_path = config::get_config_cache_path(packed_tex_folder);
if Path::exists(packed_folder_path.as_path()) {
fs::remove_dir_all(packed_folder_path.as_path()).unwrap();
}
fs::create_dir_all(packed_folder_path.as_path()).unwrap();
for (idx, packer) in self.packers.iter().enumerate() {
let image = ImageExporter::export(packer).unwrap();
let mut file_path = packed_folder_path.clone();
file_path.push(&format!("{}.png", idx));
let mut file = File::create(file_path).unwrap();
image.save(&mut file, image::PNG).unwrap();
textures.push(make_texture(display, image));
}
println!("Saved {}", packed_tex_folder);
let config = TileAtlasConfig {
locations: self.locations.clone(),
frames: self.frames.clone(),
file_hash: self.file_hash.clone(),
};
config::write_tile_atlas_config(&config, packed_tex_folder);
TileAtlas::new(config, textures)
}
}
impl TileAtlas {
pub fn new(config: TileAtlasConfig, textures: Vec<Texture2d>) -> Self {
let mut atlas = TileAtlas {
config: config,
textures: textures,
indices: Vec::new(),
};
atlas.cache_tile_regions();
atlas
}
/// Precalculates the UV rectangles for individual tiles to avoid the
/// overhead of recalculationg them on lookup. It must be done before the
/// tile atlas can be used.
fn cache_tile_regions(&mut self) {
for frame in self.config.frames.values() {
let (frame_w, frame_h) = self.frame_size(frame);
for (tile_type, tile) in frame.offsets.iter() {
let tex_ratio = self.get_sprite_tex_ratio(tile_type);
let add_offset = get_add_offset(&frame.rect, &frame.tile_size);
let ratio = if tile.data.is_autotile {
2
} else {
1
};
let tx = ((tile.data.offset.0 + add_offset.0) * ratio) as f32 * tex_ratio[0];
let ty = ((tile.data.offset.1 + add_offset.1) * ratio) as f32 * tex_ratio[1];
let tw = (frame.tile_size.0 * ratio) as f32 / frame_w as f32;
let th = (frame.tile_size.1 * ratio) as f32 / frame_h as f32;
*tile.cached_rect.borrow_mut() = Some((tx, ty, tw, th));
}
}
self.indices = self.config.locations.keys().map(|l| l.to_string()).collect();
}
fn frame_size(&self, frame: &AtlasFrame) -> (u32, u32) {
self.texture_size(frame.texture_idx)
}
fn texture_size(&self, texture_idx: usize) -> (u32, u32) {
self.textures[texture_idx].dimensions()
}
fn get_frame(&self, tile_type: &str) -> &AtlasFrame {
let tex_name = &self.config.locations[tile_type];
&self.config.frames[tex_name]
}
pub fn get_tile_texture_idx(&self, tile_type: &str) -> usize {
self.get_frame(tile_type).texture_idx
}
pub fn get_tilemap_tex_ratio(&self, texture_idx: usize) -> [f32; 2] {
let dimensions = self.texture_size(texture_idx);
let cols: u32 = dimensions.0 / 24;
let rows: u32 = dimensions.1 / 24;
[1.0 / cols as f32, 1.0 / rows as f32]
}
pub fn get_sprite_tex_ratio(&self, tile_type: &str) -> [f32; 2] {
let frame = self.get_frame(tile_type);
let (mut sx, mut sy) = frame.tile_size;
if frame.offsets[tile_type].data.is_autotile {
// divide the autotile into 24x24 from 48x48
sx /= 2;
sy /= 2;
}
let dimensions = self.frame_size(frame);
let cols: f32 = dimensions.0 as f32 / sx as f32;
let rows: f32 = dimensions.1 as f32 / sy as f32;
[1.0 / cols, 1.0 / rows]
}
pub fn get_tile_texture_size(&self, tile_type: &str) -> (u32, u32) {
self.get_frame(tile_type).tile_size
}
pub fn get_tile(&self, tile_type: &str) -> &AtlasTile {
let frame = self.get_frame(tile_type);
&frame.offsets[tile_type]
}
pub fn get_texture_offset(&self, tile_type: &str, msecs: u64) -> (f32, f32) {
let frame = self.get_frame(tile_type);
let tile = &frame.offsets[tile_type];
let (mut tx, ty, tw, _) = tile.cached_rect.borrow()
.expect("Texture atlas regions weren't cached yet.");
match tile.data.tile_kind {
TileKind::Static => (),
TileKind::Animated(frame_count, delay) => {
let current_frame = msecs / delay;
let x_index_offset = current_frame % frame_count;
tx += x_index_offset as f32 * tw;
}
}
(tx, ty)
}
pub fn get_tile_index(&self, tile_kind: &str) -> usize {
self.indices.iter().enumerate().find(|&(_, i)| i == tile_kind).unwrap().0
}
fn get_tile_kind_indexed(&self, tile_idx: usize) -> &String {
&self.indices[tile_idx]
}
pub fn | get_texture_offset_indexed | identifier_name |
|
mod.rs | 32,
pub h: u32,
}
impl From<Rect> for AtlasRect {
fn from(rect: Rect) -> AtlasRect {
AtlasRect {
x: rect.x,
y: rect.y,
w: rect.w,
h: rect.h,
}
}
}
pub type AtlasTextureRegion = (f32, f32, f32, f32);
pub enum TileShape {
Static,
Autotile,
Wall,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AtlasTileData {
pub offset: (u32, u32),
pub is_autotile: bool,
pub tile_kind: TileKind,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AtlasTile {
pub data: AtlasTileData,
pub cached_rect: RefCell<Option<AtlasTextureRegion>>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AtlasFrame {
tile_size: (u32, u32),
texture_idx: usize,
rect: AtlasRect, | pub fn new(texture_idx: usize, rect: Rect, tile_size: (u32, u32)) -> Self {
AtlasFrame {
tile_size: tile_size,
texture_idx: texture_idx,
rect: AtlasRect::from(rect),
offsets: HashMap::new(),
}
}
}
pub type TilePacker<'a> = TexturePacker<'a, DynamicImage, SkylinePacker<Rgba<u8>>>;
pub struct TileAtlas {
config: TileAtlasConfig,
textures: Vec<Texture2d>,
indices: Vec<String>,
}
pub struct TileAtlasBuilder<'a> {
locations: HashMap<String, String>,
frames: HashMap<String, AtlasFrame>,
packers: Vec<TilePacker<'a>>,
pub file_hash: String,
}
impl <'a> TileAtlasBuilder<'a> {
pub fn new() -> Self {
let mut builder = TileAtlasBuilder {
locations: HashMap::new(),
frames: HashMap::new(),
packers: Vec::new(),
file_hash: String::new(),
};
builder.add_packer();
builder
}
pub fn add_tile(&mut self, path_str: &str, index: String, tile_data: AtlasTileData) {
let key = path_str.to_string();
assert!(self.frames.contains_key(&path_str.to_string()));
{
let mut frame = self.frames.get_mut(&key).unwrap();
assert!(!frame.offsets.contains_key(&index));
let tile = AtlasTile {
data: tile_data,
cached_rect: RefCell::new(None),
};
frame.offsets.insert(index.clone(), tile);
self.locations.insert(index, key);
}
}
pub fn add_frame(&mut self, path_string: &str, tile_size: (u32, u32)) {
if self.frames.contains_key(path_string) {
return;
}
let path = Path::new(&path_string);
let texture = ImageImporter::import_from_file(path).unwrap();
for (idx, packer) in self.packers.iter_mut().enumerate() {
if packer.can_pack(&texture) {
packer.pack_own(path_string.to_string(), texture).unwrap();
let rect = packer.get_frame(path_string).unwrap().frame;
self.frames.insert(path_string.to_string(), AtlasFrame::new(idx, rect, tile_size));
// cannot return self here, since self already borrowed, so
// cannot use builder pattern.
return;
}
}
self.add_packer();
{
// complains that borrow doesn't last long enough
// len mut packer = self.newest_packer_mut();
let packer_idx = self.packers.len() - 1;
let mut packer = &mut self.packers[packer_idx];
packer.pack_own(path_string.to_string(), texture).unwrap();
let rect = packer.get_frame(&path_string).unwrap().frame;
self.frames.insert(path_string.to_string(), AtlasFrame::new(packer_idx, rect, tile_size));
}
}
fn add_packer(&mut self) {
let config = TexturePackerConfig {
max_width: 2048,
max_height: 2048,
allow_rotation: false,
texture_outlines: false,
trim: false,
texture_padding: 0,
..Default::default()
};
self.packers.push(TexturePacker::new_skyline(config));
}
pub fn build<F: Facade>(&self, display: &F, packed_tex_folder: &str) -> TileAtlas {
let mut textures = Vec::new();
let packed_folder_path = config::get_config_cache_path(packed_tex_folder);
if Path::exists(packed_folder_path.as_path()) {
fs::remove_dir_all(packed_folder_path.as_path()).unwrap();
}
fs::create_dir_all(packed_folder_path.as_path()).unwrap();
for (idx, packer) in self.packers.iter().enumerate() {
let image = ImageExporter::export(packer).unwrap();
let mut file_path = packed_folder_path.clone();
file_path.push(&format!("{}.png", idx));
let mut file = File::create(file_path).unwrap();
image.save(&mut file, image::PNG).unwrap();
textures.push(make_texture(display, image));
}
println!("Saved {}", packed_tex_folder);
let config = TileAtlasConfig {
locations: self.locations.clone(),
frames: self.frames.clone(),
file_hash: self.file_hash.clone(),
};
config::write_tile_atlas_config(&config, packed_tex_folder);
TileAtlas::new(config, textures)
}
}
impl TileAtlas {
pub fn new(config: TileAtlasConfig, textures: Vec<Texture2d>) -> Self {
let mut atlas = TileAtlas {
config: config,
textures: textures,
indices: Vec::new(),
};
atlas.cache_tile_regions();
atlas
}
/// Precalculates the UV rectangles for individual tiles to avoid the
/// overhead of recalculationg them on lookup. It must be done before the
/// tile atlas can be used.
fn cache_tile_regions(&mut self) {
for frame in self.config.frames.values() {
let (frame_w, frame_h) = self.frame_size(frame);
for (tile_type, tile) in frame.offsets.iter() {
let tex_ratio = self.get_sprite_tex_ratio(tile_type);
let add_offset = get_add_offset(&frame.rect, &frame.tile_size);
let ratio = if tile.data.is_autotile {
2
} else {
1
};
let tx = ((tile.data.offset.0 + add_offset.0) * ratio) as f32 * tex_ratio[0];
let ty = ((tile.data.offset.1 + add_offset.1) * ratio) as f32 * tex_ratio[1];
let tw = (frame.tile_size.0 * ratio) as f32 / frame_w as f32;
let th = (frame.tile_size.1 * ratio) as f32 / frame_h as f32;
*tile.cached_rect.borrow_mut() = Some((tx, ty, tw, th));
}
}
self.indices = self.config.locations.keys().map(|l| l.to_string()).collect();
}
fn frame_size(&self, frame: &AtlasFrame) -> (u32, u32) {
self.texture_size(frame.texture_idx)
}
fn texture_size(&self, texture_idx: usize) -> (u32, u32) {
self.textures[texture_idx].dimensions()
}
fn get_frame(&self, tile_type: &str) -> &AtlasFrame {
let tex_name = &self.config.locations[tile_type];
&self.config.frames[tex_name]
}
pub fn get_tile_texture_idx(&self, tile_type: &str) -> usize {
self.get_frame(tile_type).texture_idx
}
pub fn get_tilemap_tex_ratio(&self, texture_idx: usize) -> [f32; 2] {
let dimensions = self.texture_size(texture_idx);
let cols: u32 = dimensions.0 / 24;
let rows: u32 = dimensions.1 / 24;
[1.0 / cols as f32, 1.0 / rows as f32]
}
pub fn get_sprite_tex_ratio(&self, tile_type: &str) -> [f32; 2] {
let frame = self.get_frame(tile_type);
let (mut sx, mut sy) = frame.tile_size;
if frame.offsets[tile_type].data.is_autotile {
// divide the autotile into 24x24 from 48x48
sx /= 2;
sy /= 2;
}
let dimensions = self.frame_size(frame);
let cols: f32 = dimensions.0 as f32 / sx as f32;
let rows: f32 = dimensions.1 as f32 / sy as f32;
[1.0 / cols, 1.0 / rows]
}
pub fn get_tile_texture_size(&self, tile_type: &str) -> (u32, u32) {
self.get_frame(tile_type).tile | offsets: HashMap<String, AtlasTile>,
}
impl AtlasFrame { | random_line_split |
compensation_disp.py | (max_v_gr, signal_duration, factor=0.9):
# delta k powinno być = 1/(n(delta_x) i mniejsze niż 1/(m*delta_t*v_gr_max) m*delta_t jest równe długości trwania sygnału :)
if signal_duration <= 0:
print("Długość sygnału musi być większa od 0")
exit(0)
if factor >= 1:
print("Współczynnik musi być mniejszy od 1, przyjęta wartość to 0,9")
factor = 0.9
delta_k = factor/(signal_duration * max_v_gr)
return delta_k # delta_k zwracana jest w rad/m
def calculate_delta_x(k_Nyquista):
return 1/(2*k_Nyquista) # w metrach
def find_max_k(mode, k_vect, max_omega_kHz):
if max_omega_kHz > mode.all_omega_khz[-1]:
max_k = mode.findPoint([mode.points[-2], mode.points[-1]], max_omega_kHz)
elif max_omega_kHz < mode.minOmega:
max_k = -1
else:
P1 = selectMode.Point()
P2 = selectMode.Point()
for ind in range(len(mode.points)-1):
if mode.points[ind].w < max_omega_kHz and mode.points[ind+1].w > max_omega_kHz:
P1 = mode.points[ind]
P2 = mode.points[ind+1]
break
max_k = mode.findPoint([P1, P2], max_omega_kHz)
return max_k
def find_omega_in_dispercion_curves(mode, temp_k, k_vect):
omega = mode.points[0].w
if temp_k > k_vect[-1]:
omega = mode.findPointWithGivenK([mode.points[-2], mode.points[-1]], temp_k)
elif temp_k < k_vect[0]:
if mode.points[0].w < 5:
temp_point = selectMode.Point()
omega = mode.findPointWithGivenK([temp_point, mode.points[0]], temp_k)
else:
omega = mode.points[0].w
else:
for ind in range(len(k_vect)-1):
if k_vect[ind] < temp_k and k_vect[ind + 1] > temp_k:
omega = mode.findPointWithGivenK([mode.points[ind], mode.points[ind+1]], temp_k)
return omega
def find_omega_in_dispercion_curves_rad_s(mode, temp_k, k_vect):
omega = mode.points[0].wkat_complex
if temp_k > k_vect[-1]:
omega = mode.findPointWithGivenK_rad_s([mode.points[-2], mode.points[-1]], temp_k)
elif temp_k < k_vect[0]:
if mode.points[0].w < 5:
temp_point = selectMode.Point()
omega = mode.findPointWithGivenK_rad_s([temp_point, mode.points[0]], temp_k)
else:
omega = mode.points[0].wkat_complex
else:
for ind in range(len(k_vect)-1):
if k_ve | w, freq_sampling_kHz, omega):
value = -1
for ind in range(len(freq_sampling_kHz)-1):
if freq_sampling_kHz[ind] == omega:
value = G_w[ind]
break
elif freq_sampling_kHz[ind] < omega and freq_sampling_kHz[ind + 1] > omega:
a = (G_w[ind] - G_w[ind+1])/(freq_sampling_kHz[ind] - freq_sampling_kHz[ind +1])
b = G_w[ind] - a * freq_sampling_kHz[ind]
value = a* omega + b
break
if value == -1:
if omega == freq_sampling_kHz[-1]:
value = G_w[-1]
return value
def calculate_group_velocity(mode, k_sampling_rad_m, ind, k_vect):
k1 = k_sampling_rad_m[ind + 1]
k2 = k_sampling_rad_m[ind]
om1 = find_omega_in_dispercion_curves_rad_s(mode, k1, k_vect)
om2 = find_omega_in_dispercion_curves_rad_s(mode, k2, k_vect)
group_velocity = (om1 - om2)/(k1 - k2)
return group_velocity
def calculate_mean_mode(dispercion_curves, numbers_of_propagated_modes):
modes = []
for ind in numbers_of_propagated_modes:
modes.append(dispercion_curves.getMode(ind))
mean_mode = selectMode.Mode()
mean_k_vector = []
omegs = modes[0].all_omega_khz
for ind in range(len(omegs)):
mean_k = modes[0].points[ind].k
for mode_ind in range(len(modes)-1):
calc_k = Anim_dyspersji.curve_sampling_new(modes[mode_ind + 1].all_omega_khz, dispercion_curves.k_v, [omegs[ind]])[0]
mean_k = mean_k + calc_k
mean_k = mean_k/(len(modes))
mean_mode.addPoint(modes[0].points[ind])
mean_mode.points[ind].k = mean_k
mean_k_vector.append(mean_k)
return [mean_mode, mean_k_vector]
def mapping_from_time_to_distance(dispersion, dispercion_curves, propagated_modes, need_to_pad = False):
if need_to_pad:
signal_to_fft = pad_timetraces_zeroes(dispersion[0], dispersion[1])
else:
signal_to_fft = dispersion
signal_after_fft = np.fft.rfft(signal_to_fft[1])
time = signal_to_fft[0]
dt = time[-1]/len(time)
frequency_from_numpy = np.fft.rfftfreq(len(signal_to_fft[1]), d=dt)*1e-3
new_freq_sampling_kHz = frequency_from_numpy
modes = []
for ind in range(len(propagated_modes)):
modes.append(dispercion_curves.getMode(propagated_modes[ind]))
k_vect = dispercion_curves.k_v
G_w = np.sqrt(signal_after_fft.real**2 + signal_after_fft.imag**2)
if len(modes) > 1:
mean_data = calculate_mean_mode(dispercion_curves, propagated_modes)
mean_mode = mean_data[0]
mean_k_vector = mean_data[1]
else:
mean_mode = modes[0]
mean_k_vector = dispercion_curves.k_v
mode_0 = mean_mode
k_vect = mean_k_vector
v_gr_max = 0
for ind in range(len(k_vect) - 1):
print("Indeks wynosi " + str(ind))
value = (mode_0.points[ind + 1].wkat_complex - mode_0.points[ind].wkat_complex)/(k_vect[ind+1]-k_vect[ind])
if value > v_gr_max:
v_gr_max = value
#------------------Wyliczanie ograniczeń --------------------------------
k_nyq = calculate_k_nyquist(dispercion_curves, dt)
delta_x = calculate_delta_x(k_nyq)
delta_k = calculate_delta_k(v_gr_max.real, time[-1])
n = calculate_n(k_nyq, delta_k) # n to długość wektora x, liczba próbek na odległości
max_k = find_max_k(mode_0, k_vect, new_freq_sampling_kHz[-1])
new_k_sampling_rad_m = []
while max_k/delta_k > 40000:
delta_k = delta_k * 5
k = 0
while k < max_k:
new_k_sampling_rad_m.append(k)
k += delta_k
G_k = []
ind = 0
for temp_k in new_k_sampling_rad_m:
om = find_omega_in_dispercion_curves(mode_0, temp_k, k_vect)
val = find_value_by_omega_in_G_w(signal_after_fft, new_freq_sampling_kHz, om)
G_k.append(val)
ind += 1
v_gr = []
for ind in range(len(new_k_sampling_rad_m) - 1):
value = calculate_group_velocity(mode_0, new_k_sampling_rad_m, ind, k_vect)
v_gr.append(value)
v_gr.append(v_gr[-1])
H_k = []
for ind in range(len(v_gr)):
H_k.append(G_k[ind] * v_gr[ind])
h_x = np.fft.ifft(H_k) / (2000 * np.pi)
distance = 1/delta_k # w metrach
n = len(h_x)
dx = distance/n
dist_vect = []
for i in range(n):
dist_vect.append(i*dx*2*np.pi/len(propagated_modes))
return [dist_vect | ct[ind] < temp_k and k_vect[ind + 1] > temp_k:
omega = mode.findPointWithGivenK_rad_s([mode.points[ind], mode.points[ind+1]], temp_k)
break
return omega
def find_value_by_omega_in_G_w(G_ | conditional_block |
compensation_disp.py | omega = mode.findPointWithGivenK_rad_s([mode.points[-2], mode.points[-1]], temp_k)
elif temp_k < k_vect[0]:
if mode.points[0].w < 5:
temp_point = selectMode.Point()
omega = mode.findPointWithGivenK_rad_s([temp_point, mode.points[0]], temp_k)
else:
omega = mode.points[0].wkat_complex
else:
for ind in range(len(k_vect)-1):
if k_vect[ind] < temp_k and k_vect[ind + 1] > temp_k:
omega = mode.findPointWithGivenK_rad_s([mode.points[ind], mode.points[ind+1]], temp_k)
break
return omega
def find_value_by_omega_in_G_w(G_w, freq_sampling_kHz, omega):
value = -1
for ind in range(len(freq_sampling_kHz)-1):
if freq_sampling_kHz[ind] == omega:
value = G_w[ind]
break
elif freq_sampling_kHz[ind] < omega and freq_sampling_kHz[ind + 1] > omega:
a = (G_w[ind] - G_w[ind+1])/(freq_sampling_kHz[ind] - freq_sampling_kHz[ind +1])
b = G_w[ind] - a * freq_sampling_kHz[ind]
value = a* omega + b
break
if value == -1:
if omega == freq_sampling_kHz[-1]:
value = G_w[-1]
return value
def calculate_group_velocity(mode, k_sampling_rad_m, ind, k_vect):
k1 = k_sampling_rad_m[ind + 1]
k2 = k_sampling_rad_m[ind]
om1 = find_omega_in_dispercion_curves_rad_s(mode, k1, k_vect)
om2 = find_omega_in_dispercion_curves_rad_s(mode, k2, k_vect)
group_velocity = (om1 - om2)/(k1 - k2)
return group_velocity
def calculate_mean_mode(dispercion_curves, numbers_of_propagated_modes):
modes = []
for ind in numbers_of_propagated_modes:
modes.append(dispercion_curves.getMode(ind))
mean_mode = selectMode.Mode()
mean_k_vector = []
omegs = modes[0].all_omega_khz
for ind in range(len(omegs)):
mean_k = modes[0].points[ind].k
for mode_ind in range(len(modes)-1):
calc_k = Anim_dyspersji.curve_sampling_new(modes[mode_ind + 1].all_omega_khz, dispercion_curves.k_v, [omegs[ind]])[0]
mean_k = mean_k + calc_k
mean_k = mean_k/(len(modes))
mean_mode.addPoint(modes[0].points[ind])
mean_mode.points[ind].k = mean_k
mean_k_vector.append(mean_k)
return [mean_mode, mean_k_vector]
def mapping_from_time_to_distance(dispersion, dispercion_curves, propagated_modes, need_to_pad = False):
if need_to_pad:
signal_to_fft = pad_timetraces_zeroes(dispersion[0], dispersion[1])
else:
signal_to_fft = dispersion
signal_after_fft = np.fft.rfft(signal_to_fft[1])
time = signal_to_fft[0]
dt = time[-1]/len(time)
frequency_from_numpy = np.fft.rfftfreq(len(signal_to_fft[1]), d=dt)*1e-3
new_freq_sampling_kHz = frequency_from_numpy
modes = []
for ind in range(len(propagated_modes)):
modes.append(dispercion_curves.getMode(propagated_modes[ind]))
k_vect = dispercion_curves.k_v
G_w = np.sqrt(signal_after_fft.real**2 + signal_after_fft.imag**2)
if len(modes) > 1:
mean_data = calculate_mean_mode(dispercion_curves, propagated_modes)
mean_mode = mean_data[0]
mean_k_vector = mean_data[1]
else:
mean_mode = modes[0]
mean_k_vector = dispercion_curves.k_v
mode_0 = mean_mode
k_vect = mean_k_vector
v_gr_max = 0
for ind in range(len(k_vect) - 1):
print("Indeks wynosi " + str(ind))
value = (mode_0.points[ind + 1].wkat_complex - mode_0.points[ind].wkat_complex)/(k_vect[ind+1]-k_vect[ind])
if value > v_gr_max:
v_gr_max = value
#------------------Wyliczanie ograniczeń --------------------------------
k_nyq = calculate_k_nyquist(dispercion_curves, dt)
delta_x = calculate_delta_x(k_nyq)
delta_k = calculate_delta_k(v_gr_max.real, time[-1])
n = calculate_n(k_nyq, delta_k) # n to długość wektora x, liczba próbek na odległości
max_k = find_max_k(mode_0, k_vect, new_freq_sampling_kHz[-1])
new_k_sampling_rad_m = []
while max_k/delta_k > 40000:
delta_k = delta_k * 5
k = 0
while k < max_k:
new_k_sampling_rad_m.append(k)
k += delta_k
G_k = []
ind = 0
for temp_k in new_k_sampling_rad_m:
om = find_omega_in_dispercion_curves(mode_0, temp_k, k_vect)
val = find_value_by_omega_in_G_w(signal_after_fft, new_freq_sampling_kHz, om)
G_k.append(val)
ind += 1
v_gr = []
for ind in range(len(new_k_sampling_rad_m) - 1):
value = calculate_group_velocity(mode_0, new_k_sampling_rad_m, ind, k_vect)
v_gr.append(value)
v_gr.append(v_gr[-1])
H_k = []
for ind in range(len(v_gr)):
H_k.append(G_k[ind] * v_gr[ind])
h_x = np.fft.ifft(H_k) / (2000 * np.pi)
distance = 1/delta_k # w metrach
n = len(h_x)
dx = distance/n
dist_vect = []
for i in range(n):
dist_vect.append(i*dx*2*np.pi/len(propagated_modes))
return [dist_vect, h_x]
def wave_length_propagation(signal, numbers_of_modes, disp_curves, distance_m, F_PADZEROS, mult=8):
modes_table = []
for mode_number in numbers_of_modes:
modes_table.append(disp_curves.getMode(mode_number))
if F_PADZEROS:
signal_to_fft = pad_timetraces_zeroes(signal[0], signal[1], mult)
else:
signal_to_fft = signal
signal_after_fft = np.fft.rfft(signal_to_fft[1])
time = signal_to_fft[0]
dt = time[-1]/len(time)
frequency_from_numpy = np.fft.rfftfreq(len(signal_to_fft[1]), d=dt)*1e-3#*1e4
k_vect = []
new_signal_after_fft = []
for ind, f in enumerate(frequency_from_numpy):
k_vect.append(0)
for mode in modes_table:
k_vect[-1] += mode.findKWithGivenOmega_kHz(f)
new_signal_after_fft.append(signal_after_fft[ind] * np.exp(-1j * k_vect[ind] * distance_m))
propagated_signal = np.fft.irfft(new_signal_after_fft) #/distance_m
new_time = np.linspace(time[0], time[-1], len(propagated_signal))
return [new_time, propagated_signal]
def time_reverse(signal):
time_vector = signal[0]
new_signal = []
for s in signal[1]:
new_signal.append(s)
new_signal.reverse()
return [time_vector, new_signal]
def time_reverse_compensation(signal, distance, numbers_of_modes, disp_curves):
signal_temp = wave_length_propagation(signal, numbers_of_modes, disp_curves, distance, True, 100)
return time_reverse(signal_temp)
def linear_mapping_compensation(signal, number_of_modes, disp_curves):
signal_after_fft = np.fft.rfft(signal[1])
time = signal | [0]
dt = time[-1]/len(time)
frequency_from_numpy = np.fft.rfftfreq(len(signal[1]), d=dt)*1e-3
G_w = np.sqrt(signal_after_fft.real**2 + signal_after_fft.imag**2)
#znalezienie najsilniejszej/średniej omegi
max_g = G_w[0]
max_ind = 0
for ind, g in enumerate(G_w):
if g>max_g:
max_g = g
max_ind = ind
w_0 = frequency_from_numpy[max_ind]
mean_mode = disp_curves.getMode(number_of_modes)
mean_k_vector = disp_curves.k_v
k_vect = []
for ind, f in enumerate(frequency_from_numpy):
k_vect.append(mean_mode.findKWithGivenOmega_kHz(f)) | identifier_body |
|
compensation_disp.py | k_temp = Anim_dyspersji.curve_sampling(mode.all_omega_khz, dispercion_curves.k_v, [f_Nyq_kHz])
if k_temp > max_k_Nyq:
max_k_Nyq = k_temp
return factor*max_k_Nyq[0] # Zwracana wartość jest w rad/m
def calculate_delta_k(max_v_gr, signal_duration, factor=0.9):
# delta k powinno być = 1/(n(delta_x) i mniejsze niż 1/(m*delta_t*v_gr_max) m*delta_t jest równe długości trwania sygnału :)
if signal_duration <= 0:
print("Długość sygnału musi być większa od 0")
exit(0)
if factor >= 1:
print("Współczynnik musi być mniejszy od 1, przyjęta wartość to 0,9")
factor = 0.9
delta_k = factor/(signal_duration * max_v_gr)
return delta_k # delta_k zwracana jest w rad/m
def calculate_delta_x(k_Nyquista):
return 1/(2*k_Nyquista) # w metrach
def find_max_k(mode, k_vect, max_omega_kHz):
if max_omega_kHz > mode.all_omega_khz[-1]:
max_k = mode.findPoint([mode.points[-2], mode.points[-1]], max_omega_kHz)
elif max_omega_kHz < mode.minOmega:
max_k = -1
else:
P1 = selectMode.Point()
P2 = selectMode.Point()
for ind in range(len(mode.points)-1):
if mode.points[ind].w < max_omega_kHz and mode.points[ind+1].w > max_omega_kHz:
P1 = mode.points[ind]
P2 = mode.points[ind+1]
break
max_k = mode.findPoint([P1, P2], max_omega_kHz)
return max_k
def find_omega_in_dispercion_curves(mode, temp_k, k_vect):
omega = mode.points[0].w
if temp_k > k_vect[-1]:
omega = mode.findPointWithGivenK([mode.points[-2], mode.points[-1]], temp_k)
elif temp_k < k_vect[0]:
if mode.points[0].w < 5:
temp_point = selectMode.Point()
omega = mode.findPointWithGivenK([temp_point, mode.points[0]], temp_k)
else:
omega = mode.points[0].w
else:
for ind in range(len(k_vect)-1):
if k_vect[ind] < temp_k and k_vect[ind + 1] > temp_k:
omega = mode.findPointWithGivenK([mode.points[ind], mode.points[ind+1]], temp_k)
return omega
def find_omega_in_dispercion_curves_rad_s(mode, temp_k, k_vect):
omega = mode.points[0].wkat_complex
if temp_k > k_vect[-1]:
omega = mode.findPointWithGivenK_rad_s([mode.points[-2], mode.points[-1]], temp_k)
elif temp_k < k_vect[0]:
if mode.points[0].w < 5:
temp_point = selectMode.Point()
omega = mode.findPointWithGivenK_rad_s([temp_point, mode.points[0]], temp_k)
else:
omega = mode.points[0].wkat_complex
else:
for ind in range(len(k_vect)-1):
if k_vect[ind] < temp_k and k_vect[ind + 1] > temp_k:
omega = mode.findPointWithGivenK_rad_s([mode.points[ind], mode.points[ind+1]], temp_k)
break
return omega
def find_value_by_omega_in_G_w(G_w, freq_sampling_kHz, omega):
value = -1
for ind in range(len(freq_sampling_kHz)-1):
if freq_sampling_kHz[ind] == omega:
value = G_w[ind]
break
elif freq_sampling_kHz[ind] < omega and freq_sampling_kHz[ind + 1] > omega:
a = (G_w[ind] - G_w[ind+1])/(freq_sampling_kHz[ind] - freq_sampling_kHz[ind +1])
b = G_w[ind] - a * freq_sampling_kHz[ind]
value = a* omega + b
break
if value == -1:
if omega == freq_sampling_kHz[-1]:
value = G_w[-1]
return value
def calculate_group_velocity(mode, k_sampling_rad_m, ind, k_vect):
k1 = k_sampling_rad_m[ind + 1]
k2 = k_sampling_rad_m[ind]
om1 = find_omega_in_dispercion_curves_rad_s(mode, k1, k_vect)
om2 = find_omega_in_dispercion_curves_rad_s(mode, k2, k_vect)
group_velocity = (om1 - om2)/(k1 - k2)
return group_velocity
def calculate_mean_mode(dispercion_curves, numbers_of_propagated_modes):
modes = []
for ind in numbers_of_propagated_modes:
modes.append(dispercion_curves.getMode(ind))
mean_mode = selectMode.Mode()
mean_k_vector = []
omegs = modes[0].all_omega_khz
for ind in range(len(omegs)):
mean_k = modes[0].points[ind].k
for mode_ind in range(len(modes)-1):
calc_k = Anim_dyspersji.curve_sampling_new(modes[mode_ind + 1].all_omega_khz, dispercion_curves.k_v, [omegs[ind]])[0]
mean_k = mean_k + calc_k
mean_k = mean_k/(len(modes))
mean_mode.addPoint(modes[0].points[ind])
mean_mode.points[ind].k = mean_k
mean_k_vector.append(mean_k)
return [mean_mode, mean_k_vector]
def mapping_from_time_to_distance(dispersion, dispercion_curves, propagated_modes, need_to_pad = False):
if need_to_pad:
signal_to_fft = pad_timetraces_zeroes(dispersion[0], dispersion[1])
else:
signal_to_fft = dispersion
signal_after_fft = np.fft.rfft(signal_to_fft[1])
time = signal_to_fft[0]
dt = time[-1]/len(time)
frequency_from_numpy = np.fft.rfftfreq(len(signal_to_fft[1]), d=dt)*1e-3
new_freq_sampling_kHz = frequency_from_numpy
modes = []
for ind in range(len(propagated_modes)):
modes.append(dispercion_curves.getMode(propagated_modes[ind]))
k_vect = dispercion_curves.k_v
G_w = np.sqrt(signal_after_fft.real**2 + signal_after_fft.imag**2)
if len(modes) > 1:
mean_data = calculate_mean_mode(dispercion_curves, propagated_modes)
mean_mode = mean_data[0]
mean_k_vector = mean_data[1]
else:
mean_mode = modes[0]
mean_k_vector = dispercion_curves.k_v
mode_0 = mean_mode
k_vect = mean_k_vector
v_gr_max = 0
for ind in range(len(k_vect) - 1):
print("Indeks wynosi " + str(ind))
value = (mode_0.points[ind + 1].wkat_complex - mode_0.points[ind].wkat_complex)/(k_vect[ind+1]-k_vect[ind])
if value > v_gr_max:
v_gr_max = value
#------------------Wyliczanie ograniczeń --------------------------------
k_nyq = calculate_k_nyquist(dispercion_curves, dt)
delta_x = calculate_delta_x(k_nyq)
delta_k = calculate_delta_k(v_gr_max.real, time[-1])
n = calculate_n(k_nyq, delta_k) # n to długość wektora x, liczba próbek na odległości
max_k = find_max_k(mode_0, k_vect, new_freq_sampling_kHz[-1])
new_k_sampling_rad_m = []
while max_k/delta_k > 40000:
delta_k = delta_k * 5
k = 0
while k < max_k:
new_k_sampling_rad_m.append(k)
k += delta_k
G_k = []
ind = 0
for temp_k in new_k_sampling_rad_m:
om = find_omega_in_dispercion_curves(mode_0, temp_k, k_vect)
val = find_value_by_omega_in_G_w(signal_after_fft, new_freq_sampling_kHz, om)
G_k.append(val)
ind += 1
v_gr = []
for ind in range(len(new_k_sampling_rad_m) - 1):
value = calculate_group_velocity(mode_0, new_k_sampling_rad_m, ind, k_vect)
v_gr.append(value)
v_gr.append(v_gr[-1])
H_k = []
for ind in range(len(v_gr)):
H_k.append(G_k[ind] * v_gr[ind])
| random_line_split |
||
compensation_disp.py | temp_k > k_vect[-1]:
omega = mode.findPointWithGivenK([mode.points[-2], mode.points[-1]], temp_k)
elif temp_k < k_vect[0]:
if mode.points[0].w < 5:
temp_point = selectMode.Point()
omega = mode.findPointWithGivenK([temp_point, mode.points[0]], temp_k)
else:
omega = mode.points[0].w
else:
for ind in range(len(k_vect)-1):
if k_vect[ind] < temp_k and k_vect[ind + 1] > temp_k:
omega = mode.findPointWithGivenK([mode.points[ind], mode.points[ind+1]], temp_k)
return omega
def find_omega_in_dispercion_curves_rad_s(mode, temp_k, k_vect):
omega = mode.points[0].wkat_complex
if temp_k > k_vect[-1]:
omega = mode.findPointWithGivenK_rad_s([mode.points[-2], mode.points[-1]], temp_k)
elif temp_k < k_vect[0]:
if mode.points[0].w < 5:
temp_point = selectMode.Point()
omega = mode.findPointWithGivenK_rad_s([temp_point, mode.points[0]], temp_k)
else:
omega = mode.points[0].wkat_complex
else:
for ind in range(len(k_vect)-1):
if k_vect[ind] < temp_k and k_vect[ind + 1] > temp_k:
omega = mode.findPointWithGivenK_rad_s([mode.points[ind], mode.points[ind+1]], temp_k)
break
return omega
def find_value_by_omega_in_G_w(G_w, freq_sampling_kHz, omega):
value = -1
for ind in range(len(freq_sampling_kHz)-1):
if freq_sampling_kHz[ind] == omega:
value = G_w[ind]
break
elif freq_sampling_kHz[ind] < omega and freq_sampling_kHz[ind + 1] > omega:
a = (G_w[ind] - G_w[ind+1])/(freq_sampling_kHz[ind] - freq_sampling_kHz[ind +1])
b = G_w[ind] - a * freq_sampling_kHz[ind]
value = a* omega + b
break
if value == -1:
if omega == freq_sampling_kHz[-1]:
value = G_w[-1]
return value
def calculate_group_velocity(mode, k_sampling_rad_m, ind, k_vect):
k1 = k_sampling_rad_m[ind + 1]
k2 = k_sampling_rad_m[ind]
om1 = find_omega_in_dispercion_curves_rad_s(mode, k1, k_vect)
om2 = find_omega_in_dispercion_curves_rad_s(mode, k2, k_vect)
group_velocity = (om1 - om2)/(k1 - k2)
return group_velocity
def calculate_mean_mode(dispercion_curves, numbers_of_propagated_modes):
modes = []
for ind in numbers_of_propagated_modes:
modes.append(dispercion_curves.getMode(ind))
mean_mode = selectMode.Mode()
mean_k_vector = []
omegs = modes[0].all_omega_khz
for ind in range(len(omegs)):
mean_k = modes[0].points[ind].k
for mode_ind in range(len(modes)-1):
calc_k = Anim_dyspersji.curve_sampling_new(modes[mode_ind + 1].all_omega_khz, dispercion_curves.k_v, [omegs[ind]])[0]
mean_k = mean_k + calc_k
mean_k = mean_k/(len(modes))
mean_mode.addPoint(modes[0].points[ind])
mean_mode.points[ind].k = mean_k
mean_k_vector.append(mean_k)
return [mean_mode, mean_k_vector]
def mapping_from_time_to_distance(dispersion, dispercion_curves, propagated_modes, need_to_pad = False):
if need_to_pad:
signal_to_fft = pad_timetraces_zeroes(dispersion[0], dispersion[1])
else:
signal_to_fft = dispersion
signal_after_fft = np.fft.rfft(signal_to_fft[1])
time = signal_to_fft[0]
dt = time[-1]/len(time)
frequency_from_numpy = np.fft.rfftfreq(len(signal_to_fft[1]), d=dt)*1e-3
new_freq_sampling_kHz = frequency_from_numpy
modes = []
for ind in range(len(propagated_modes)):
modes.append(dispercion_curves.getMode(propagated_modes[ind]))
k_vect = dispercion_curves.k_v
G_w = np.sqrt(signal_after_fft.real**2 + signal_after_fft.imag**2)
if len(modes) > 1:
mean_data = calculate_mean_mode(dispercion_curves, propagated_modes)
mean_mode = mean_data[0]
mean_k_vector = mean_data[1]
else:
mean_mode = modes[0]
mean_k_vector = dispercion_curves.k_v
mode_0 = mean_mode
k_vect = mean_k_vector
v_gr_max = 0
for ind in range(len(k_vect) - 1):
print("Indeks wynosi " + str(ind))
value = (mode_0.points[ind + 1].wkat_complex - mode_0.points[ind].wkat_complex)/(k_vect[ind+1]-k_vect[ind])
if value > v_gr_max:
v_gr_max = value
#------------------Wyliczanie ograniczeń --------------------------------
k_nyq = calculate_k_nyquist(dispercion_curves, dt)
delta_x = calculate_delta_x(k_nyq)
delta_k = calculate_delta_k(v_gr_max.real, time[-1])
n = calculate_n(k_nyq, delta_k) # n to długość wektora x, liczba próbek na odległości
max_k = find_max_k(mode_0, k_vect, new_freq_sampling_kHz[-1])
new_k_sampling_rad_m = []
while max_k/delta_k > 40000:
delta_k = delta_k * 5
k = 0
while k < max_k:
new_k_sampling_rad_m.append(k)
k += delta_k
G_k = []
ind = 0
for temp_k in new_k_sampling_rad_m:
om = find_omega_in_dispercion_curves(mode_0, temp_k, k_vect)
val = find_value_by_omega_in_G_w(signal_after_fft, new_freq_sampling_kHz, om)
G_k.append(val)
ind += 1
v_gr = []
for ind in range(len(new_k_sampling_rad_m) - 1):
value = calculate_group_velocity(mode_0, new_k_sampling_rad_m, ind, k_vect)
v_gr.append(value)
v_gr.append(v_gr[-1])
H_k = []
for ind in range(len(v_gr)):
H_k.append(G_k[ind] * v_gr[ind])
h_x = np.fft.ifft(H_k) / (2000 * np.pi)
distance = 1/delta_k # w metrach
n = len(h_x)
dx = distance/n
dist_vect = []
for i in range(n):
dist_vect.append(i*dx*2*np.pi/len(propagated_modes))
return [dist_vect, h_x]
def wave_length_propagation(signal, numbers_of_modes, disp_curves, distance_m, F_PADZEROS, mult=8):
modes_table = []
for mode_number in numbers_of_modes:
modes_table.append(disp_curves.getMode(mode_number))
if F_PADZEROS:
signal_to_fft = pad_timetraces_zeroes(signal[0], signal[1], mult)
else:
signal_to_fft = signal
signal_after_fft = np.fft.rfft(signal_to_fft[1])
time = signal_to_fft[0]
dt = time[-1]/len(time)
frequency_from_numpy = np.fft.rfftfreq(len(signal_to_fft[1]), d=dt)*1e-3#*1e4
k_vect = []
new_signal_after_fft = []
for ind, f in enumerate(frequency_from_numpy):
k_vect.append(0)
for mode in modes_table:
k_vect[-1] += mode.findKWithGivenOmega_kHz(f)
new_signal_after_fft.append(signal_after_fft[ind] * np.exp(-1j * k_vect[ind] * distance_m))
propagated_signal = np.fft.irfft(new_signal_after_fft) #/distance_m
new_time = np.linspace(time[0], time[-1], len(propagated_signal))
return [new_time, propagated_signal]
def time_reverse(signal):
time_vector = signal[0]
new_signal = []
for s in signal[1]:
new_signal.append(s)
new_signal.reverse()
return [time_vector, new_signal]
def time_reverse_compensation(signal, distance, numbers_of_modes, disp_curves):
signal_temp = wave_length_propagation(signal, numbers_of_modes, disp_curves, distance, True, 100)
return time_reverse(signal_temp)
def linear_mapping_compensation(signal, number_of_modes, disp_c | urves):
signal_after_f | identifier_name |
|
channelamqp.go | AMQPChannelStatus", 0, err)
return err
}
// Given a PCF response message, parse it to extract the desired statistics
func parseAMQPChlData(instanceType int32, cfh *ibmmq.MQCFH, buf []byte) string {
var elem *ibmmq.PCFParameter
traceEntry("parseAMQPChlData")
ci := getConnection(GetConnectionKey())
//os := &ci.objectStatus[OT_CHANNEL_AMQP]
st := GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP)
chlName := ""
connName := ""
clientId := ""
key := ""
lastMsgDate := ""
lastMsgTime := ""
parmAvail := true
bytesRead := 0
offset := 0
datalen := len(buf)
if cfh == nil || cfh.ParameterCount == 0 {
traceExit("parseAMQPChlData", 1)
return ""
}
// Parse it once to extract the fields that are needed for the map key
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
switch elem.Parameter {
case ibmmq.MQCACH_CHANNEL_NAME:
chlName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CONNECTION_NAME:
connName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CLIENT_ID:
clientId = strings.TrimSpace(elem.String[0])
}
}
// Create a unique key for this channel instance
if connName == "" {
connName = DUMMY_STRING
}
if ci.hideAMQPClientId {
clientId = DUMMY_STRING
}
key = chlName + "/" + connName + "/" + clientId
logDebug("AMQP status - key: %s", key)
st.Attributes[ATTR_CHL_NAME].Values[key] = newStatusValueString(chlName)
st.Attributes[ATTR_CHL_CONNNAME].Values[key] = newStatusValueString(connName)
st.Attributes[ATTR_CHL_AMQP_CLIENT_ID].Values[key] = newStatusValueString(clientId)
// And then re-parse the message so we can store the metrics now knowing the map key
parmAvail = true
offset = 0
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
if !statusGetIntAttributes(GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP), elem, key) {
switch elem.Parameter {
case ibmmq.MQCACH_LAST_MSG_TIME:
lastMsgTime = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_LAST_MSG_DATE:
lastMsgDate = strings.TrimSpace(elem.String[0])
}
}
}
now := time.Now()
diff := statusTimeDiff(now, lastMsgDate, lastMsgTime)
st.Attributes[ATTR_CHL_SINCE_MSG].Values[key] = newStatusValueInt64(diff)
// Bump the number of active instances of the channel, treating it a bit like a
// regular config attribute.
if s, ok := amqpInfoMap[chlName]; ok {
s.AttrCurInst++
}
traceExitF("parseAMQPChlData", 0, "Key: %s", key)
return key
}
// Issue the INQUIRE_CHANNEL call for wildcarded channel names and
// extract the required attributes
func inquireAMQPChannelAttributes(objectPatternsList string, infoMap map[string]*ObjInfo) error {
var err error
traceEntry("inquireAMQPChannelAttributes")
ci := getConnection(GetConnectionKey())
statusClearReplyQ()
if objectPatternsList == "" {
traceExitErr("inquireAMQPChannelAttributes", 1, err)
return err
}
objectPatterns := strings.Split(strings.TrimSpace(objectPatternsList), ",")
for i := 0; i < len(objectPatterns) && err == nil; i++ {
var buf []byte
pattern := strings.TrimSpace(objectPatterns[i])
if len(pattern) == 0 {
continue
}
putmqmd, pmo, cfh, buf := statusSetCommandHeaders()
// Can allow all the other fields to default
cfh.Command = ibmmq.MQCMD_INQUIRE_CHANNEL
cfh.ParameterCount = 0
// Add the parameters one at a time into a buffer
pcfparm := new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_STRING
pcfparm.Parameter = ibmmq.MQCACH_CHANNEL_NAME
pcfparm.String = []string{pattern}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_INTEGER
pcfparm.Parameter = ibmmq.MQIACH_CHANNEL_TYPE
pcfparm.Int64Value = []int64{int64(ibmmq.MQCHT_AMQP)}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_INTEGER_LIST
pcfparm.Parameter = ibmmq.MQIACF_CHANNEL_ATTRS
pcfparm.Int64Value = []int64{int64(ibmmq.MQIACH_MAX_INSTANCES), int64(ibmmq.MQIACH_MAX_INSTS_PER_CLIENT), int64(ibmmq.MQCACH_DESC), int64(ibmmq.MQIACH_CHANNEL_TYPE)}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
// Once we know the total number of parameters, put the
// CFH header on the front of the buffer.
buf = append(cfh.Bytes(), buf...)
// And now put the command to the queue
err = ci.si.cmdQObj.Put(putmqmd, pmo, buf)
if err != nil {
traceExitErr("inquireAMQPChannelAttributes", 2, err)
return err
}
for allReceived := false; !allReceived; {
cfh, buf, allReceived, err = statusGetReply(putmqmd.MsgId)
if buf != nil {
parseAMQPChannelAttrData(cfh, buf, infoMap)
}
}
}
traceExit("inquireAMQPChannelAttributes", 0)
return nil
}
func parseAMQPChannelAttrData(cfh *ibmmq.MQCFH, buf []byte, infoMap map[string]*ObjInfo) {
var elem *ibmmq.PCFParameter
var ci *ObjInfo
var ok bool
traceEntry("parseAMQPChannelAttrData")
chlName := ""
parmAvail := true
bytesRead := 0
offset := 0
datalen := len(buf)
if cfh.ParameterCount == 0 {
traceExit("parseAMQPChannelAttrData", 1)
return
}
// Parse it once to extract the fields that are needed for the map key
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
// Only one field needed for channels
switch elem.Parameter {
case ibmmq.MQCACH_CHANNEL_NAME:
chlName = strings.TrimSpace(elem.String[0])
}
}
// And then re-parse the message so we can store the metrics now knowing the map key
parmAvail = true
offset = 0
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
switch elem.Parameter {
case ibmmq.MQIACH_MAX_INSTANCES:
v := elem.Int64Value[0]
if v > 0 {
if ci, ok = infoMap[chlName]; !ok {
ci = new(ObjInfo)
infoMap[chlName] = ci
}
ci.AttrMaxInst = v
ci.exists = true
}
case ibmmq.MQIACH_MAX_INSTS_PER_CLIENT:
v := elem.Int64Value[0]
if v > 0 {
if ci, ok = infoMap[chlName]; !ok {
ci = new(ObjInfo)
infoMap[chlName] = ci
}
ci.AttrMaxInstC = v
ci.exists = true
} |
case ibmmq.MQIACH_CHANNEL_TYPE: | random_line_split |
|
channelamqp.go | Attribute(attr, "Channel Status", ibmmq.MQIACH_CHANNEL_STATUS)
attr = ATTR_CHL_SINCE_MSG
st.Attributes[attr] = newStatusAttribute(attr, "Time Since Msg", -1)
// These are not really monitoring metrics but it may enable calculations to be made such as %used for
// the channel instance availability. It's extracted at startup of the program via INQUIRE_CHL and not updated later
// until rediscovery is done based on a separate schedule.
attr = ATTR_CHL_MAX_INST
st.Attributes[attr] = newStatusAttribute(attr, "MaxInst", -1)
attr = ATTR_CHL_MAX_INSTC
st.Attributes[attr] = newStatusAttribute(attr, "MaxInstC", -1)
// Current Instances is treated a bit oddly. Although reported on each channel status,
// it actually refers to the total number of instances of the same name.
attr = ATTR_CHL_CUR_INST
st.Attributes[attr] = newStatusAttribute(attr, "Current Instances", -1)
os.init = true
traceExit("ChannelAMQPInitAttributes", 0)
}
// If we need to list the channels that match a pattern. Not needed for
// the status queries as they (unlike the pub/sub resource stats) accept
// patterns in the PCF command
func InquireAMQPChannels(patterns string) ([]string, error) {
traceEntry("InquireAMQPChannels")
ChannelAMQPInitAttributes()
rc, err := inquireObjectsWithFilter(patterns, ibmmq.MQOT_CHANNEL, OT_CHANNEL_AMQP)
traceExitErr("InquireAMQPChannels", 0, err)
return rc, err
}
func CollectAMQPChannelStatus(patterns string) error {
var err error
traceEntry("CollectAMQPChannelStatus")
ci := getConnection(GetConnectionKey())
os := &ci.objectStatus[OT_CHANNEL_AMQP]
st := GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP)
os.objectSeen = make(map[string]bool) // Record which channels have been seen in this period
ChannelAMQPInitAttributes()
// Empty any collected values
for k := range st.Attributes |
for k := range amqpInfoMap {
amqpInfoMap[k].AttrCurInst = 0
}
channelPatterns := strings.Split(patterns, ",")
if len(channelPatterns) == 0 {
traceExit("CollectAMQPChannelStatus", 1)
return nil
}
for _, pattern := range channelPatterns {
pattern = strings.TrimSpace(pattern)
if len(pattern) == 0 {
continue
}
// This would allow us to extract SAVED information too
errCurrent := collectAMQPChannelStatus(pattern, ibmmq.MQOT_CURRENT_CHANNEL)
err = errCurrent
}
// Need to clean out the prevValues elements to stop short-lived channels
// building up in the map
for a, _ := range st.Attributes {
if st.Attributes[a].delta {
m := st.Attributes[a].prevValues
for key, _ := range m {
if _, ok := os.objectSeen[key]; ok {
// Leave it in the map
} else {
// need to delete it from the map
delete(m, key)
}
}
}
}
// Set the metrics corresponding to attributes for all the monitored channels
// The current instance count is not, strictly speaking, an attribute but it's a way
// of providing a metric alongside each channel which shows how many there are of that name.
// All instances of the same channel name, regardless of other aspects (eg remote connName)
// are given the same instance count so it could be extracted.
for key, _ := range st.Attributes[ATTR_CHL_NAME].Values {
chlName := st.Attributes[ATTR_CHL_NAME].Values[key].ValueString
if s, ok := amqpInfoMap[chlName]; ok {
maxInstC := s.AttrMaxInstC
st.Attributes[ATTR_CHL_MAX_INSTC].Values[key] = newStatusValueInt64(maxInstC)
maxInst := s.AttrMaxInst
st.Attributes[ATTR_CHL_MAX_INST].Values[key] = newStatusValueInt64(maxInst)
curInst := s.AttrCurInst
st.Attributes[ATTR_CHL_CUR_INST].Values[key] = newStatusValueInt64(curInst)
}
}
traceExitErr("CollectAMQPChannelStatus", 0, err)
return err
}
// Issue the INQUIRE_CHANNEL_STATUS command for a channel or wildcarded channel name
// Collect the responses and build up the statistics. Add CLIENTID(*) to get the actual
// instances instead of an aggregated response
func collectAMQPChannelStatus(pattern string, instanceType int32) error {
var err error
traceEntryF("collectAMQPChannelStatus", "Pattern: %s", pattern)
ci := getConnection(GetConnectionKey())
os := &ci.objectStatus[OT_CHANNEL_AMQP]
statusClearReplyQ()
putmqmd, pmo, cfh, buf := statusSetCommandHeaders()
// Can allow all the other fields to default
cfh.Command = ibmmq.MQCMD_INQUIRE_CHANNEL_STATUS
// Add the parameters one at a time into a buffer
pcfparm := new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_STRING
pcfparm.Parameter = ibmmq.MQCACH_CHANNEL_NAME
pcfparm.String = []string{pattern}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
// Add the parameters one at a time into a buffer
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_INTEGER
pcfparm.Parameter = ibmmq.MQIACH_CHANNEL_TYPE
pcfparm.Int64Value = []int64{int64(ibmmq.MQCHT_AMQP)}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_STRING
pcfparm.Parameter = ibmmq.MQCACH_CLIENT_ID
pcfparm.String = []string{"*"}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
// Once we know the total number of parameters, put the
// CFH header on the front of the buffer.
buf = append(cfh.Bytes(), buf...)
// And now put the command to the queue
err = ci.si.cmdQObj.Put(putmqmd, pmo, buf)
if err != nil {
traceExitErr("collectAMQPChannelStatus", 1, err)
return err
}
// Now get the responses - loop until all have been received (one
// per channel) or we run out of time
for allReceived := false; !allReceived; {
cfh, buf, allReceived, err = statusGetReply(putmqmd.MsgId)
if buf != nil {
key := parseAMQPChlData(instanceType, cfh, buf)
if key != "" {
os.objectSeen[key] = true
}
}
}
traceExitErr("collectAMQPChannelStatus", 0, err)
return err
}
// Given a PCF response message, parse it to extract the desired statistics
func parseAMQPChlData(instanceType int32, cfh *ibmmq.MQCFH, buf []byte) string {
var elem *ibmmq.PCFParameter
traceEntry("parseAMQPChlData")
ci := getConnection(GetConnectionKey())
//os := &ci.objectStatus[OT_CHANNEL_AMQP]
st := GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP)
chlName := ""
connName := ""
clientId := ""
key := ""
lastMsgDate := ""
lastMsgTime := ""
parmAvail := true
bytesRead := 0
offset := 0
datalen := len(buf)
if cfh == nil || cfh.ParameterCount == 0 {
traceExit("parseAMQPChlData", 1)
return ""
}
// Parse it once to extract the fields that are needed for the map key
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
switch elem.Parameter {
case ibmmq.MQCACH_CHANNEL_NAME:
chlName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CONNECTION_NAME:
connName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CLIENT_ID:
clientId = strings.TrimSpace(elem.String[0])
}
}
// Create a unique key for this channel instance
if connName == "" {
connName = DUMMY_STRING
}
if ci.hideAMQPClientId {
clientId = DUMMY_STRING
}
key = chlName + "/" + connName + "/" + clientId
logDebug("AMQP status - key: %s", key)
st.Attributes[ATTR_CHL_NAME].Values[key] = newStatusValueString(chlName)
st.Attributes[ATTR_CHL_CONNNAME].Values[key] = new | {
st.Attributes[k].Values = make(map[string]*StatusValue)
} | conditional_block |
channelamqp.go | Attribute(attr, "Channel Status", ibmmq.MQIACH_CHANNEL_STATUS)
attr = ATTR_CHL_SINCE_MSG
st.Attributes[attr] = newStatusAttribute(attr, "Time Since Msg", -1)
// These are not really monitoring metrics but it may enable calculations to be made such as %used for
// the channel instance availability. It's extracted at startup of the program via INQUIRE_CHL and not updated later
// until rediscovery is done based on a separate schedule.
attr = ATTR_CHL_MAX_INST
st.Attributes[attr] = newStatusAttribute(attr, "MaxInst", -1)
attr = ATTR_CHL_MAX_INSTC
st.Attributes[attr] = newStatusAttribute(attr, "MaxInstC", -1)
// Current Instances is treated a bit oddly. Although reported on each channel status,
// it actually refers to the total number of instances of the same name.
attr = ATTR_CHL_CUR_INST
st.Attributes[attr] = newStatusAttribute(attr, "Current Instances", -1)
os.init = true
traceExit("ChannelAMQPInitAttributes", 0)
}
// If we need to list the channels that match a pattern. Not needed for
// the status queries as they (unlike the pub/sub resource stats) accept
// patterns in the PCF command
func InquireAMQPChannels(patterns string) ([]string, error) {
traceEntry("InquireAMQPChannels")
ChannelAMQPInitAttributes()
rc, err := inquireObjectsWithFilter(patterns, ibmmq.MQOT_CHANNEL, OT_CHANNEL_AMQP)
traceExitErr("InquireAMQPChannels", 0, err)
return rc, err
}
func CollectAMQPChannelStatus(patterns string) error | }
channelPatterns := strings.Split(patterns, ",")
if len(channelPatterns) == 0 {
traceExit("CollectAMQPChannelStatus", 1)
return nil
}
for _, pattern := range channelPatterns {
pattern = strings.TrimSpace(pattern)
if len(pattern) == 0 {
continue
}
// This would allow us to extract SAVED information too
errCurrent := collectAMQPChannelStatus(pattern, ibmmq.MQOT_CURRENT_CHANNEL)
err = errCurrent
}
// Need to clean out the prevValues elements to stop short-lived channels
// building up in the map
for a, _ := range st.Attributes {
if st.Attributes[a].delta {
m := st.Attributes[a].prevValues
for key, _ := range m {
if _, ok := os.objectSeen[key]; ok {
// Leave it in the map
} else {
// need to delete it from the map
delete(m, key)
}
}
}
}
// Set the metrics corresponding to attributes for all the monitored channels
// The current instance count is not, strictly speaking, an attribute but it's a way
// of providing a metric alongside each channel which shows how many there are of that name.
// All instances of the same channel name, regardless of other aspects (eg remote connName)
// are given the same instance count so it could be extracted.
for key, _ := range st.Attributes[ATTR_CHL_NAME].Values {
chlName := st.Attributes[ATTR_CHL_NAME].Values[key].ValueString
if s, ok := amqpInfoMap[chlName]; ok {
maxInstC := s.AttrMaxInstC
st.Attributes[ATTR_CHL_MAX_INSTC].Values[key] = newStatusValueInt64(maxInstC)
maxInst := s.AttrMaxInst
st.Attributes[ATTR_CHL_MAX_INST].Values[key] = newStatusValueInt64(maxInst)
curInst := s.AttrCurInst
st.Attributes[ATTR_CHL_CUR_INST].Values[key] = newStatusValueInt64(curInst)
}
}
traceExitErr("CollectAMQPChannelStatus", 0, err)
return err
}
// Issue the INQUIRE_CHANNEL_STATUS command for a channel or wildcarded channel name
// Collect the responses and build up the statistics. Add CLIENTID(*) to get the actual
// instances instead of an aggregated response
func collectAMQPChannelStatus(pattern string, instanceType int32) error {
var err error
traceEntryF("collectAMQPChannelStatus", "Pattern: %s", pattern)
ci := getConnection(GetConnectionKey())
os := &ci.objectStatus[OT_CHANNEL_AMQP]
statusClearReplyQ()
putmqmd, pmo, cfh, buf := statusSetCommandHeaders()
// Can allow all the other fields to default
cfh.Command = ibmmq.MQCMD_INQUIRE_CHANNEL_STATUS
// Add the parameters one at a time into a buffer
pcfparm := new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_STRING
pcfparm.Parameter = ibmmq.MQCACH_CHANNEL_NAME
pcfparm.String = []string{pattern}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
// Add the parameters one at a time into a buffer
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_INTEGER
pcfparm.Parameter = ibmmq.MQIACH_CHANNEL_TYPE
pcfparm.Int64Value = []int64{int64(ibmmq.MQCHT_AMQP)}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_STRING
pcfparm.Parameter = ibmmq.MQCACH_CLIENT_ID
pcfparm.String = []string{"*"}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
// Once we know the total number of parameters, put the
// CFH header on the front of the buffer.
buf = append(cfh.Bytes(), buf...)
// And now put the command to the queue
err = ci.si.cmdQObj.Put(putmqmd, pmo, buf)
if err != nil {
traceExitErr("collectAMQPChannelStatus", 1, err)
return err
}
// Now get the responses - loop until all have been received (one
// per channel) or we run out of time
for allReceived := false; !allReceived; {
cfh, buf, allReceived, err = statusGetReply(putmqmd.MsgId)
if buf != nil {
key := parseAMQPChlData(instanceType, cfh, buf)
if key != "" {
os.objectSeen[key] = true
}
}
}
traceExitErr("collectAMQPChannelStatus", 0, err)
return err
}
// Given a PCF response message, parse it to extract the desired statistics
func parseAMQPChlData(instanceType int32, cfh *ibmmq.MQCFH, buf []byte) string {
var elem *ibmmq.PCFParameter
traceEntry("parseAMQPChlData")
ci := getConnection(GetConnectionKey())
//os := &ci.objectStatus[OT_CHANNEL_AMQP]
st := GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP)
chlName := ""
connName := ""
clientId := ""
key := ""
lastMsgDate := ""
lastMsgTime := ""
parmAvail := true
bytesRead := 0
offset := 0
datalen := len(buf)
if cfh == nil || cfh.ParameterCount == 0 {
traceExit("parseAMQPChlData", 1)
return ""
}
// Parse it once to extract the fields that are needed for the map key
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
switch elem.Parameter {
case ibmmq.MQCACH_CHANNEL_NAME:
chlName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CONNECTION_NAME:
connName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CLIENT_ID:
clientId = strings.TrimSpace(elem.String[0])
}
}
// Create a unique key for this channel instance
if connName == "" {
connName = DUMMY_STRING
}
if ci.hideAMQPClientId {
clientId = DUMMY_STRING
}
key = chlName + "/" + connName + "/" + clientId
logDebug("AMQP status - key: %s", key)
st.Attributes[ATTR_CHL_NAME].Values[key] = newStatusValueString(chlName)
st.Attributes[ATTR_CHL_CONNNAME].Values[key] = newStatusValue | {
var err error
traceEntry("CollectAMQPChannelStatus")
ci := getConnection(GetConnectionKey())
os := &ci.objectStatus[OT_CHANNEL_AMQP]
st := GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP)
os.objectSeen = make(map[string]bool) // Record which channels have been seen in this period
ChannelAMQPInitAttributes()
// Empty any collected values
for k := range st.Attributes {
st.Attributes[k].Values = make(map[string]*StatusValue)
}
for k := range amqpInfoMap {
amqpInfoMap[k].AttrCurInst = 0 | identifier_body |
channelamqp.go | (patterns string) error {
var err error
traceEntry("CollectAMQPChannelStatus")
ci := getConnection(GetConnectionKey())
os := &ci.objectStatus[OT_CHANNEL_AMQP]
st := GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP)
os.objectSeen = make(map[string]bool) // Record which channels have been seen in this period
ChannelAMQPInitAttributes()
// Empty any collected values
for k := range st.Attributes {
st.Attributes[k].Values = make(map[string]*StatusValue)
}
for k := range amqpInfoMap {
amqpInfoMap[k].AttrCurInst = 0
}
channelPatterns := strings.Split(patterns, ",")
if len(channelPatterns) == 0 {
traceExit("CollectAMQPChannelStatus", 1)
return nil
}
for _, pattern := range channelPatterns {
pattern = strings.TrimSpace(pattern)
if len(pattern) == 0 {
continue
}
// This would allow us to extract SAVED information too
errCurrent := collectAMQPChannelStatus(pattern, ibmmq.MQOT_CURRENT_CHANNEL)
err = errCurrent
}
// Need to clean out the prevValues elements to stop short-lived channels
// building up in the map
for a, _ := range st.Attributes {
if st.Attributes[a].delta {
m := st.Attributes[a].prevValues
for key, _ := range m {
if _, ok := os.objectSeen[key]; ok {
// Leave it in the map
} else {
// need to delete it from the map
delete(m, key)
}
}
}
}
// Set the metrics corresponding to attributes for all the monitored channels
// The current instance count is not, strictly speaking, an attribute but it's a way
// of providing a metric alongside each channel which shows how many there are of that name.
// All instances of the same channel name, regardless of other aspects (eg remote connName)
// are given the same instance count so it could be extracted.
for key, _ := range st.Attributes[ATTR_CHL_NAME].Values {
chlName := st.Attributes[ATTR_CHL_NAME].Values[key].ValueString
if s, ok := amqpInfoMap[chlName]; ok {
maxInstC := s.AttrMaxInstC
st.Attributes[ATTR_CHL_MAX_INSTC].Values[key] = newStatusValueInt64(maxInstC)
maxInst := s.AttrMaxInst
st.Attributes[ATTR_CHL_MAX_INST].Values[key] = newStatusValueInt64(maxInst)
curInst := s.AttrCurInst
st.Attributes[ATTR_CHL_CUR_INST].Values[key] = newStatusValueInt64(curInst)
}
}
traceExitErr("CollectAMQPChannelStatus", 0, err)
return err
}
// Issue the INQUIRE_CHANNEL_STATUS command for a channel or wildcarded channel name
// Collect the responses and build up the statistics. Add CLIENTID(*) to get the actual
// instances instead of an aggregated response
func collectAMQPChannelStatus(pattern string, instanceType int32) error {
var err error
traceEntryF("collectAMQPChannelStatus", "Pattern: %s", pattern)
ci := getConnection(GetConnectionKey())
os := &ci.objectStatus[OT_CHANNEL_AMQP]
statusClearReplyQ()
putmqmd, pmo, cfh, buf := statusSetCommandHeaders()
// Can allow all the other fields to default
cfh.Command = ibmmq.MQCMD_INQUIRE_CHANNEL_STATUS
// Add the parameters one at a time into a buffer
pcfparm := new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_STRING
pcfparm.Parameter = ibmmq.MQCACH_CHANNEL_NAME
pcfparm.String = []string{pattern}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
// Add the parameters one at a time into a buffer
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_INTEGER
pcfparm.Parameter = ibmmq.MQIACH_CHANNEL_TYPE
pcfparm.Int64Value = []int64{int64(ibmmq.MQCHT_AMQP)}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
pcfparm = new(ibmmq.PCFParameter)
pcfparm.Type = ibmmq.MQCFT_STRING
pcfparm.Parameter = ibmmq.MQCACH_CLIENT_ID
pcfparm.String = []string{"*"}
cfh.ParameterCount++
buf = append(buf, pcfparm.Bytes()...)
// Once we know the total number of parameters, put the
// CFH header on the front of the buffer.
buf = append(cfh.Bytes(), buf...)
// And now put the command to the queue
err = ci.si.cmdQObj.Put(putmqmd, pmo, buf)
if err != nil {
traceExitErr("collectAMQPChannelStatus", 1, err)
return err
}
// Now get the responses - loop until all have been received (one
// per channel) or we run out of time
for allReceived := false; !allReceived; {
cfh, buf, allReceived, err = statusGetReply(putmqmd.MsgId)
if buf != nil {
key := parseAMQPChlData(instanceType, cfh, buf)
if key != "" {
os.objectSeen[key] = true
}
}
}
traceExitErr("collectAMQPChannelStatus", 0, err)
return err
}
// Given a PCF response message, parse it to extract the desired statistics
func parseAMQPChlData(instanceType int32, cfh *ibmmq.MQCFH, buf []byte) string {
var elem *ibmmq.PCFParameter
traceEntry("parseAMQPChlData")
ci := getConnection(GetConnectionKey())
//os := &ci.objectStatus[OT_CHANNEL_AMQP]
st := GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP)
chlName := ""
connName := ""
clientId := ""
key := ""
lastMsgDate := ""
lastMsgTime := ""
parmAvail := true
bytesRead := 0
offset := 0
datalen := len(buf)
if cfh == nil || cfh.ParameterCount == 0 {
traceExit("parseAMQPChlData", 1)
return ""
}
// Parse it once to extract the fields that are needed for the map key
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
switch elem.Parameter {
case ibmmq.MQCACH_CHANNEL_NAME:
chlName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CONNECTION_NAME:
connName = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_CLIENT_ID:
clientId = strings.TrimSpace(elem.String[0])
}
}
// Create a unique key for this channel instance
if connName == "" {
connName = DUMMY_STRING
}
if ci.hideAMQPClientId {
clientId = DUMMY_STRING
}
key = chlName + "/" + connName + "/" + clientId
logDebug("AMQP status - key: %s", key)
st.Attributes[ATTR_CHL_NAME].Values[key] = newStatusValueString(chlName)
st.Attributes[ATTR_CHL_CONNNAME].Values[key] = newStatusValueString(connName)
st.Attributes[ATTR_CHL_AMQP_CLIENT_ID].Values[key] = newStatusValueString(clientId)
// And then re-parse the message so we can store the metrics now knowing the map key
parmAvail = true
offset = 0
for parmAvail && cfh.CompCode != ibmmq.MQCC_FAILED {
elem, bytesRead = ibmmq.ReadPCFParameter(buf[offset:])
offset += bytesRead
// Have we now reached the end of the message
if offset >= datalen {
parmAvail = false
}
if !statusGetIntAttributes(GetObjectStatus(GetConnectionKey(), OT_CHANNEL_AMQP), elem, key) {
switch elem.Parameter {
case ibmmq.MQCACH_LAST_MSG_TIME:
lastMsgTime = strings.TrimSpace(elem.String[0])
case ibmmq.MQCACH_LAST_MSG_DATE:
lastMsgDate = strings.TrimSpace(elem.String[0])
}
}
}
now := time.Now()
diff := statusTimeDiff(now, lastMsgDate, lastMsgTime)
st.Attributes[ATTR_CHL_SINCE_MSG].Values[key] = newStatusValueInt64(diff)
// Bump the number of active instances of the channel, treating it a bit like a
// regular config attribute.
if s, ok := amqpInfoMap[chlName]; ok {
s.AttrCurInst++
}
traceExitF("parseAMQPChlData", 0, "Key: %s", key)
return key
}
// Issue the INQUIRE_CHANNEL call for wildcarded channel names and
// extract the required attributes
func | inquireAMQPChannelAttributes | identifier_name |
|
btckey.go | G */
Q := secp256k1.ScalarBaseMult(priv.D)
/* Check that Q is on the curve */
if !secp256k1.IsOnCurve(Q) {
panic("Catastrophic math logic failure in public key derivation.")
}
priv.X = Q.X
priv.Y = Q.Y
return &priv.PublicKey
}
// GenerateKey generates a public and private key pair using random source rand.
func GenerateKey(rand io.Reader) (priv PrivateKey, err error) {
/* See Certicom's SEC1 3.2.1, pg.23 */
/* See NSA's Suite B Implementer’s Guide to FIPS 186-3 (ECDSA) A.1.1, pg.18 */
/* Select private key d randomly from [1, n) */
/* Read N bit length random bytes + 64 extra bits */
b := make([]byte, secp256k1.N.BitLen()/8+8)
_, err = io.ReadFull(rand, b)
if err != nil {
return priv, fmt.Errorf("Reading random reader: %v", err)
}
d := new(big.Int).SetBytes(b)
/* Mod n-1 to shift d into [0, n-1) range */
d.Mod(d, new(big.Int).Sub(secp256k1.N, big.NewInt(1)))
/* Add one to shift d to [1, n) range */
d.Add(d, big.NewInt(1))
priv.D = d
/* Derive public key from private key */
priv.derive()
return priv, nil
}
/******************************************************************************/
/* Base-58 Encode/Decode */
/******************************************************************************/
// b58encode encodes a byte slice b into a base-58 encoded string.
func b58encode(b []byte) (s string) {
/* See https://en.bitcoin.it/wiki/Base58Check_encoding */
const BITCOIN_BASE58_TABLE = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
/* Convert big endian bytes to big int */
x := new(big.Int).SetBytes(b)
/* Initialize */
r := new(big.Int)
m := big.NewInt(58)
zero := big.NewInt(0)
s = ""
/* Convert big int to string */
for x.Cmp(zero) > 0 {
/* x, r = (x / 58, x % 58) */
x.QuoRem(x, m, r)
/* Prepend ASCII character */
s = string(BITCOIN_BASE58_TABLE[r.Int64()]) + s
}
return s
}
// b58decode decodes a base-58 encoded string into a byte slice b.
func b58decode(s string) (b []byte, err error) {
/* See https://en.bitcoin.it/wiki/Base58Check_encoding */
const BITCOIN_BASE58_TABLE = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
/* Initialize */
x := big.NewInt(0)
m := big.NewInt(58)
/* Convert string to big int */
for i := 0; i < len(s); i++ {
b58index := strings.IndexByte(BITCOIN_BASE58_TABLE, s[i])
if b58index == -1 {
return nil, fmt.Errorf("Invalid base-58 character encountered: '%c', index %d.", s[i], i)
}
b58value := big.NewInt(int64(b58index))
x.Mul(x, m)
x.Add(x, b58value)
}
/* Convert big int to big endian bytes */
b = x.Bytes()
return b, nil
}
/******************************************************************************/
/* Base-58 Check Encode/Decode */
/******************************************************************************/
// b58checkencode encodes version ver and byte slice b into a base-58 check encoded string.
func b58checkencode(ver uint8, b []byte) (s string) {
/* Prepend version */
bcpy := append([]byte{ver}, b...)
/* Create a new SHA256 context */
sha256_h := sha256.New()
/* SHA256 Hash #1 */
sha256_h.Reset()
sha256_h.Write(bcpy)
hash1 := sha256_h.Sum(nil)
/* SHA256 Hash #2 */
sha256_h.Reset()
sha256_h.Write(hash1)
hash2 := sha256_h.Sum(nil)
/* Append first four bytes of hash */
bcpy = append(bcpy, hash2[0:4]...)
/* Encode base58 string */
s = b58encode(bcpy)
/* For number of leading 0's in bytes, prepend 1 */
for _, v := range bcpy {
if v != 0 {
break
}
s = "1" + s
}
return s
}
// b58checkdecode decodes base-58 check encoded string s into a version ver and byte slice b.
func b58checkdecode(s string) (ver uint8, b []byte, err error) {
/* Decode base58 string */
b, err = b58decode(s)
if err != nil {
return 0, nil, err
}
/* Add leading zero bytes */
for i := 0; i < len(s); i++ {
if s[i] != '1' {
| b = append([]byte{0x3f}, b...)
}
/* Verify checksum */
if len(b) < 5 {
return 0, nil, fmt.Errorf("Invalid base-58 check string: missing checksum.")
}
/* Create a new SHA256 context */
sha256_h := sha256.New()
/* SHA256 Hash #1 */
sha256_h.Reset()
sha256_h.Write(b[:len(b)-4])
hash1 := sha256_h.Sum(nil)
/* SHA256 Hash #2 */
sha256_h.Reset()
sha256_h.Write(hash1)
hash2 := sha256_h.Sum(nil)
/* Compare checksum */
if bytes.Compare(hash2[0:4], b[len(b)-4:]) != 0 {
return 0, nil, fmt.Errorf("Invalid base-58 check string: invalid checksum.")
}
/* Strip checksum bytes */
b = b[:len(b)-4]
/* Extract and strip version */
ver = b[0]
b = b[1:]
return ver, b, nil
}
/******************************************************************************/
/* Bitcoin Private Key Import/Export */
/******************************************************************************/
// CheckWIF checks that string wif is a valid Wallet Import Format or Wallet Import Format Compressed string. If it is not, err is populated with the reason.
func CheckWIF(wif string) (valid bool, err error) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Base58 Check Decode the WIF string */
ver, priv_bytes, err := b58checkdecode(wif)
if err != nil {
return false, err
}
/* Check that the version byte is 0x80 */
if ver != 0x80 {
return false, fmt.Errorf("Invalid WIF version 0x%02x, expected 0x80.", ver)
}
/* Check that private key bytes length is 32 or 33 */
if len(priv_bytes) != 32 && len(priv_bytes) != 33 {
return false, fmt.Errorf("Invalid private key bytes length %d, expected 32 or 33.", len(priv_bytes))
}
/* If the private key bytes length is 33, check that suffix byte is 0x01 (for compression) */
if len(priv_bytes) == 33 && priv_bytes[len(priv_bytes)-1] != 0x01 {
return false, fmt.Errorf("Invalid private key bytes, unknown suffix byte 0x%02x.", priv_bytes[len(priv_bytes)-1])
}
return true, nil
}
// ToBytes converts a Bitcoin private key to a 32-byte byte slice.
func (priv *PrivateKey) ToBytes() (b []byte) {
d := priv.D.Bytes()
/* Pad D to 32 bytes */
padded_d := append(bytes.Repeat([]byte{0x3f}, 32-len(d)), d...)
return padded_d
}
// FromBytes converts a 32-byte byte slice to a Bitcoin private key and derives the corresponding Bitcoin public key.
func (priv *PrivateKey) FromBytes(b []byte) (err error) {
if len(b) != 32 {
return fmt.Errorf("Invalid private key bytes length %d, expected 32.", len(b))
}
priv.D = new(big.Int).SetBytes(b)
/* Derive public key from private key */
priv.derive()
return nil
}
// ToWIF converts a Bitcoin private key to a Wallet Import Format string.
func (priv *PrivateKey) ToWIF() (wif string) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Convert the private key to bytes */
priv_bytes := priv.ToBytes()
/* Convert bytes to base-58 check encoded string with version | break
}
| conditional_block |
btckey.go | bcpy = append(bcpy, hash2[0:4]...)
/* Encode base58 string */
s = b58encode(bcpy)
/* For number of leading 0's in bytes, prepend 1 */
for _, v := range bcpy {
if v != 0 {
break
}
s = "1" + s
}
return s
}
// b58checkdecode decodes base-58 check encoded string s into a version ver and byte slice b.
func b58checkdecode(s string) (ver uint8, b []byte, err error) {
/* Decode base58 string */
b, err = b58decode(s)
if err != nil {
return 0, nil, err
}
/* Add leading zero bytes */
for i := 0; i < len(s); i++ {
if s[i] != '1' {
break
}
b = append([]byte{0x3f}, b...)
}
/* Verify checksum */
if len(b) < 5 {
return 0, nil, fmt.Errorf("Invalid base-58 check string: missing checksum.")
}
/* Create a new SHA256 context */
sha256_h := sha256.New()
/* SHA256 Hash #1 */
sha256_h.Reset()
sha256_h.Write(b[:len(b)-4])
hash1 := sha256_h.Sum(nil)
/* SHA256 Hash #2 */
sha256_h.Reset()
sha256_h.Write(hash1)
hash2 := sha256_h.Sum(nil)
/* Compare checksum */
if bytes.Compare(hash2[0:4], b[len(b)-4:]) != 0 {
return 0, nil, fmt.Errorf("Invalid base-58 check string: invalid checksum.")
}
/* Strip checksum bytes */
b = b[:len(b)-4]
/* Extract and strip version */
ver = b[0]
b = b[1:]
return ver, b, nil
}
/******************************************************************************/
/* Bitcoin Private Key Import/Export */
/******************************************************************************/
// CheckWIF checks that string wif is a valid Wallet Import Format or Wallet Import Format Compressed string. If it is not, err is populated with the reason.
func CheckWIF(wif string) (valid bool, err error) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Base58 Check Decode the WIF string */
ver, priv_bytes, err := b58checkdecode(wif)
if err != nil {
return false, err
}
/* Check that the version byte is 0x80 */
if ver != 0x80 {
return false, fmt.Errorf("Invalid WIF version 0x%02x, expected 0x80.", ver)
}
/* Check that private key bytes length is 32 or 33 */
if len(priv_bytes) != 32 && len(priv_bytes) != 33 {
return false, fmt.Errorf("Invalid private key bytes length %d, expected 32 or 33.", len(priv_bytes))
}
/* If the private key bytes length is 33, check that suffix byte is 0x01 (for compression) */
if len(priv_bytes) == 33 && priv_bytes[len(priv_bytes)-1] != 0x01 {
return false, fmt.Errorf("Invalid private key bytes, unknown suffix byte 0x%02x.", priv_bytes[len(priv_bytes)-1])
}
return true, nil
}
// ToBytes converts a Bitcoin private key to a 32-byte byte slice.
func (priv *PrivateKey) ToBytes() (b []byte) {
d := priv.D.Bytes()
/* Pad D to 32 bytes */
padded_d := append(bytes.Repeat([]byte{0x3f}, 32-len(d)), d...)
return padded_d
}
// FromBytes converts a 32-byte byte slice to a Bitcoin private key and derives the corresponding Bitcoin public key.
func (priv *PrivateKey) FromBytes(b []byte) (err error) {
if len(b) != 32 {
return fmt.Errorf("Invalid private key bytes length %d, expected 32.", len(b))
}
priv.D = new(big.Int).SetBytes(b)
/* Derive public key from private key */
priv.derive()
return nil
}
// ToWIF converts a Bitcoin private key to a Wallet Import Format string.
func (priv *PrivateKey) ToWIF() (wif string) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Convert the private key to bytes */
priv_bytes := priv.ToBytes()
/* Convert bytes to base-58 check encoded string with version 0x80 */
wif = b58checkencode(0x80, priv_bytes)
return wif
}
// ToWIFC converts a Bitcoin private key to a Wallet Import Format string with the public key compressed flag.
func (priv *PrivateKey) ToWIFC() (wifc string) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Convert the private key to bytes */
priv_bytes := priv.ToBytes()
/* Append 0x01 to tell Bitcoin wallet to use compressed public keys */
priv_bytes = append(priv_bytes, []byte{0x01}...)
/* Convert bytes to base-58 check encoded string with version 0x80 */
wifc = b58checkencode(0x80, priv_bytes)
return wifc
}
// FromWIF converts a Wallet Import Format string to a Bitcoin private key and derives the corresponding Bitcoin public key.
func (priv *PrivateKey) FromWIF(wif string) (err error) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Base58 Check Decode the WIF string */
ver, priv_bytes, err := b58checkdecode(wif)
if err != nil {
return err
}
/* Check that the version byte is 0x80 */
if ver != 0x80 {
return fmt.Errorf("Invalid WIF version 0x%02x, expected 0x80.", ver)
}
/* If the private key bytes length is 33, check that suffix byte is 0x01 (for compression) and strip it off */
if len(priv_bytes) == 33 {
if priv_bytes[len(priv_bytes)-1] != 0x01 {
return fmt.Errorf("Invalid private key, unknown suffix byte 0x%02x.", priv_bytes[len(priv_bytes)-1])
}
priv_bytes = priv_bytes[0:32]
}
/* Convert from bytes to a private key */
err = priv.FromBytes(priv_bytes)
if err != nil {
return err
}
/* Derive public key from private key */
priv.derive()
return nil
}
/******************************************************************************/
/* Bitcoin Public Key Import/Export */
/******************************************************************************/
// ToBytes converts a Bitcoin public key to a 33-byte byte slice with point compression.
func (pub *PublicKey) ToBytes() (b []byte) {
/* See Certicom SEC1 2.3.3, pg. 10 */
x := pub.X.Bytes()
/* Pad X to 32-bytes */
padded_x := append(bytes.Repeat([]byte{0x3f}, 32-len(x)), x...)
/* Add prefix 0x02 or 0x03 depending on ylsb */
if pub.Y.Bit(0) == 0 {
return append([]byte{0x02}, padded_x...)
}
return append([]byte{0x03}, padded_x...)
}
// ToBytesUncompressed converts a Bitcoin public key to a 65-byte byte slice without point compression.
func (pub *PublicKey) ToBytesUncompressed() (b []byte) {
/* See Certicom SEC1 2.3.3, pg. 10 */
x := pub.X.Bytes()
y := pub.Y.Bytes()
/* Pad X and Y coordinate bytes to 32-bytes */
padded_x := append(bytes.Repeat([]byte{0x3f}, 32-len(x)), x...)
padded_y := append(bytes.Repeat([]byte{0x3f}, 32-len(y)), y...)
/* Add prefix 0x04 for uncompressed coordinates */
return append([]byte{0x04}, append(padded_x, padded_y...)...)
}
// FromBytes converts a byte slice (either with or without point compression) to a Bitcoin public key.
func (pub *PublicKey) FromBytes(b []byte) (err error) {
/* See Certicom SEC1 2.3.4, pg. 11 */
if len(b) < 33 {
return fmt.Errorf("Invalid public key bytes length %d, expected at least 33.", len(b))
}
if b[0] == 0x02 || b[0] == 0x03 {
/* Compressed public key */
if len(b) != 33 {
return fmt.Errorf("Invalid public key bytes length %d, expected 33.", len(b))
} |
P, err := secp256k1.Decompress(new(big.Int).SetBytes(b[1:33]), uint(b[0]&0x1))
if err != nil { | random_line_split |
|
btckey.go | G */
Q := secp256k1.ScalarBaseMult(priv.D)
/* Check that Q is on the curve */
if !secp256k1.IsOnCurve(Q) {
panic("Catastrophic math logic failure in public key derivation.")
}
priv.X = Q.X
priv.Y = Q.Y
return &priv.PublicKey
}
// GenerateKey generates a public and private key pair using random source rand.
func GenerateKey(rand io.Reader) (priv PrivateKey, err error) {
/* See Certicom's SEC1 3.2.1, pg.23 */
/* See NSA's Suite B Implementer’s Guide to FIPS 186-3 (ECDSA) A.1.1, pg.18 */
/* Select private key d randomly from [1, n) */
/* Read N bit length random bytes + 64 extra bits */
b := make([]byte, secp256k1.N.BitLen()/8+8)
_, err = io.ReadFull(rand, b)
if err != nil {
return priv, fmt.Errorf("Reading random reader: %v", err)
}
d := new(big.Int).SetBytes(b)
/* Mod n-1 to shift d into [0, n-1) range */
d.Mod(d, new(big.Int).Sub(secp256k1.N, big.NewInt(1)))
/* Add one to shift d to [1, n) range */
d.Add(d, big.NewInt(1))
priv.D = d
/* Derive public key from private key */
priv.derive()
return priv, nil
}
/******************************************************************************/
/* Base-58 Encode/Decode */
/******************************************************************************/
// b58encode encodes a byte slice b into a base-58 encoded string.
func b58encode(b []byte) (s string) {
/* See https://en.bitcoin.it/wiki/Base58Check_encoding */
const BITCOIN_BASE58_TABLE = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
/* Convert big endian bytes to big int */
x := new(big.Int).SetBytes(b)
/* Initialize */
r := new(big.Int)
m := big.NewInt(58)
zero := big.NewInt(0)
s = ""
/* Convert big int to string */
for x.Cmp(zero) > 0 {
/* x, r = (x / 58, x % 58) */
x.QuoRem(x, m, r)
/* Prepend ASCII character */
s = string(BITCOIN_BASE58_TABLE[r.Int64()]) + s
}
return s
}
// b58decode decodes a base-58 encoded string into a byte slice b.
func b58decode(s string) (b []byte, err error) {
/* See https://en.bitcoin.it/wiki/Base58Check_encoding */
const BITCOIN_BASE58_TABLE = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
/* Initialize */
x := big.NewInt(0)
m := big.NewInt(58)
/* Convert string to big int */
for i := 0; i < len(s); i++ {
b58index := strings.IndexByte(BITCOIN_BASE58_TABLE, s[i])
if b58index == -1 {
return nil, fmt.Errorf("Invalid base-58 character encountered: '%c', index %d.", s[i], i)
}
b58value := big.NewInt(int64(b58index))
x.Mul(x, m)
x.Add(x, b58value)
}
/* Convert big int to big endian bytes */
b = x.Bytes()
return b, nil
}
/******************************************************************************/
/* Base-58 Check Encode/Decode */
/******************************************************************************/
// b58checkencode encodes version ver and byte slice b into a base-58 check encoded string.
func b58checkencode(ver uint8, b []byte) (s string) {
/* Prepend version */
bcpy := append([]byte{ver}, b...)
/* Create a new SHA256 context */
sha256_h := sha256.New()
/* SHA256 Hash #1 */
sha256_h.Reset()
sha256_h.Write(bcpy)
hash1 := sha256_h.Sum(nil)
/* SHA256 Hash #2 */
sha256_h.Reset()
sha256_h.Write(hash1)
hash2 := sha256_h.Sum(nil)
/* Append first four bytes of hash */
bcpy = append(bcpy, hash2[0:4]...)
/* Encode base58 string */
s = b58encode(bcpy)
/* For number of leading 0's in bytes, prepend 1 */
for _, v := range bcpy {
if v != 0 {
break
}
s = "1" + s
}
return s
}
// b58checkdecode decodes base-58 check encoded string s into a version ver and byte slice b.
func b58checkdecode(s string) (ver uint8, b []byte, err error) {
/* Decode base58 string */
b, err = b58decode(s)
if err != nil {
return 0, nil, err
}
/* Add leading zero bytes */
for i := 0; i < len(s); i++ {
if s[i] != '1' {
break
}
b = append([]byte{0x3f}, b...)
}
/* Verify checksum */
if len(b) < 5 {
return 0, nil, fmt.Errorf("Invalid base-58 check string: missing checksum.")
}
/* Create a new SHA256 context */
sha256_h := sha256.New()
/* SHA256 Hash #1 */
sha256_h.Reset()
sha256_h.Write(b[:len(b)-4])
hash1 := sha256_h.Sum(nil)
/* SHA256 Hash #2 */
sha256_h.Reset()
sha256_h.Write(hash1)
hash2 := sha256_h.Sum(nil)
/* Compare checksum */
if bytes.Compare(hash2[0:4], b[len(b)-4:]) != 0 {
return 0, nil, fmt.Errorf("Invalid base-58 check string: invalid checksum.")
}
/* Strip checksum bytes */
b = b[:len(b)-4]
/* Extract and strip version */
ver = b[0]
b = b[1:]
return ver, b, nil
}
/******************************************************************************/
/* Bitcoin Private Key Import/Export */
/******************************************************************************/
// CheckWIF checks that string wif is a valid Wallet Import Format or Wallet Import Format Compressed string. If it is not, err is populated with the reason.
func CheckWIF(wif string) (valid bool, err error) {
| return false, fmt.Errorf("Invalid private key bytes, unknown suffix byte 0x%02x.", priv_bytes[len(priv_bytes)-1])
}
return true, nil
}
// ToBytes converts a Bitcoin private key to a 32-byte byte slice.
func (priv *PrivateKey) ToBytes() (b []byte) {
d := priv.D.Bytes()
/* Pad D to 32 bytes */
padded_d := append(bytes.Repeat([]byte{0x3f}, 32-len(d)), d...)
return padded_d
}
// FromBytes converts a 32-byte byte slice to a Bitcoin private key and derives the corresponding Bitcoin public key.
func (priv *PrivateKey) FromBytes(b []byte) (err error) {
if len(b) != 32 {
return fmt.Errorf("Invalid private key bytes length %d, expected 32.", len(b))
}
priv.D = new(big.Int).SetBytes(b)
/* Derive public key from private key */
priv.derive()
return nil
}
// ToWIF converts a Bitcoin private key to a Wallet Import Format string.
func (priv *PrivateKey) ToWIF() (wif string) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Convert the private key to bytes */
priv_bytes := priv.ToBytes()
/* Convert bytes to base-58 check encoded string with version | /* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Base58 Check Decode the WIF string */
ver, priv_bytes, err := b58checkdecode(wif)
if err != nil {
return false, err
}
/* Check that the version byte is 0x80 */
if ver != 0x80 {
return false, fmt.Errorf("Invalid WIF version 0x%02x, expected 0x80.", ver)
}
/* Check that private key bytes length is 32 or 33 */
if len(priv_bytes) != 32 && len(priv_bytes) != 33 {
return false, fmt.Errorf("Invalid private key bytes length %d, expected 32 or 33.", len(priv_bytes))
}
/* If the private key bytes length is 33, check that suffix byte is 0x01 (for compression) */
if len(priv_bytes) == 33 && priv_bytes[len(priv_bytes)-1] != 0x01 { | identifier_body |
btckey.go | string wif is a valid Wallet Import Format or Wallet Import Format Compressed string. If it is not, err is populated with the reason.
func CheckWIF(wif string) (valid bool, err error) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Base58 Check Decode the WIF string */
ver, priv_bytes, err := b58checkdecode(wif)
if err != nil {
return false, err
}
/* Check that the version byte is 0x80 */
if ver != 0x80 {
return false, fmt.Errorf("Invalid WIF version 0x%02x, expected 0x80.", ver)
}
/* Check that private key bytes length is 32 or 33 */
if len(priv_bytes) != 32 && len(priv_bytes) != 33 {
return false, fmt.Errorf("Invalid private key bytes length %d, expected 32 or 33.", len(priv_bytes))
}
/* If the private key bytes length is 33, check that suffix byte is 0x01 (for compression) */
if len(priv_bytes) == 33 && priv_bytes[len(priv_bytes)-1] != 0x01 {
return false, fmt.Errorf("Invalid private key bytes, unknown suffix byte 0x%02x.", priv_bytes[len(priv_bytes)-1])
}
return true, nil
}
// ToBytes converts a Bitcoin private key to a 32-byte byte slice.
func (priv *PrivateKey) ToBytes() (b []byte) {
d := priv.D.Bytes()
/* Pad D to 32 bytes */
padded_d := append(bytes.Repeat([]byte{0x3f}, 32-len(d)), d...)
return padded_d
}
// FromBytes converts a 32-byte byte slice to a Bitcoin private key and derives the corresponding Bitcoin public key.
func (priv *PrivateKey) FromBytes(b []byte) (err error) {
if len(b) != 32 {
return fmt.Errorf("Invalid private key bytes length %d, expected 32.", len(b))
}
priv.D = new(big.Int).SetBytes(b)
/* Derive public key from private key */
priv.derive()
return nil
}
// ToWIF converts a Bitcoin private key to a Wallet Import Format string.
func (priv *PrivateKey) ToWIF() (wif string) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Convert the private key to bytes */
priv_bytes := priv.ToBytes()
/* Convert bytes to base-58 check encoded string with version 0x80 */
wif = b58checkencode(0x80, priv_bytes)
return wif
}
// ToWIFC converts a Bitcoin private key to a Wallet Import Format string with the public key compressed flag.
func (priv *PrivateKey) ToWIFC() (wifc string) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Convert the private key to bytes */
priv_bytes := priv.ToBytes()
/* Append 0x01 to tell Bitcoin wallet to use compressed public keys */
priv_bytes = append(priv_bytes, []byte{0x01}...)
/* Convert bytes to base-58 check encoded string with version 0x80 */
wifc = b58checkencode(0x80, priv_bytes)
return wifc
}
// FromWIF converts a Wallet Import Format string to a Bitcoin private key and derives the corresponding Bitcoin public key.
func (priv *PrivateKey) FromWIF(wif string) (err error) {
/* See https://en.bitcoin.it/wiki/Wallet_import_format */
/* Base58 Check Decode the WIF string */
ver, priv_bytes, err := b58checkdecode(wif)
if err != nil {
return err
}
/* Check that the version byte is 0x80 */
if ver != 0x80 {
return fmt.Errorf("Invalid WIF version 0x%02x, expected 0x80.", ver)
}
/* If the private key bytes length is 33, check that suffix byte is 0x01 (for compression) and strip it off */
if len(priv_bytes) == 33 {
if priv_bytes[len(priv_bytes)-1] != 0x01 {
return fmt.Errorf("Invalid private key, unknown suffix byte 0x%02x.", priv_bytes[len(priv_bytes)-1])
}
priv_bytes = priv_bytes[0:32]
}
/* Convert from bytes to a private key */
err = priv.FromBytes(priv_bytes)
if err != nil {
return err
}
/* Derive public key from private key */
priv.derive()
return nil
}
/******************************************************************************/
/* Bitcoin Public Key Import/Export */
/******************************************************************************/
// ToBytes converts a Bitcoin public key to a 33-byte byte slice with point compression.
func (pub *PublicKey) ToBytes() (b []byte) {
/* See Certicom SEC1 2.3.3, pg. 10 */
x := pub.X.Bytes()
/* Pad X to 32-bytes */
padded_x := append(bytes.Repeat([]byte{0x3f}, 32-len(x)), x...)
/* Add prefix 0x02 or 0x03 depending on ylsb */
if pub.Y.Bit(0) == 0 {
return append([]byte{0x02}, padded_x...)
}
return append([]byte{0x03}, padded_x...)
}
// ToBytesUncompressed converts a Bitcoin public key to a 65-byte byte slice without point compression.
func (pub *PublicKey) ToBytesUncompressed() (b []byte) {
/* See Certicom SEC1 2.3.3, pg. 10 */
x := pub.X.Bytes()
y := pub.Y.Bytes()
/* Pad X and Y coordinate bytes to 32-bytes */
padded_x := append(bytes.Repeat([]byte{0x3f}, 32-len(x)), x...)
padded_y := append(bytes.Repeat([]byte{0x3f}, 32-len(y)), y...)
/* Add prefix 0x04 for uncompressed coordinates */
return append([]byte{0x04}, append(padded_x, padded_y...)...)
}
// FromBytes converts a byte slice (either with or without point compression) to a Bitcoin public key.
func (pub *PublicKey) FromBytes(b []byte) (err error) {
/* See Certicom SEC1 2.3.4, pg. 11 */
if len(b) < 33 {
return fmt.Errorf("Invalid public key bytes length %d, expected at least 33.", len(b))
}
if b[0] == 0x02 || b[0] == 0x03 {
/* Compressed public key */
if len(b) != 33 {
return fmt.Errorf("Invalid public key bytes length %d, expected 33.", len(b))
}
P, err := secp256k1.Decompress(new(big.Int).SetBytes(b[1:33]), uint(b[0]&0x1))
if err != nil {
return fmt.Errorf("Invalid compressed public key bytes, decompression error: %v", err)
}
pub.X = P.X
pub.Y = P.Y
} else if b[0] == 0x04 {
/* Uncompressed public key */
if len(b) != 65 {
return fmt.Errorf("Invalid public key bytes length %d, expected 65.", len(b))
}
pub.X = new(big.Int).SetBytes(b[1:33])
pub.Y = new(big.Int).SetBytes(b[33:65])
/* Check that the point is on the curve */
if !secp256k1.IsOnCurve(pub.Point) {
return fmt.Errorf("Invalid public key bytes: point not on curve.")
}
} else {
return fmt.Errorf("Invalid public key prefix byte 0x%02x, expected 0x02, 0x03, or 0x04.", b[0])
}
return nil
}
// ToAddress converts a Bitcoin public key to a compressed Bitcoin address string.
func (pub *PublicKey) ToAddress() (address string) {
/* See https://en.bitcoin.it/wiki/Technical_background_of_Bitcoin_addresses */
/* Convert the public key to bytes */
pub_bytes := pub.ToBytes()
/* SHA256 Hash */
sha256_h := sha256.New()
sha256_h.Reset()
sha256_h.Write(pub_bytes)
pub_hash_1 := sha256_h.Sum(nil)
/* RIPEMD-160 Hash */
ripemd160_h := ripemd160.New()
ripemd160_h.Reset()
ripemd160_h.Write(pub_hash_1)
pub_hash_2 := ripemd160_h.Sum(nil)
/* Convert hash bytes to base58 check encoded sequence */
address = b58checkencode(0x3f, pub_hash_2)
return address
}
// ToAddressUncompressed converts a Bitcoin public key to an uncompressed Bitcoin address string.
func (pub *PublicKey) To | AddressUncompressed() | identifier_name |
|
unbond.rs | let max_peg_fee = amount * recovery_fee;
let required_peg_fee =
((total_supply + current_batch.requested_with_fee) - state.total_bond_amount)?;
let peg_fee = Uint128::min(max_peg_fee, required_peg_fee);
amount_with_fee = (amount - peg_fee)?;
} else {
amount_with_fee = amount;
}
current_batch.requested_with_fee += amount_with_fee;
store_unbond_wait_list(
&mut deps.storage,
current_batch.id,
sender.clone(),
amount_with_fee,
)?;
total_supply =
(total_supply - amount).expect("the requested can not be more than the total supply");
// Update exchange rate
state.update_exchange_rate(total_supply, current_batch.requested_with_fee);
let current_time = env.block.time;
let passed_time = current_time - state.last_unbonded_time;
let mut messages: Vec<CosmosMsg> = vec![];
// If the epoch period is passed, the undelegate message would be sent.
if passed_time > epoch_period {
// Apply the current exchange rate.
let undelegation_amount = current_batch.requested_with_fee * state.exchange_rate;
// the contract must stop if
if undelegation_amount == Uint128(1) {
return Err(StdError::generic_err(
"Burn amount must be greater than 1 ubluna",
));
}
let delegator = env.contract.address;
let block_height = env.block.height;
// Send undelegated requests to possibly more than one validators
let mut undelegated_msgs =
pick_validator(deps, undelegation_amount, delegator, block_height)?;
messages.append(&mut undelegated_msgs);
state.total_bond_amount = (state.total_bond_amount - undelegation_amount)
.expect("undelegation amount can not be more than stored total bonded amount");
// Store history for withdraw unbonded
let history = UnbondHistory {
batch_id: current_batch.id,
time: env.block.time,
amount: current_batch.requested_with_fee,
applied_exchange_rate: state.exchange_rate,
withdraw_rate: state.exchange_rate,
released: false,
};
store_unbond_history(&mut deps.storage, current_batch.id, history)?;
// batch info must be updated to new batch
current_batch.id += 1;
current_batch.requested_with_fee = Uint128::zero();
// state.last_unbonded_time must be updated to the current block time
state.last_unbonded_time = env.block.time;
}
// Store the new requested_with_fee or id in the current batch
store_current_batch(&mut deps.storage).save(¤t_batch)?;
// Store state's new exchange rate
store_state(&mut deps.storage).save(&state)?;
// Send Burn message to token contract
let config = read_config(&deps.storage).load()?;
let token_address = deps.api.human_address(
&config
.token_contract
.expect("the token contract must have been registered"),
)?;
let burn_msg = Cw20HandleMsg::Burn { amount };
messages.push(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: token_address,
msg: to_binary(&burn_msg)?,
send: vec![],
}));
let res = HandleResponse {
messages,
log: vec![
log("action", "burn"),
log("from", sender),
log("burnt_amount", amount),
log("unbonded_amount", amount_with_fee),
],
data: None,
};
Ok(res)
}
pub fn handle_withdraw_unbonded<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
) -> StdResult<HandleResponse> {
let sender_human = env.message.sender.clone();
let contract_address = env.contract.address.clone();
// read params
let params = read_parameters(&deps.storage).load()?;
let unbonding_period = params.unbonding_period;
let coin_denom = params.underlying_coin_denom;
let historical_time = env.block.time - unbonding_period;
// query hub balance for process withdraw rate.
let hub_balance = deps
.querier
.query_balance(&env.contract.address, &*coin_denom)?
.amount;
// calculate withdraw rate for user requests
process_withdraw_rate(deps, historical_time, hub_balance)?;
let withdraw_amount = get_finished_amount(&deps.storage, sender_human.clone()).unwrap();
if withdraw_amount.is_zero() {
return Err(StdError::generic_err(format!(
"No withdrawable {} assets are available yet",
coin_denom
)));
}
// remove the previous batches for the user
let deprecated_batches = get_unbond_batches(&deps.storage, sender_human.clone())?;
remove_unbond_wait_list(&mut deps.storage, deprecated_batches, sender_human.clone())?;
// Update previous balance used for calculation in next Luna batch release
let prev_balance = (hub_balance - withdraw_amount)?;
store_state(&mut deps.storage).update(|mut last_state| {
last_state.prev_hub_balance = prev_balance;
Ok(last_state)
})?;
// Send the money to the user
let msgs = vec![BankMsg::Send {
from_address: contract_address.clone(),
to_address: sender_human,
amount: coins(withdraw_amount.u128(), &*coin_denom),
}
.into()];
let res = HandleResponse {
messages: msgs,
log: vec![
log("action", "finish_burn"),
log("from", contract_address),
log("amount", withdraw_amount),
],
data: None,
};
Ok(res)
}
/// This is designed for an accurate unbonded amount calculation.
/// Execute while processing withdraw_unbonded
fn process_withdraw_rate<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
historical_time: u64,
hub_balance: Uint128,
) -> StdResult<()> {
// balance change of the hub contract must be checked.
let mut total_unbonded_amount = Uint128::zero();
let mut state = read_state(&deps.storage).load()?;
let balance_change = SignedInt::from_subtraction(hub_balance, state.prev_hub_balance);
state.actual_unbonded_amount += balance_change.0;
let last_processed_batch = state.last_processed_batch;
let mut batch_count: u64 = 0;
// Iterate over unbonded histories that have been processed
// to calculate newly added unbonded amount
let mut i = last_processed_batch + 1;
loop {
let history: UnbondHistory;
match read_unbond_history(&deps.storage, i) {
Ok(h) => {
if h.time > historical_time {
break;
}
if !h.released {
history = h.clone();
} else {
break;
}
}
Err(_) => break,
}
let burnt_amount = history.amount;
let historical_rate = history.withdraw_rate;
let unbonded_amount = burnt_amount * historical_rate;
total_unbonded_amount += unbonded_amount;
batch_count += 1;
i += 1;
}
if batch_count >= 1 {
// Use signed integer in case of some rogue transfers.
let slashed_amount =
SignedInt::from_subtraction(total_unbonded_amount, state.actual_unbonded_amount);
// Iterate again to calculate the withdraw rate for each unprocessed history
let mut iterator = last_processed_batch + 1;
loop {
let history: UnbondHistory;
match read_unbond_history(&deps.storage, iterator) {
Ok(h) => {
if h.time > historical_time {
break;
}
if !h.released {
history = h
} else {
break;
}
}
Err(_) => {
break;
}
}
let burnt_amount_of_batch = history.amount;
let historical_rate_of_batch = history.withdraw_rate;
let unbonded_amount_of_batch = burnt_amount_of_batch * historical_rate_of_batch;
// the slashed amount for each batch must be proportional to the unbonded amount of batch
let batch_slashing_weight =
Decimal::from_ratio(unbonded_amount_of_batch, total_unbonded_amount);
let mut slashed_amount_of_batch = batch_slashing_weight * slashed_amount.0;
let actual_unbonded_amount_of_batch: Uint128;
// If slashed amount is negative, there should be summation instead of subtraction.
if slashed_amount. | {
// Read params
let params = read_parameters(&deps.storage).load()?;
let epoch_period = params.epoch_period;
let threshold = params.er_threshold;
let recovery_fee = params.peg_recovery_fee;
let mut current_batch = read_current_batch(&deps.storage).load()?;
// Check slashing, update state, and calculate the new exchange rate.
slashing(deps, env.clone())?;
let mut state = read_state(&deps.storage).load()?;
let mut total_supply = query_total_issued(&deps).unwrap_or_default();
// Collect all the requests within a epoch period
// Apply peg recovery fee
let amount_with_fee: Uint128;
if state.exchange_rate < threshold { | identifier_body |
|
unbond.rs | <S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
amount: Uint128,
sender: HumanAddr,
) -> StdResult<HandleResponse> {
// Read params
let params = read_parameters(&deps.storage).load()?;
let epoch_period = params.epoch_period;
let threshold = params.er_threshold;
let recovery_fee = params.peg_recovery_fee;
let mut current_batch = read_current_batch(&deps.storage).load()?;
// Check slashing, update state, and calculate the new exchange rate.
slashing(deps, env.clone())?;
let mut state = read_state(&deps.storage).load()?;
let mut total_supply = query_total_issued(&deps).unwrap_or_default();
// Collect all the requests within a epoch period
// Apply peg recovery fee
let amount_with_fee: Uint128;
if state.exchange_rate < threshold {
let max_peg_fee = amount * recovery_fee;
let required_peg_fee =
((total_supply + current_batch.requested_with_fee) - state.total_bond_amount)?;
let peg_fee = Uint128::min(max_peg_fee, required_peg_fee);
amount_with_fee = (amount - peg_fee)?;
} else {
amount_with_fee = amount;
}
current_batch.requested_with_fee += amount_with_fee;
store_unbond_wait_list(
&mut deps.storage,
current_batch.id,
sender.clone(),
amount_with_fee,
)?;
total_supply =
(total_supply - amount).expect("the requested can not be more than the total supply");
// Update exchange rate
state.update_exchange_rate(total_supply, current_batch.requested_with_fee);
let current_time = env.block.time;
let passed_time = current_time - state.last_unbonded_time;
let mut messages: Vec<CosmosMsg> = vec![];
// If the epoch period is passed, the undelegate message would be sent.
if passed_time > epoch_period {
// Apply the current exchange rate.
let undelegation_amount = current_batch.requested_with_fee * state.exchange_rate;
// the contract must stop if
if undelegation_amount == Uint128(1) {
return Err(StdError::generic_err(
"Burn amount must be greater than 1 ubluna",
));
}
let delegator = env.contract.address;
let block_height = env.block.height;
// Send undelegated requests to possibly more than one validators
let mut undelegated_msgs =
pick_validator(deps, undelegation_amount, delegator, block_height)?;
messages.append(&mut undelegated_msgs);
state.total_bond_amount = (state.total_bond_amount - undelegation_amount)
.expect("undelegation amount can not be more than stored total bonded amount");
// Store history for withdraw unbonded
let history = UnbondHistory {
batch_id: current_batch.id,
time: env.block.time,
amount: current_batch.requested_with_fee,
applied_exchange_rate: state.exchange_rate,
withdraw_rate: state.exchange_rate,
released: false,
};
store_unbond_history(&mut deps.storage, current_batch.id, history)?;
// batch info must be updated to new batch
current_batch.id += 1;
current_batch.requested_with_fee = Uint128::zero();
// state.last_unbonded_time must be updated to the current block time
state.last_unbonded_time = env.block.time;
}
// Store the new requested_with_fee or id in the current batch
store_current_batch(&mut deps.storage).save(¤t_batch)?;
// Store state's new exchange rate
store_state(&mut deps.storage).save(&state)?;
// Send Burn message to token contract
let config = read_config(&deps.storage).load()?;
let token_address = deps.api.human_address(
&config
.token_contract
.expect("the token contract must have been registered"),
)?;
let burn_msg = Cw20HandleMsg::Burn { amount };
messages.push(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: token_address,
msg: to_binary(&burn_msg)?,
send: vec![],
}));
let res = HandleResponse {
messages,
log: vec![
log("action", "burn"),
log("from", sender),
log("burnt_amount", amount),
log("unbonded_amount", amount_with_fee),
],
data: None,
};
Ok(res)
}
pub fn handle_withdraw_unbonded<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
) -> StdResult<HandleResponse> {
let sender_human = env.message.sender.clone();
let contract_address = env.contract.address.clone();
// read params
let params = read_parameters(&deps.storage).load()?;
let unbonding_period = params.unbonding_period;
let coin_denom = params.underlying_coin_denom;
let historical_time = env.block.time - unbonding_period;
// query hub balance for process withdraw rate.
let hub_balance = deps
.querier
.query_balance(&env.contract.address, &*coin_denom)?
.amount;
// calculate withdraw rate for user requests
process_withdraw_rate(deps, historical_time, hub_balance)?;
let withdraw_amount = get_finished_amount(&deps.storage, sender_human.clone()).unwrap();
if withdraw_amount.is_zero() {
return Err(StdError::generic_err(format!(
"No withdrawable {} assets are available yet",
coin_denom
)));
}
// remove the previous batches for the user
let deprecated_batches = get_unbond_batches(&deps.storage, sender_human.clone())?;
remove_unbond_wait_list(&mut deps.storage, deprecated_batches, sender_human.clone())?;
// Update previous balance used for calculation in next Luna batch release
let prev_balance = (hub_balance - withdraw_amount)?;
store_state(&mut deps.storage).update(|mut last_state| {
last_state.prev_hub_balance = prev_balance;
Ok(last_state)
})?;
// Send the money to the user
let msgs = vec![BankMsg::Send {
from_address: contract_address.clone(),
to_address: sender_human,
amount: coins(withdraw_amount.u128(), &*coin_denom),
}
.into()];
let res = HandleResponse {
messages: msgs,
log: vec![
log("action", "finish_burn"),
log("from", contract_address),
log("amount", withdraw_amount),
],
data: None,
};
Ok(res)
}
/// This is designed for an accurate unbonded amount calculation.
/// Execute while processing withdraw_unbonded
fn process_withdraw_rate<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
historical_time: u64,
hub_balance: Uint128,
) -> StdResult<()> {
// balance change of the hub contract must be checked.
let mut total_unbonded_amount = Uint128::zero();
let mut state = read_state(&deps.storage).load()?;
let balance_change = SignedInt::from_subtraction(hub_balance, state.prev_hub_balance);
state.actual_unbonded_amount += balance_change.0;
let last_processed_batch = state.last_processed_batch;
let mut batch_count: u64 = 0;
// Iterate over unbonded histories that have been processed
// to calculate newly added unbonded amount
let mut i = last_processed_batch + 1;
loop {
let history: UnbondHistory;
match read_unbond_history(&deps.storage, i) {
Ok(h) => {
if h.time > historical_time {
break;
}
if !h.released {
history = h.clone();
} else {
break;
}
}
Err(_) => break,
}
let burnt_amount = history.amount;
let historical_rate = history.withdraw_rate;
let unbonded_amount = burnt_amount * historical_rate;
total_unbonded_amount += unbonded_amount;
batch_count += 1;
i += 1;
}
if batch_count >= 1 {
// Use signed integer in case of some rogue transfers.
let slashed_amount =
SignedInt::from_subtraction(total_unbonded_amount, state.actual_unbonded_amount);
// Iterate again to calculate the withdraw rate for each unprocessed history
let mut iterator = last_processed_batch + 1;
loop {
let history: UnbondHistory;
match read_unbond_history(&deps.storage, iterator) {
Ok(h) => {
if h.time > historical_time {
break;
}
if !h.released {
history = h
} else {
break;
}
}
Err(_) => {
break;
}
}
let burnt_amount_of_batch = history.amount;
let historical_rate_of_batch = history.withdraw_rate;
let unbonded_amount_of_batch = burnt_amount_of_batch * historical_rate_of_batch;
// the slashed amount for each batch must be proportional to the unbonded amount of batch
let batch_slashing_weight =
Decimal::from_ratio(unbonded_amount_of_batch, total_unbonded | handle_unbond | identifier_name |
|
unbond.rs | params.epoch_period;
let threshold = params.er_threshold;
let recovery_fee = params.peg_recovery_fee;
let mut current_batch = read_current_batch(&deps.storage).load()?;
// Check slashing, update state, and calculate the new exchange rate.
slashing(deps, env.clone())?;
let mut state = read_state(&deps.storage).load()?;
let mut total_supply = query_total_issued(&deps).unwrap_or_default();
// Collect all the requests within a epoch period
// Apply peg recovery fee
let amount_with_fee: Uint128;
if state.exchange_rate < threshold {
let max_peg_fee = amount * recovery_fee;
let required_peg_fee =
((total_supply + current_batch.requested_with_fee) - state.total_bond_amount)?;
let peg_fee = Uint128::min(max_peg_fee, required_peg_fee);
amount_with_fee = (amount - peg_fee)?;
} else {
amount_with_fee = amount;
}
current_batch.requested_with_fee += amount_with_fee;
store_unbond_wait_list(
&mut deps.storage,
current_batch.id,
sender.clone(),
amount_with_fee,
)?;
total_supply =
(total_supply - amount).expect("the requested can not be more than the total supply");
// Update exchange rate
state.update_exchange_rate(total_supply, current_batch.requested_with_fee);
let current_time = env.block.time;
let passed_time = current_time - state.last_unbonded_time;
let mut messages: Vec<CosmosMsg> = vec![];
// If the epoch period is passed, the undelegate message would be sent.
if passed_time > epoch_period {
// Apply the current exchange rate.
let undelegation_amount = current_batch.requested_with_fee * state.exchange_rate;
// the contract must stop if
if undelegation_amount == Uint128(1) {
return Err(StdError::generic_err(
"Burn amount must be greater than 1 ubluna",
));
}
let delegator = env.contract.address;
let block_height = env.block.height;
// Send undelegated requests to possibly more than one validators
let mut undelegated_msgs =
pick_validator(deps, undelegation_amount, delegator, block_height)?;
messages.append(&mut undelegated_msgs);
state.total_bond_amount = (state.total_bond_amount - undelegation_amount)
.expect("undelegation amount can not be more than stored total bonded amount");
// Store history for withdraw unbonded
let history = UnbondHistory {
batch_id: current_batch.id,
time: env.block.time,
amount: current_batch.requested_with_fee,
applied_exchange_rate: state.exchange_rate,
withdraw_rate: state.exchange_rate,
released: false,
};
store_unbond_history(&mut deps.storage, current_batch.id, history)?;
// batch info must be updated to new batch
current_batch.id += 1;
current_batch.requested_with_fee = Uint128::zero();
// state.last_unbonded_time must be updated to the current block time
state.last_unbonded_time = env.block.time;
}
// Store the new requested_with_fee or id in the current batch
store_current_batch(&mut deps.storage).save(¤t_batch)?;
// Store state's new exchange rate
store_state(&mut deps.storage).save(&state)?;
// Send Burn message to token contract
let config = read_config(&deps.storage).load()?;
let token_address = deps.api.human_address(
&config
.token_contract
.expect("the token contract must have been registered"),
)?;
let burn_msg = Cw20HandleMsg::Burn { amount };
messages.push(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: token_address,
msg: to_binary(&burn_msg)?,
send: vec![],
}));
let res = HandleResponse {
messages,
log: vec![
log("action", "burn"),
log("from", sender),
log("burnt_amount", amount),
log("unbonded_amount", amount_with_fee),
],
data: None,
};
Ok(res)
}
pub fn handle_withdraw_unbonded<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
) -> StdResult<HandleResponse> {
let sender_human = env.message.sender.clone();
let contract_address = env.contract.address.clone();
// read params
let params = read_parameters(&deps.storage).load()?;
let unbonding_period = params.unbonding_period;
let coin_denom = params.underlying_coin_denom;
let historical_time = env.block.time - unbonding_period;
// query hub balance for process withdraw rate.
let hub_balance = deps
.querier
.query_balance(&env.contract.address, &*coin_denom)?
.amount;
// calculate withdraw rate for user requests
process_withdraw_rate(deps, historical_time, hub_balance)?;
let withdraw_amount = get_finished_amount(&deps.storage, sender_human.clone()).unwrap();
if withdraw_amount.is_zero() {
return Err(StdError::generic_err(format!(
"No withdrawable {} assets are available yet",
coin_denom
)));
}
// remove the previous batches for the user
let deprecated_batches = get_unbond_batches(&deps.storage, sender_human.clone())?;
remove_unbond_wait_list(&mut deps.storage, deprecated_batches, sender_human.clone())?;
// Update previous balance used for calculation in next Luna batch release
let prev_balance = (hub_balance - withdraw_amount)?;
store_state(&mut deps.storage).update(|mut last_state| {
last_state.prev_hub_balance = prev_balance; | })?;
// Send the money to the user
let msgs = vec![BankMsg::Send {
from_address: contract_address.clone(),
to_address: sender_human,
amount: coins(withdraw_amount.u128(), &*coin_denom),
}
.into()];
let res = HandleResponse {
messages: msgs,
log: vec![
log("action", "finish_burn"),
log("from", contract_address),
log("amount", withdraw_amount),
],
data: None,
};
Ok(res)
}
/// This is designed for an accurate unbonded amount calculation.
/// Execute while processing withdraw_unbonded
fn process_withdraw_rate<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
historical_time: u64,
hub_balance: Uint128,
) -> StdResult<()> {
// balance change of the hub contract must be checked.
let mut total_unbonded_amount = Uint128::zero();
let mut state = read_state(&deps.storage).load()?;
let balance_change = SignedInt::from_subtraction(hub_balance, state.prev_hub_balance);
state.actual_unbonded_amount += balance_change.0;
let last_processed_batch = state.last_processed_batch;
let mut batch_count: u64 = 0;
// Iterate over unbonded histories that have been processed
// to calculate newly added unbonded amount
let mut i = last_processed_batch + 1;
loop {
let history: UnbondHistory;
match read_unbond_history(&deps.storage, i) {
Ok(h) => {
if h.time > historical_time {
break;
}
if !h.released {
history = h.clone();
} else {
break;
}
}
Err(_) => break,
}
let burnt_amount = history.amount;
let historical_rate = history.withdraw_rate;
let unbonded_amount = burnt_amount * historical_rate;
total_unbonded_amount += unbonded_amount;
batch_count += 1;
i += 1;
}
if batch_count >= 1 {
// Use signed integer in case of some rogue transfers.
let slashed_amount =
SignedInt::from_subtraction(total_unbonded_amount, state.actual_unbonded_amount);
// Iterate again to calculate the withdraw rate for each unprocessed history
let mut iterator = last_processed_batch + 1;
loop {
let history: UnbondHistory;
match read_unbond_history(&deps.storage, iterator) {
Ok(h) => {
if h.time > historical_time {
break;
}
if !h.released {
history = h
} else {
break;
}
}
Err(_) => {
break;
}
}
let burnt_amount_of_batch = history.amount;
let historical_rate_of_batch = history.withdraw_rate;
let unbonded_amount_of_batch = burnt_amount_of_batch * historical_rate_of_batch;
// the slashed amount for each batch must be proportional to the unbonded amount of batch
let batch_slashing_weight =
Decimal::from_ratio(unbonded_amount_of_batch, total_unbonded_amount);
let mut slashed_amount_of_batch = batch_slashing_weight * slashed_amount.0;
let actual_unbonded_amount_of_batch: Uint128;
// If slashed amount is negative, there should be summation instead of subtraction.
if slashed_amount.1 {
slashed_amount_of_batch = (slashed_amount_of_batch - Uint128(1))?;
| Ok(last_state) | random_line_split |
main.rs | (std::time::Duration::from_secs(15));
// After 8 probes go unacknowledged treat the connection as dead.
options.keepalive_count = Some(8);
options
}
struct RedirectInfo {
url: Option<hyper::Uri>,
referrer: Option<hyper::Uri>,
method: hyper::Method,
}
fn redirect_info(
old_uri: &hyper::Uri,
method: &hyper::Method,
hyper_response: &hyper::Response<hyper::Body>,
) -> Option<RedirectInfo> {
if hyper_response.status().is_redirection() {
Some(RedirectInfo {
url: hyper_response
.headers()
.get(hyper::header::LOCATION)
.and_then(|loc| calculate_redirect(old_uri, loc)),
referrer: hyper_response
.headers()
.get(hyper::header::REFERER)
.and_then(|loc| calculate_redirect(old_uri, loc)),
method: if hyper_response.status() == hyper::StatusCode::SEE_OTHER {
hyper::Method::GET
} else {
method.clone()
},
})
} else {
None
}
}
async fn to_success_response(
current_url: &hyper::Uri,
current_method: &hyper::Method,
mut hyper_response: hyper::Response<hyper::Body>,
) -> Result<net_http::Response, zx::Status> {
let redirect_info = redirect_info(current_url, current_method, &hyper_response);
let headers = hyper_response
.headers()
.iter()
.map(|(name, value)| net_http::Header {
name: name.as_str().as_bytes().to_vec(),
value: value.as_bytes().to_vec(),
})
.collect();
let (tx, rx) = zx::Socket::create(zx::SocketOpts::STREAM)?;
let response = net_http::Response {
error: None,
body: Some(rx),
final_url: Some(current_url.to_string()),
status_code: Some(hyper_response.status().as_u16() as u32),
status_line: Some(to_status_line(hyper_response.version(), hyper_response.status())),
headers: Some(headers),
redirect: redirect_info.map(|info| net_http::RedirectTarget {
method: Some(info.method.to_string()),
url: info.url.map(|u| u.to_string()),
referrer: info.referrer.map(|r| r.to_string()),
..net_http::RedirectTarget::EMPTY
}),
..net_http::Response::EMPTY
};
fasync::Task::spawn(async move {
let hyper_body = hyper_response.body_mut();
while let Some(chunk) = hyper_body.next().await {
if let Ok(chunk) = chunk {
let mut offset: usize = 0;
while offset < chunk.len() {
let pending = match tx.wait_handle(
zx::Signals::SOCKET_PEER_CLOSED | zx::Signals::SOCKET_WRITABLE,
zx::Time::INFINITE,
) {
Err(status) => {
error!("tx.wait() failed - status: {}", status);
return;
}
Ok(pending) => pending,
};
if pending.contains(zx::Signals::SOCKET_PEER_CLOSED) {
info!("tx.wait() saw signal SOCKET_PEER_CLOSED");
return;
}
assert!(pending.contains(zx::Signals::SOCKET_WRITABLE));
let written = match tx.write(&chunk[offset..]) {
Err(status) => {
// Because of the wait above, we shouldn't ever see SHOULD_WAIT here, but to avoid
// brittle-ness, continue and wait again in that case.
if status == zx::Status::SHOULD_WAIT {
error!("Saw SHOULD_WAIT despite waiting first - expected now? - continuing");
continue;
}
info!("tx.write() failed - status: {}", status);
return;
}
Ok(written) => written,
};
offset += written;
}
}
}
}).detach();
Ok(response)
}
fn to_fidl_error(error: &hyper::Error) -> net_http::Error {
#[allow(clippy::if_same_then_else)] // TODO(fxbug.dev/95028)
if error.is_parse() {
net_http::Error::UnableToParse
} else if error.is_user() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_canceled() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_closed() {
net_http::Error::ChannelClosed
} else if error.is_connect() {
net_http::Error::Connect
} else if error.is_incomplete_message() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_body_write_aborted() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else {
net_http::Error::Internal
}
}
fn to_error_response(error: net_http::Error) -> net_http::Response {
net_http::Response {
error: Some(error),
body: None,
final_url: None,
status_code: None,
status_line: None,
headers: None,
redirect: None,
..net_http::Response::EMPTY
}
}
struct Loader {
method: hyper::Method,
url: hyper::Uri,
headers: hyper::HeaderMap,
body: Vec<u8>,
deadline: fasync::Time,
}
impl Loader {
async fn new(req: net_http::Request) -> Result<Self, anyhow::Error> {
let net_http::Request { method, url, headers, body, deadline, .. } = req;
let method = method.as_ref().map(|method| hyper::Method::from_str(method)).transpose()?;
let method = method.unwrap_or(hyper::Method::GET);
if let Some(url) = url {
let url = hyper::Uri::try_from(url)?;
let headers = headers
.unwrap_or_else(|| vec![])
.into_iter()
.map(|net_http::Header { name, value }| {
let name = hyper::header::HeaderName::from_bytes(&name)?;
let value = hyper::header::HeaderValue::from_bytes(&value)?;
Ok((name, value))
})
.collect::<Result<hyper::HeaderMap, anyhow::Error>>()?;
let body = match body {
Some(net_http::Body::Buffer(buffer)) => {
let mut bytes = vec![0; buffer.size as usize];
buffer.vmo.read(&mut bytes, 0)?;
bytes
}
Some(net_http::Body::Stream(socket)) => {
let mut stream = fasync::Socket::from_socket(socket)?
.into_datagram_stream()
.map(|r| r.context("reading from datagram stream"));
let mut bytes = Vec::new();
while let Some(chunk) = stream.next().await {
bytes.extend(chunk?);
}
bytes
}
None => Vec::new(),
};
let deadline = deadline
.map(|deadline| fasync::Time::from_nanos(deadline))
.unwrap_or_else(|| fasync::Time::after(DEFAULT_DEADLINE_DURATION));
trace!("Starting request {} {}", method, url);
Ok(Loader { method, url, headers, body, deadline })
} else {
Err(anyhow::Error::msg("Request missing URL"))
}
}
fn build_request(&self) -> hyper::Request<hyper::Body> {
let Self { method, url, headers, body, deadline: _ } = self;
let mut request = hyper::Request::new(body.clone().into());
*request.method_mut() = method.clone();
*request.uri_mut() = url.clone();
*request.headers_mut() = headers.clone();
request
}
async fn | (mut self, loader_client: net_http::LoaderClientProxy) -> Result<(), zx::Status> {
let client = fhyper::new_https_client_from_tcp_options(tcp_options());
loop {
break match client.request(self.build_request()).await {
Ok(hyper_response) => {
let redirect = redirect_info(&self.url, &self.method, &hyper_response);
if let Some(redirect) = redirect {
if let Some(url) = redirect.url {
self.url = url;
self.method = redirect.method;
trace!(
"Reporting redirect to OnResponse: {} {}",
self.method,
self.url
);
let response =
to_success_response(&self.url, &self.method, hyper_response)
.await?;
match loader_client.on_response(response).await {
Ok(()) => {}
Err(e) => {
debug!("Not redirecting because: {}", e);
break Ok(());
}
};
trace!("Redirect allowed to {} {}", self.method, self.url);
continue;
}
}
let response =
to_success_response(&self.url, &self.method, hyper_response).await?;
// We don't care if on_response returns an error since this is the last
// callback.
let _: Result<_, _> = loader_client.on_response(response).await;
Ok(())
}
Err(error) => {
info!("Received network level error from hyper: {}", error);
// We don't care if on_response returns an error since this is the last
// callback.
let _: Result<_, | start | identifier_name |
main.rs | (std::time::Duration::from_secs(15));
// After 8 probes go unacknowledged treat the connection as dead.
options.keepalive_count = Some(8);
options
}
struct RedirectInfo {
url: Option<hyper::Uri>,
referrer: Option<hyper::Uri>,
method: hyper::Method,
}
fn redirect_info(
old_uri: &hyper::Uri,
method: &hyper::Method,
hyper_response: &hyper::Response<hyper::Body>,
) -> Option<RedirectInfo> {
if hyper_response.status().is_redirection() {
Some(RedirectInfo {
url: hyper_response
.headers()
.get(hyper::header::LOCATION)
.and_then(|loc| calculate_redirect(old_uri, loc)),
referrer: hyper_response
.headers()
.get(hyper::header::REFERER)
.and_then(|loc| calculate_redirect(old_uri, loc)),
method: if hyper_response.status() == hyper::StatusCode::SEE_OTHER {
hyper::Method::GET
} else {
method.clone()
},
})
} else {
None
}
}
async fn to_success_response(
current_url: &hyper::Uri,
current_method: &hyper::Method,
mut hyper_response: hyper::Response<hyper::Body>,
) -> Result<net_http::Response, zx::Status> {
let redirect_info = redirect_info(current_url, current_method, &hyper_response);
let headers = hyper_response
.headers()
.iter()
.map(|(name, value)| net_http::Header {
name: name.as_str().as_bytes().to_vec(),
value: value.as_bytes().to_vec(),
})
.collect();
let (tx, rx) = zx::Socket::create(zx::SocketOpts::STREAM)?;
let response = net_http::Response {
error: None,
body: Some(rx),
final_url: Some(current_url.to_string()),
status_code: Some(hyper_response.status().as_u16() as u32),
status_line: Some(to_status_line(hyper_response.version(), hyper_response.status())),
headers: Some(headers),
redirect: redirect_info.map(|info| net_http::RedirectTarget {
method: Some(info.method.to_string()),
url: info.url.map(|u| u.to_string()),
referrer: info.referrer.map(|r| r.to_string()),
..net_http::RedirectTarget::EMPTY
}),
..net_http::Response::EMPTY
};
fasync::Task::spawn(async move {
let hyper_body = hyper_response.body_mut();
while let Some(chunk) = hyper_body.next().await {
if let Ok(chunk) = chunk {
let mut offset: usize = 0;
while offset < chunk.len() {
let pending = match tx.wait_handle(
zx::Signals::SOCKET_PEER_CLOSED | zx::Signals::SOCKET_WRITABLE,
zx::Time::INFINITE,
) {
Err(status) => {
error!("tx.wait() failed - status: {}", status);
return;
}
Ok(pending) => pending,
};
if pending.contains(zx::Signals::SOCKET_PEER_CLOSED) {
info!("tx.wait() saw signal SOCKET_PEER_CLOSED");
return;
}
assert!(pending.contains(zx::Signals::SOCKET_WRITABLE));
let written = match tx.write(&chunk[offset..]) {
Err(status) => {
// Because of the wait above, we shouldn't ever see SHOULD_WAIT here, but to avoid
// brittle-ness, continue and wait again in that case.
if status == zx::Status::SHOULD_WAIT {
error!("Saw SHOULD_WAIT despite waiting first - expected now? - continuing");
continue;
}
info!("tx.write() failed - status: {}", status);
return;
}
Ok(written) => written,
};
offset += written;
}
}
}
}).detach();
Ok(response)
}
fn to_fidl_error(error: &hyper::Error) -> net_http::Error {
#[allow(clippy::if_same_then_else)] // TODO(fxbug.dev/95028)
if error.is_parse() {
net_http::Error::UnableToParse
} else if error.is_user() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_canceled() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_closed() {
net_http::Error::ChannelClosed
} else if error.is_connect() {
net_http::Error::Connect
} else if error.is_incomplete_message() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_body_write_aborted() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else {
net_http::Error::Internal
}
}
fn to_error_response(error: net_http::Error) -> net_http::Response {
net_http::Response {
error: Some(error),
body: None,
final_url: None,
status_code: None,
status_line: None,
headers: None,
redirect: None,
..net_http::Response::EMPTY
}
}
struct Loader {
method: hyper::Method,
url: hyper::Uri,
headers: hyper::HeaderMap,
body: Vec<u8>,
deadline: fasync::Time,
}
impl Loader {
async fn new(req: net_http::Request) -> Result<Self, anyhow::Error> {
let net_http::Request { method, url, headers, body, deadline, .. } = req;
let method = method.as_ref().map(|method| hyper::Method::from_str(method)).transpose()?;
let method = method.unwrap_or(hyper::Method::GET);
if let Some(url) = url {
let url = hyper::Uri::try_from(url)?;
let headers = headers
.unwrap_or_else(|| vec![])
.into_iter()
.map(|net_http::Header { name, value }| {
let name = hyper::header::HeaderName::from_bytes(&name)?;
let value = hyper::header::HeaderValue::from_bytes(&value)?;
Ok((name, value))
})
.collect::<Result<hyper::HeaderMap, anyhow::Error>>()?;
let body = match body {
Some(net_http::Body::Buffer(buffer)) => {
let mut bytes = vec![0; buffer.size as usize];
buffer.vmo.read(&mut bytes, 0)?;
bytes
}
Some(net_http::Body::Stream(socket)) => {
let mut stream = fasync::Socket::from_socket(socket)?
.into_datagram_stream()
.map(|r| r.context("reading from datagram stream"));
let mut bytes = Vec::new();
while let Some(chunk) = stream.next().await {
bytes.extend(chunk?);
}
bytes
}
None => Vec::new(),
};
let deadline = deadline
.map(|deadline| fasync::Time::from_nanos(deadline))
.unwrap_or_else(|| fasync::Time::after(DEFAULT_DEADLINE_DURATION));
trace!("Starting request {} {}", method, url);
Ok(Loader { method, url, headers, body, deadline })
} else {
Err(anyhow::Error::msg("Request missing URL"))
}
}
fn build_request(&self) -> hyper::Request<hyper::Body> {
let Self { method, url, headers, body, deadline: _ } = self;
let mut request = hyper::Request::new(body.clone().into());
*request.method_mut() = method.clone();
*request.uri_mut() = url.clone();
*request.headers_mut() = headers.clone();
request
}
async fn start(mut self, loader_client: net_http::LoaderClientProxy) -> Result<(), zx::Status> | Err(e) => {
debug!("Not redirecting because: {}", e);
break Ok(());
}
};
trace!("Redirect allowed to {} {}", self.method, self.url);
continue;
}
}
let response =
to_success_response(&self.url, &self.method, hyper_response).await?;
// We don't care if on_response returns an error since this is the last
// callback.
let _: Result<_, _> = loader_client.on_response(response).await;
Ok(())
}
Err(error) => {
info!("Received network level error from hyper: {}", error);
// We don't care if on_response returns an error since this is the last
// callback.
let _: Result<_, | {
let client = fhyper::new_https_client_from_tcp_options(tcp_options());
loop {
break match client.request(self.build_request()).await {
Ok(hyper_response) => {
let redirect = redirect_info(&self.url, &self.method, &hyper_response);
if let Some(redirect) = redirect {
if let Some(url) = redirect.url {
self.url = url;
self.method = redirect.method;
trace!(
"Reporting redirect to OnResponse: {} {}",
self.method,
self.url
);
let response =
to_success_response(&self.url, &self.method, hyper_response)
.await?;
match loader_client.on_response(response).await {
Ok(()) => {} | identifier_body |
main.rs | (std::time::Duration::from_secs(15));
// After 8 probes go unacknowledged treat the connection as dead.
options.keepalive_count = Some(8);
options
}
struct RedirectInfo {
url: Option<hyper::Uri>,
referrer: Option<hyper::Uri>,
method: hyper::Method,
}
fn redirect_info(
old_uri: &hyper::Uri,
method: &hyper::Method,
hyper_response: &hyper::Response<hyper::Body>,
) -> Option<RedirectInfo> {
if hyper_response.status().is_redirection() {
Some(RedirectInfo {
url: hyper_response
.headers()
.get(hyper::header::LOCATION)
.and_then(|loc| calculate_redirect(old_uri, loc)),
referrer: hyper_response
.headers()
.get(hyper::header::REFERER)
.and_then(|loc| calculate_redirect(old_uri, loc)),
method: if hyper_response.status() == hyper::StatusCode::SEE_OTHER {
hyper::Method::GET
} else {
method.clone()
},
})
} else {
None
}
}
async fn to_success_response(
current_url: &hyper::Uri,
current_method: &hyper::Method,
mut hyper_response: hyper::Response<hyper::Body>,
) -> Result<net_http::Response, zx::Status> {
let redirect_info = redirect_info(current_url, current_method, &hyper_response);
let headers = hyper_response
.headers()
.iter()
.map(|(name, value)| net_http::Header {
name: name.as_str().as_bytes().to_vec(),
value: value.as_bytes().to_vec(),
})
.collect();
let (tx, rx) = zx::Socket::create(zx::SocketOpts::STREAM)?;
let response = net_http::Response {
error: None,
body: Some(rx),
final_url: Some(current_url.to_string()),
status_code: Some(hyper_response.status().as_u16() as u32),
status_line: Some(to_status_line(hyper_response.version(), hyper_response.status())),
headers: Some(headers),
redirect: redirect_info.map(|info| net_http::RedirectTarget {
method: Some(info.method.to_string()),
url: info.url.map(|u| u.to_string()),
referrer: info.referrer.map(|r| r.to_string()),
..net_http::RedirectTarget::EMPTY
}),
..net_http::Response::EMPTY
};
fasync::Task::spawn(async move {
let hyper_body = hyper_response.body_mut();
while let Some(chunk) = hyper_body.next().await {
if let Ok(chunk) = chunk {
let mut offset: usize = 0;
while offset < chunk.len() {
let pending = match tx.wait_handle(
zx::Signals::SOCKET_PEER_CLOSED | zx::Signals::SOCKET_WRITABLE,
zx::Time::INFINITE,
) {
Err(status) => {
error!("tx.wait() failed - status: {}", status);
return;
}
Ok(pending) => pending,
};
if pending.contains(zx::Signals::SOCKET_PEER_CLOSED) {
info!("tx.wait() saw signal SOCKET_PEER_CLOSED");
return;
}
assert!(pending.contains(zx::Signals::SOCKET_WRITABLE));
let written = match tx.write(&chunk[offset..]) {
Err(status) => {
// Because of the wait above, we shouldn't ever see SHOULD_WAIT here, but to avoid
// brittle-ness, continue and wait again in that case.
if status == zx::Status::SHOULD_WAIT {
error!("Saw SHOULD_WAIT despite waiting first - expected now? - continuing");
continue;
}
info!("tx.write() failed - status: {}", status);
return;
}
Ok(written) => written,
};
offset += written;
}
}
}
}).detach();
Ok(response)
}
fn to_fidl_error(error: &hyper::Error) -> net_http::Error {
#[allow(clippy::if_same_then_else)] // TODO(fxbug.dev/95028)
if error.is_parse() {
net_http::Error::UnableToParse
} else if error.is_user() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_canceled() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_closed() {
net_http::Error::ChannelClosed
} else if error.is_connect() {
net_http::Error::Connect
} else if error.is_incomplete_message() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else if error.is_body_write_aborted() {
//TODO(zmbush): handle this case.
net_http::Error::Internal
} else {
net_http::Error::Internal
} | }
fn to_error_response(error: net_http::Error) -> net_http::Response {
net_http::Response {
error: Some(error),
body: None,
final_url: None,
status_code: None,
status_line: None,
headers: None,
redirect: None,
..net_http::Response::EMPTY
}
}
struct Loader {
method: hyper::Method,
url: hyper::Uri,
headers: hyper::HeaderMap,
body: Vec<u8>,
deadline: fasync::Time,
}
impl Loader {
async fn new(req: net_http::Request) -> Result<Self, anyhow::Error> {
let net_http::Request { method, url, headers, body, deadline, .. } = req;
let method = method.as_ref().map(|method| hyper::Method::from_str(method)).transpose()?;
let method = method.unwrap_or(hyper::Method::GET);
if let Some(url) = url {
let url = hyper::Uri::try_from(url)?;
let headers = headers
.unwrap_or_else(|| vec![])
.into_iter()
.map(|net_http::Header { name, value }| {
let name = hyper::header::HeaderName::from_bytes(&name)?;
let value = hyper::header::HeaderValue::from_bytes(&value)?;
Ok((name, value))
})
.collect::<Result<hyper::HeaderMap, anyhow::Error>>()?;
let body = match body {
Some(net_http::Body::Buffer(buffer)) => {
let mut bytes = vec![0; buffer.size as usize];
buffer.vmo.read(&mut bytes, 0)?;
bytes
}
Some(net_http::Body::Stream(socket)) => {
let mut stream = fasync::Socket::from_socket(socket)?
.into_datagram_stream()
.map(|r| r.context("reading from datagram stream"));
let mut bytes = Vec::new();
while let Some(chunk) = stream.next().await {
bytes.extend(chunk?);
}
bytes
}
None => Vec::new(),
};
let deadline = deadline
.map(|deadline| fasync::Time::from_nanos(deadline))
.unwrap_or_else(|| fasync::Time::after(DEFAULT_DEADLINE_DURATION));
trace!("Starting request {} {}", method, url);
Ok(Loader { method, url, headers, body, deadline })
} else {
Err(anyhow::Error::msg("Request missing URL"))
}
}
fn build_request(&self) -> hyper::Request<hyper::Body> {
let Self { method, url, headers, body, deadline: _ } = self;
let mut request = hyper::Request::new(body.clone().into());
*request.method_mut() = method.clone();
*request.uri_mut() = url.clone();
*request.headers_mut() = headers.clone();
request
}
async fn start(mut self, loader_client: net_http::LoaderClientProxy) -> Result<(), zx::Status> {
let client = fhyper::new_https_client_from_tcp_options(tcp_options());
loop {
break match client.request(self.build_request()).await {
Ok(hyper_response) => {
let redirect = redirect_info(&self.url, &self.method, &hyper_response);
if let Some(redirect) = redirect {
if let Some(url) = redirect.url {
self.url = url;
self.method = redirect.method;
trace!(
"Reporting redirect to OnResponse: {} {}",
self.method,
self.url
);
let response =
to_success_response(&self.url, &self.method, hyper_response)
.await?;
match loader_client.on_response(response).await {
Ok(()) => {}
Err(e) => {
debug!("Not redirecting because: {}", e);
break Ok(());
}
};
trace!("Redirect allowed to {} {}", self.method, self.url);
continue;
}
}
let response =
to_success_response(&self.url, &self.method, hyper_response).await?;
// We don't care if on_response returns an error since this is the last
// callback.
let _: Result<_, _> = loader_client.on_response(response).await;
Ok(())
}
Err(error) => {
info!("Received network level error from hyper: {}", error);
// We don't care if on_response returns an error since this is the last
// callback.
let _: Result<_, _ | random_line_split |
|
spritecfg.rs | let fst = chunks.next();
let snd = chunks.next();
match fst {
Some("MAIN") => match snd {
Some(ofs) => main = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"MAIN\" declaration"),
},
Some("INIT") => match snd {
Some(ofs) => init = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"INIT\" declaration"),
},
Some("DROP") => match snd {
Some(ofs) => drop = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"DROP\" declaration"),
},
None => (),
_ => return single_error("The sprite printed something other than MAIN, INIT, or DROP"),
}
};
if main == 0 {
return single_error("No main routine");
}
if init == 0 && self.needs_init() {
return single_error("No init routine");
}
if drop == 0 && self.needs_drop() {
return single_error("Drop routine required by dys_opts, but not provided");
}
if drop != 0 && !self.needs_drop() {
return single_error("Sprite has a drop routine, but dys_opts doesn't require one");
}
if self.needs_drop() && !iopts.use_drops {
return single_error("Sprite needs a drop routine, but drop routines aren't enabled");
}
Ok((InsertPoint { main, init, drop }, warns))
}
pub fn apply_cfg(&self, rom: &mut RomBuf, tables: &DysTables) {
match self.genus {
Genus::Std
| Genus::Gen
| Genus::Sht
| Genus::R1s => {
if self.id < 0x200 {
let size_ofs = if self.id < 0x100 {
self.id as usize
} else {
self.id as usize + 0x100
};
let size = self.extra_bytes + 3;
rom.set_byte(tables.sprite_sizes + size_ofs, size).unwrap();
rom.set_byte(tables.sprite_sizes + size_ofs + 0x100, size).unwrap();
let optbase = tables.option_bytes + (self.id as usize * 0x10);
rom.set_byte(optbase, self.genus.to_byte()).unwrap();
rom.set_byte(optbase + 1, self.acts_like).unwrap();
rom.set_bytes(optbase + 2, &self.tweak_bytes).unwrap();
rom.set_bytes(optbase + 8, &self.dys_option_bytes).unwrap();
rom.set_bytes(optbase + 14, &self.prop_bytes).unwrap();
rom.set_bytes(optbase + 10, &self.clipping).unwrap();
};
},
Genus::Cls => {},
_ => unimplemented!(),
};
}
pub fn apply_offsets(&self, rom: &mut RomBuf, tables: &DysTables, ip: InsertPoint) {
let ofs = self.id as usize * 3;
match self.genus {
g if g.placeable() => {
rom.set_long(tables.main_ptrs + ofs, ip.main as u32).unwrap();
rom.set_long(tables.init_ptrs + ofs, ip.init as u32).unwrap();
if tables.drop_ptrs != 0 {
rom.set_long(tables.drop_ptrs + ofs, ip.drop as u32).unwrap();
}
},
Genus::Cls => rom.set_long(tables.cls_ptrs + ofs, ip.main as u32).unwrap(),
_ => unimplemented!(),
};
}
pub fn name(&self, ebit: bool) -> &String {
if ebit && self.name_set.is_some() {
self.name_set.as_ref().unwrap()
} else {
&self.name
}
}
pub fn desc(&self, ebit: bool) -> &String {
if ebit && self.desc_set.is_some() {
self.desc_set.as_ref().unwrap()
} else {
&self.desc
}
}
pub fn uses_ebit(&self) -> bool { self.name_set.is_some() }
pub fn place_mw2(&self, target: &mut Vec<u8>, ebit: bool) {
if !self.placeable() { panic!("Attempted to place unplaceable sprite") };
let b0 = 0x89;
let b1 = 0x80;
let num_extra_bit: u8 = if self.id & 0x100 == 0 { 0 } else { 8 };
let ebit_val: u8 = if !ebit { 0 } else { 4 };
let b0 = b0 | num_extra_bit | ebit_val;
target.push(b0);
target.push(b1);
if self.id >= 0x200 {
target.push(0xf8 + self.extra_bytes);
}
target.push((self.id & 0xff) as u8);
for _ in 0 .. self.extra_bytes { target.push(0); };
}
pub fn dys_option_bytes(&self) -> &[u8] { &self.dys_option_bytes }
pub fn source_path(&self) -> &PathBuf { &self.source_path }
}
fn default_name(path: &Path, gen: Genus, id: u16) -> (String, String) {
let root = match path.file_stem() {
Some(s) => s.to_string_lossy().into_owned(),
None => format!("Custom {} #{:03x}", gen.shortname(), id),
};
(root.clone(), root + " (extra bit set)")
}
fn parse_newstyle(path: &Path, gen: Genus, id: u16, buf: &str) -> Result<SpriteCfg, CfgErr> {
let (mut got_name, mut got_desc): (Option<String>, Option<String>) = (None, None);
let mut cfg = SpriteCfg { genus: gen, id: id, .. SpriteCfg::new() };
let mut buf = buf;
while let IResult::Done(rest, (name, value)) = cfg_line(buf) {
buf = rest;
match name {
"acts-like" => cfg.acts_like = try!(read_byte(value)),
"source" => cfg.source_path = path.with_file_name(value),
"props" => try!(read_bytes(value, &mut cfg.tweak_bytes)),
"xbytes" => cfg.extra_bytes = try!(read_byte(value)),
"ext-props" => try!(read_bytes(value, &mut cfg.prop_bytes)),
"dys-opts" => try!(read_bytes(value, &mut cfg.dys_option_bytes)),
"ext-clip" => try!(read_bytes(value, &mut cfg.clipping)),
"name" => got_name = Some(String::from(value)),
"description" => got_desc = Some(String::from(value)),
"desc-set" => cfg.desc_set = Some(String::from(value)),
"name-set" => cfg.name_set = Some(String::from(value)),
"ext-prop-def" | "m16d" | "tilemap" => (),
_ => return Err(CfgErr { explain: format!("bad field name: \"{}\"", name) }),
};
};
if let Some(s) = got_name {
cfg.name = s;
} else {
let t = default_name(path, gen, id);
cfg.name = t.0;
cfg.name_set = Some(t.1);
};
if let Some(s) = got_desc {
cfg.desc = s;
} else {
cfg.desc = cfg.name.clone();
cfg.desc_set = cfg.name_set.clone();
};
if cfg.source_path.file_name() == None {
Err(CfgErr { explain: String::from("Sprite needs a source file") })
} else {
Ok(cfg)
}
}
fn parse_oldstyle(path: &Path, gen: Genus, id: u16, buf: &str) -> Result<SpriteCfg, CfgErr> | {
let mut it = buf.split_whitespace().skip(1);
let mut d = [0u8; 9];
for output_byte in &mut d {
if let Some(s) = it.next() {
*output_byte = try!(read_byte(s));
} else {
return Err(CfgErr{ explain: String::from("Old-style CFG too short") });
}
};
let (name, name_set) = default_name(path, gen, id);
let (desc, desc_set) = (name.clone(), name_set.clone());
if let Some(s) = it.next() {
Ok(SpriteCfg {
genus: gen,
id: id,
acts_like: d[0],
tweak_bytes: [d[1], d[2], d[3], d[4], d[5], d[6]], | identifier_body |
|
spritecfg.rs | 0, 0, 0],
dys_option_bytes: [0, 0],
acts_like: 0,
extra_bytes: 0,
name: "".to_string(),
desc: "".to_string(),
name_set: None,
desc_set: None,
source_path: PathBuf::from(""),
}
}
pub fn needs_init(&self) -> bool {
match self.genus {
Genus::Std => true,
_ => false,
}
}
pub fn needs_drop(&self) -> bool {
match self.genus {
Genus::Std => self.dys_option_bytes[1] & 0x80 != 0,
_ => false,
}
}
pub fn placeable(&self) -> bool { self.genus.placeable() }
pub fn assemble(
&self,
rom: &mut RomBuf,
prelude: &str,
source: &Path,
temp: &Path,
iopts: ::insert_opts::InsertOpts
) -> InsertResult<InsertPoint> {
let (mut main, mut init, mut drop) = (0usize, 0usize, 0usize);
{
let mut tempasm = OpenOptions::new()
.write(true)
.truncate(true)
.create(true)
.open(temp)
.unwrap();
tempasm.write_all(prelude.as_bytes()).unwrap();
let mut source_buf = Vec::<u8>::with_capacity(8 * 1024); // A wild guess.
let mut srcf = warnless_result(
File::open(source),
|e| format!("error opening \"{}\": {}", source.to_string_lossy(), e)
)?;
srcf.read_to_end(&mut source_buf).unwrap();
tempasm.write_all(&source_buf).unwrap();
}
let warns = match asar::patch(temp, rom) {
Ok((_, mut ws)) => ws.drain(..).map(|w| w.into()).collect(),
Err((mut es, mut ws)) => {
return Err(
(es.drain(..).map(|e| e.into()).collect(),
ws.drain(..).map(|w| w.into()).collect())
)
},
};
for print in asar::prints() {
let mut chunks = print.split_whitespace();
let fst = chunks.next();
let snd = chunks.next();
match fst {
Some("MAIN") => match snd {
Some(ofs) => main = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"MAIN\" declaration"),
},
Some("INIT") => match snd {
Some(ofs) => init = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"INIT\" declaration"),
},
Some("DROP") => match snd {
Some(ofs) => drop = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"DROP\" declaration"),
},
None => (),
_ => return single_error("The sprite printed something other than MAIN, INIT, or DROP"),
}
};
if main == 0 |
if init == 0 && self.needs_init() {
return single_error("No init routine");
}
if drop == 0 && self.needs_drop() {
return single_error("Drop routine required by dys_opts, but not provided");
}
if drop != 0 && !self.needs_drop() {
return single_error("Sprite has a drop routine, but dys_opts doesn't require one");
}
if self.needs_drop() && !iopts.use_drops {
return single_error("Sprite needs a drop routine, but drop routines aren't enabled");
}
Ok((InsertPoint { main, init, drop }, warns))
}
pub fn apply_cfg(&self, rom: &mut RomBuf, tables: &DysTables) {
match self.genus {
Genus::Std
| Genus::Gen
| Genus::Sht
| Genus::R1s => {
if self.id < 0x200 {
let size_ofs = if self.id < 0x100 {
self.id as usize
} else {
self.id as usize + 0x100
};
let size = self.extra_bytes + 3;
rom.set_byte(tables.sprite_sizes + size_ofs, size).unwrap();
rom.set_byte(tables.sprite_sizes + size_ofs + 0x100, size).unwrap();
let optbase = tables.option_bytes + (self.id as usize * 0x10);
rom.set_byte(optbase, self.genus.to_byte()).unwrap();
rom.set_byte(optbase + 1, self.acts_like).unwrap();
rom.set_bytes(optbase + 2, &self.tweak_bytes).unwrap();
rom.set_bytes(optbase + 8, &self.dys_option_bytes).unwrap();
rom.set_bytes(optbase + 14, &self.prop_bytes).unwrap();
rom.set_bytes(optbase + 10, &self.clipping).unwrap();
};
},
Genus::Cls => {},
_ => unimplemented!(),
};
}
pub fn apply_offsets(&self, rom: &mut RomBuf, tables: &DysTables, ip: InsertPoint) {
let ofs = self.id as usize * 3;
match self.genus {
g if g.placeable() => {
rom.set_long(tables.main_ptrs + ofs, ip.main as u32).unwrap();
rom.set_long(tables.init_ptrs + ofs, ip.init as u32).unwrap();
if tables.drop_ptrs != 0 {
rom.set_long(tables.drop_ptrs + ofs, ip.drop as u32).unwrap();
}
},
Genus::Cls => rom.set_long(tables.cls_ptrs + ofs, ip.main as u32).unwrap(),
_ => unimplemented!(),
};
}
pub fn name(&self, ebit: bool) -> &String {
if ebit && self.name_set.is_some() {
self.name_set.as_ref().unwrap()
} else {
&self.name
}
}
pub fn desc(&self, ebit: bool) -> &String {
if ebit && self.desc_set.is_some() {
self.desc_set.as_ref().unwrap()
} else {
&self.desc
}
}
pub fn uses_ebit(&self) -> bool { self.name_set.is_some() }
pub fn place_mw2(&self, target: &mut Vec<u8>, ebit: bool) {
if !self.placeable() { panic!("Attempted to place unplaceable sprite") };
let b0 = 0x89;
let b1 = 0x80;
let num_extra_bit: u8 = if self.id & 0x100 == 0 { 0 } else { 8 };
let ebit_val: u8 = if !ebit { 0 } else { 4 };
let b0 = b0 | num_extra_bit | ebit_val;
target.push(b0);
target.push(b1);
if self.id >= 0x200 {
target.push(0xf8 + self.extra_bytes);
}
target.push((self.id & 0xff) as u8);
for _ in 0 .. self.extra_bytes { target.push(0); };
}
pub fn dys_option_bytes(&self) -> &[u8] { &self.dys_option_bytes }
pub fn source_path(&self) -> &PathBuf { &self.source_path }
}
fn default_name(path: &Path, gen: Genus, id: u16) -> (String, String) {
let root = match path.file_stem() {
Some(s) => s.to_string_lossy().into_owned(),
None => format!("Custom {} #{:03x}", gen.shortname(), id),
};
(root.clone(), root + " (extra bit set)")
}
fn parse_newstyle(path: &Path, gen: Genus, id: u16, buf: &str) -> Result<SpriteCfg, CfgErr> {
let (mut got_name, mut got_desc): (Option<String>, Option<String>) = (None, None);
let mut cfg = SpriteCfg { genus: gen, id: id, .. SpriteCfg::new() };
let mut buf = buf;
while let IResult::Done(rest, (name, value)) = cfg_line(buf) {
buf = rest;
match name {
"acts-like" => cfg.acts_like = try!(read_byte(value)),
"source" => cfg.source_path = path.with_file_name(value),
"props" => try!(read_bytes(value, &mut cfg.tweak_bytes)),
"xbytes" => cfg.extra_bytes = try!(read_byte(value)),
"ext-props" => try | {
return single_error("No main routine");
} | conditional_block |
spritecfg.rs | 0, 0, 0],
dys_option_bytes: [0, 0],
acts_like: 0,
extra_bytes: 0,
name: "".to_string(),
desc: "".to_string(),
name_set: None,
desc_set: None,
source_path: PathBuf::from(""),
}
}
pub fn needs_init(&self) -> bool {
match self.genus {
Genus::Std => true,
_ => false,
}
}
pub fn needs_drop(&self) -> bool {
match self.genus {
Genus::Std => self.dys_option_bytes[1] & 0x80 != 0,
_ => false,
}
}
pub fn placeable(&self) -> bool { self.genus.placeable() }
pub fn assemble(
&self,
rom: &mut RomBuf,
prelude: &str,
source: &Path,
temp: &Path,
iopts: ::insert_opts::InsertOpts
) -> InsertResult<InsertPoint> {
let (mut main, mut init, mut drop) = (0usize, 0usize, 0usize);
{
let mut tempasm = OpenOptions::new()
.write(true)
.truncate(true)
.create(true)
.open(temp)
.unwrap();
tempasm.write_all(prelude.as_bytes()).unwrap();
let mut source_buf = Vec::<u8>::with_capacity(8 * 1024); // A wild guess.
let mut srcf = warnless_result(
File::open(source),
|e| format!("error opening \"{}\": {}", source.to_string_lossy(), e)
)?;
srcf.read_to_end(&mut source_buf).unwrap();
tempasm.write_all(&source_buf).unwrap();
}
let warns = match asar::patch(temp, rom) {
Ok((_, mut ws)) => ws.drain(..).map(|w| w.into()).collect(),
Err((mut es, mut ws)) => {
return Err(
(es.drain(..).map(|e| e.into()).collect(),
ws.drain(..).map(|w| w.into()).collect())
)
},
};
for print in asar::prints() {
let mut chunks = print.split_whitespace();
let fst = chunks.next();
let snd = chunks.next();
match fst {
Some("MAIN") => match snd {
Some(ofs) => main = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"MAIN\" declaration"),
},
Some("INIT") => match snd {
Some(ofs) => init = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"INIT\" declaration"),
},
Some("DROP") => match snd {
Some(ofs) => drop = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"DROP\" declaration"),
},
None => (),
_ => return single_error("The sprite printed something other than MAIN, INIT, or DROP"),
}
};
if main == 0 {
return single_error("No main routine");
}
if init == 0 && self.needs_init() {
return single_error("No init routine");
}
if drop == 0 && self.needs_drop() {
return single_error("Drop routine required by dys_opts, but not provided");
}
if drop != 0 && !self.needs_drop() {
return single_error("Sprite has a drop routine, but dys_opts doesn't require one");
}
if self.needs_drop() && !iopts.use_drops {
return single_error("Sprite needs a drop routine, but drop routines aren't enabled");
}
Ok((InsertPoint { main, init, drop }, warns))
}
pub fn apply_cfg(&self, rom: &mut RomBuf, tables: &DysTables) {
match self.genus {
Genus::Std
| Genus::Gen
| Genus::Sht
| Genus::R1s => {
if self.id < 0x200 {
let size_ofs = if self.id < 0x100 {
self.id as usize
} else {
self.id as usize + 0x100
};
let size = self.extra_bytes + 3;
rom.set_byte(tables.sprite_sizes + size_ofs, size).unwrap();
rom.set_byte(tables.sprite_sizes + size_ofs + 0x100, size).unwrap();
let optbase = tables.option_bytes + (self.id as usize * 0x10);
rom.set_byte(optbase, self.genus.to_byte()).unwrap();
rom.set_byte(optbase + 1, self.acts_like).unwrap();
rom.set_bytes(optbase + 2, &self.tweak_bytes).unwrap();
rom.set_bytes(optbase + 8, &self.dys_option_bytes).unwrap();
rom.set_bytes(optbase + 14, &self.prop_bytes).unwrap();
rom.set_bytes(optbase + 10, &self.clipping).unwrap();
};
},
Genus::Cls => {},
_ => unimplemented!(),
};
}
pub fn apply_offsets(&self, rom: &mut RomBuf, tables: &DysTables, ip: InsertPoint) {
let ofs = self.id as usize * 3;
match self.genus {
g if g.placeable() => {
rom.set_long(tables.main_ptrs + ofs, ip.main as u32).unwrap();
rom.set_long(tables.init_ptrs + ofs, ip.init as u32).unwrap();
if tables.drop_ptrs != 0 {
rom.set_long(tables.drop_ptrs + ofs, ip.drop as u32).unwrap();
}
},
Genus::Cls => rom.set_long(tables.cls_ptrs + ofs, ip.main as u32).unwrap(),
_ => unimplemented!(),
};
}
pub fn | (&self, ebit: bool) -> &String {
if ebit && self.name_set.is_some() {
self.name_set.as_ref().unwrap()
} else {
&self.name
}
}
pub fn desc(&self, ebit: bool) -> &String {
if ebit && self.desc_set.is_some() {
self.desc_set.as_ref().unwrap()
} else {
&self.desc
}
}
pub fn uses_ebit(&self) -> bool { self.name_set.is_some() }
pub fn place_mw2(&self, target: &mut Vec<u8>, ebit: bool) {
if !self.placeable() { panic!("Attempted to place unplaceable sprite") };
let b0 = 0x89;
let b1 = 0x80;
let num_extra_bit: u8 = if self.id & 0x100 == 0 { 0 } else { 8 };
let ebit_val: u8 = if !ebit { 0 } else { 4 };
let b0 = b0 | num_extra_bit | ebit_val;
target.push(b0);
target.push(b1);
if self.id >= 0x200 {
target.push(0xf8 + self.extra_bytes);
}
target.push((self.id & 0xff) as u8);
for _ in 0 .. self.extra_bytes { target.push(0); };
}
pub fn dys_option_bytes(&self) -> &[u8] { &self.dys_option_bytes }
pub fn source_path(&self) -> &PathBuf { &self.source_path }
}
fn default_name(path: &Path, gen: Genus, id: u16) -> (String, String) {
let root = match path.file_stem() {
Some(s) => s.to_string_lossy().into_owned(),
None => format!("Custom {} #{:03x}", gen.shortname(), id),
};
(root.clone(), root + " (extra bit set)")
}
fn parse_newstyle(path: &Path, gen: Genus, id: u16, buf: &str) -> Result<SpriteCfg, CfgErr> {
let (mut got_name, mut got_desc): (Option<String>, Option<String>) = (None, None);
let mut cfg = SpriteCfg { genus: gen, id: id, .. SpriteCfg::new() };
let mut buf = buf;
while let IResult::Done(rest, (name, value)) = cfg_line(buf) {
buf = rest;
match name {
"acts-like" => cfg.acts_like = try!(read_byte(value)),
"source" => cfg.source_path = path.with_file_name(value),
"props" => try!(read_bytes(value, &mut cfg.tweak_bytes)),
"xbytes" => cfg.extra_bytes = try!(read_byte(value)),
"ext-props" => try!( | name | identifier_name |
spritecfg.rs | , 0, 0, 0],
dys_option_bytes: [0, 0],
acts_like: 0,
extra_bytes: 0,
name: "".to_string(),
desc: "".to_string(),
name_set: None,
desc_set: None,
source_path: PathBuf::from(""),
}
}
pub fn needs_init(&self) -> bool {
match self.genus {
Genus::Std => true,
_ => false,
}
}
pub fn needs_drop(&self) -> bool {
match self.genus {
Genus::Std => self.dys_option_bytes[1] & 0x80 != 0,
_ => false,
}
}
pub fn placeable(&self) -> bool { self.genus.placeable() }
pub fn assemble(
&self,
rom: &mut RomBuf,
prelude: &str,
source: &Path,
temp: &Path,
iopts: ::insert_opts::InsertOpts
) -> InsertResult<InsertPoint> {
let (mut main, mut init, mut drop) = (0usize, 0usize, 0usize);
| {
let mut tempasm = OpenOptions::new()
.write(true)
.truncate(true)
.create(true)
.open(temp)
.unwrap();
tempasm.write_all(prelude.as_bytes()).unwrap();
let mut source_buf = Vec::<u8>::with_capacity(8 * 1024); // A wild guess.
let mut srcf = warnless_result(
File::open(source),
|e| format!("error opening \"{}\": {}", source.to_string_lossy(), e)
)?;
srcf.read_to_end(&mut source_buf).unwrap();
tempasm.write_all(&source_buf).unwrap();
}
let warns = match asar::patch(temp, rom) {
Ok((_, mut ws)) => ws.drain(..).map(|w| w.into()).collect(),
Err((mut es, mut ws)) => {
return Err(
(es.drain(..).map(|e| e.into()).collect(),
ws.drain(..).map(|w| w.into()).collect())
)
},
};
for print in asar::prints() {
let mut chunks = print.split_whitespace();
let fst = chunks.next();
let snd = chunks.next();
match fst {
Some("MAIN") => match snd {
Some(ofs) => main = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"MAIN\" declaration"),
},
Some("INIT") => match snd {
Some(ofs) => init = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"INIT\" declaration"),
},
Some("DROP") => match snd {
Some(ofs) => drop = usize::from_str_radix(ofs, 16).unwrap(),
_ => return single_error("No offset after \"DROP\" declaration"),
},
None => (),
_ => return single_error("The sprite printed something other than MAIN, INIT, or DROP"),
}
};
if main == 0 {
return single_error("No main routine");
}
if init == 0 && self.needs_init() {
return single_error("No init routine");
}
if drop == 0 && self.needs_drop() {
return single_error("Drop routine required by dys_opts, but not provided");
}
if drop != 0 && !self.needs_drop() {
return single_error("Sprite has a drop routine, but dys_opts doesn't require one");
}
if self.needs_drop() && !iopts.use_drops {
return single_error("Sprite needs a drop routine, but drop routines aren't enabled");
}
Ok((InsertPoint { main, init, drop }, warns))
}
pub fn apply_cfg(&self, rom: &mut RomBuf, tables: &DysTables) {
match self.genus {
Genus::Std
| Genus::Gen
| Genus::Sht
| Genus::R1s => {
if self.id < 0x200 {
let size_ofs = if self.id < 0x100 {
self.id as usize
} else {
self.id as usize + 0x100
};
let size = self.extra_bytes + 3;
rom.set_byte(tables.sprite_sizes + size_ofs, size).unwrap();
rom.set_byte(tables.sprite_sizes + size_ofs + 0x100, size).unwrap();
let optbase = tables.option_bytes + (self.id as usize * 0x10);
rom.set_byte(optbase, self.genus.to_byte()).unwrap();
rom.set_byte(optbase + 1, self.acts_like).unwrap();
rom.set_bytes(optbase + 2, &self.tweak_bytes).unwrap();
rom.set_bytes(optbase + 8, &self.dys_option_bytes).unwrap();
rom.set_bytes(optbase + 14, &self.prop_bytes).unwrap();
rom.set_bytes(optbase + 10, &self.clipping).unwrap();
};
},
Genus::Cls => {},
_ => unimplemented!(),
};
}
pub fn apply_offsets(&self, rom: &mut RomBuf, tables: &DysTables, ip: InsertPoint) {
let ofs = self.id as usize * 3;
match self.genus {
g if g.placeable() => {
rom.set_long(tables.main_ptrs + ofs, ip.main as u32).unwrap();
rom.set_long(tables.init_ptrs + ofs, ip.init as u32).unwrap();
if tables.drop_ptrs != 0 {
rom.set_long(tables.drop_ptrs + ofs, ip.drop as u32).unwrap();
}
},
Genus::Cls => rom.set_long(tables.cls_ptrs + ofs, ip.main as u32).unwrap(),
_ => unimplemented!(),
};
}
pub fn name(&self, ebit: bool) -> &String {
if ebit && self.name_set.is_some() {
self.name_set.as_ref().unwrap()
} else {
&self.name
}
}
pub fn desc(&self, ebit: bool) -> &String {
if ebit && self.desc_set.is_some() {
self.desc_set.as_ref().unwrap()
} else {
&self.desc
}
}
pub fn uses_ebit(&self) -> bool { self.name_set.is_some() }
pub fn place_mw2(&self, target: &mut Vec<u8>, ebit: bool) {
if !self.placeable() { panic!("Attempted to place unplaceable sprite") };
let b0 = 0x89;
let b1 = 0x80;
let num_extra_bit: u8 = if self.id & 0x100 == 0 { 0 } else { 8 };
let ebit_val: u8 = if !ebit { 0 } else { 4 };
let b0 = b0 | num_extra_bit | ebit_val;
target.push(b0);
target.push(b1);
if self.id >= 0x200 {
target.push(0xf8 + self.extra_bytes);
}
target.push((self.id & 0xff) as u8);
for _ in 0 .. self.extra_bytes { target.push(0); };
}
pub fn dys_option_bytes(&self) -> &[u8] { &self.dys_option_bytes }
pub fn source_path(&self) -> &PathBuf { &self.source_path }
}
fn default_name(path: &Path, gen: Genus, id: u16) -> (String, String) {
let root = match path.file_stem() {
Some(s) => s.to_string_lossy().into_owned(),
None => format!("Custom {} #{:03x}", gen.shortname(), id),
};
(root.clone(), root + " (extra bit set)")
}
fn parse_newstyle(path: &Path, gen: Genus, id: u16, buf: &str) -> Result<SpriteCfg, CfgErr> {
let (mut got_name, mut got_desc): (Option<String>, Option<String>) = (None, None);
let mut cfg = SpriteCfg { genus: gen, id: id, .. SpriteCfg::new() };
let mut buf = buf;
while let IResult::Done(rest, (name, value)) = cfg_line(buf) {
buf = rest;
match name {
"acts-like" => cfg.acts_like = try!(read_byte(value)),
"source" => cfg.source_path = path.with_file_name(value),
"props" => try!(read_bytes(value, &mut cfg.tweak_bytes)),
"xbytes" => cfg.extra_bytes = try!(read_byte(value)),
"ext-props" => try!( | random_line_split |
|
models.py |
SIZE_BIG = 4
SIZE_HOUSE = 10
# required_bohnen are per abo, not per person
AboTyp = namedtuple('AboTyp', ['size', 'name_short', 'name_long', 'description', 'min_anteilsscheine', 'visible', 'required_bohnen', 'cost']);
abo_types = {
SIZE_NONE: AboTyp( size=SIZE_NONE, name_short='Keins', name_long='Kein Abo',
min_anteilsscheine=1, visible=True, required_bohnen = 0,
cost = 0,
description=u"Du kannst auch ohne Gemüseabo "+settings.SITE_NAME+"-GenossenschafterIn sein. Bleibe auf dem Laufenden und mach mit, wenn du Lust hast"),
SIZE_HALF: AboTyp( size=SIZE_HALF, name_short='Halb', name_long='Halbes Abo',
min_anteilsscheine=1, visible=False, required_bohnen = 10,
cost = 550,
description=u"Halbe Abos können in Ausnahmefällen vergeben werden"),
SIZE_SMALL: AboTyp( size=SIZE_SMALL, name_short='Klein', name_long='Kleines Abo',
min_anteilsscheine=2, visible=True, required_bohnen = 20,
cost = 1100,
description=u"Das kleine Abo ist für 2-3 Personen geeignet und benötigt mindestens zwei Anteilscheine"),
SIZE_BIG: AboTyp( size=SIZE_BIG, name_short='Gross', name_long='Grosses Abo',
min_anteilsscheine=4, visible=True, required_bohnen = 40,
cost = 2200,
description=u"Das grosse Abo empfiehlt sich für WG's oder Familien (ca. 4-6 Personen) und benötigt vier Anteilscheine")
}
SIZE_CHOICES = ((k, v.name_short) for k, v in abo_types.iteritems())
number = models.CharField("Abo-Nummer", blank=True, max_length=6)
number.help_text = "Interne Abo-Nummer"
depot = models.ForeignKey(Depot, on_delete=models.PROTECT)
groesse = models.PositiveIntegerField(choices=SIZE_CHOICES,default=SIZE_SMALL)
extra_abos = models.ManyToManyField(ExtraAboType, null=True, blank=True)
extra_abos.help_text = "Zusatz-Abos existieren vorderhand nicht, dieses Feld bleibt leer."
primary_loco = models.ForeignKey("Loco", related_name="abo_primary", null=True, blank=True,
on_delete=models.PROTECT)
primary_loco.help_text = "Primärer Ansprechpartner dieses Abos"
paid = models.BooleanField(default=False, verbose_name="Bezahlt")
paid.help_text = "Dieses Abo wurde vollständig bezahlt."
active = models.BooleanField(default=False, verbose_name="Aktiv")
active.help_text = "An dieses Abo wird Gemüse geliefert"
def __unicode__(self):
if self.SIZE_HALF == self.groesse:
namelist = ["1/2 Einheit"]
elif self.SIZE_SMALL == self.groesse:
namelist = ["1 Einheit"]
else:
namelist = ["%i Einheiten" % int(self.groesse / float(self.SIZE_SMALL))]
namelist.extend(extra.name for extra in self.extra_abos.all())
return u"Abo (%s) #%s" % (" + ".join(namelist), self.number)
def bezieher(self):
locos = self.locos.all()
return ", ".join(unicode(loco) for loco in locos)
def andere_bezieher(self):
locos = self.bezieher_locos().exclude(email=self.primary_loco.email)
return ", ".join(unicode(loco) for loco in locos)
def bezieher_locos(self):
return self.locos.all()
def verantwortlicher_bezieher(self):
loco = self.primary_loco
return unicode(loco) if loco is not None else ""
def groesse_name(self):
return self.abo_types[self.groesse].name_long
def groesse_name_short(self):
return self.get_groesse_display()
class Meta:
verbose_name = "Abo"
verbose_name_plural = "Abos"
class Loco(models.Model):
"""
Additional fields for Django's default user class.
"""
# user class is only used for logins, permissions, and other builtin django stuff
# all user information should be stored in the Loco model
user = models.OneToOneField(User, related_name='loco', null=True, blank=True)
first_name = models.CharField("Vorname", max_length=30)
last_name = models.CharField("Nachname", max_length=30)
email = models.EmailField(unique=True)
SEX = [
("M", "Herr"),
("F", "Frau")
]
sex = models.CharField("Geschlecht", max_length=1, choices=SEX, default='F')
addr_street = models.CharField("Strasse", max_length=100)
addr_zipcode = models.CharField("PLZ", max_length=10)
addr_location = models.CharField("Ort", max_length=50)
birthday = models.DateField("Geburtsdatum", null=True, blank=True)
phone = models.CharField("Telefonnr", max_length=50)
mobile_phone = models.CharField("Mobile", max_length=50, null=True, blank=True)
abo = models.ForeignKey(Abo, related_name="locos", null=True, blank=True,
on_delete=models.SET_NULL)
abo.help_text = "Um dieses Mitglied einem Abo zuzuweisen oder die Abozuordnung zu ändern, bitte wie die Abo-Seite gehen."
confirmed = models.BooleanField("bestätigt", default=True)
confirmed.help_text = "Neu-Anmeldungen über die Webseite sind zuerst nicht bestätigt. Dieses Feld muss danach manuell gesetzt werden."
def get_salutation(self):
if self.sex is 'M':
return 'Herr'
else:
return 'Frau'
def get_full_salutation(self):
if self.sex is 'M':
return 'Lieber '+self.get_name()
else:
return 'Liebe '+self.get_name()
def get_taetigkeitsbereiche(self):
tbs = []
for tb in Taetigkeitsbereich.objects.all():
if tb.locos.all().filter(id=self.id).__len__() > 0:
tbs.append(tb)
return tbs
def __unicode__(self):
return self.get_name()
@classmethod
def create(cls, sender, instance, created, **kdws):
"""
Callback to create corresponding loco when new user is created.
"""
if created:
username = helpers.make_username(instance.first_name, instance.last_name, instance.email)
user = User(username=username)
user.save()
user = User.objects.get(username=username)
instance.user = user
instance.save()
@classmethod
def post_delete(cls, sender, instance, **kwds):
instance.user.delete()
class Meta:
verbose_name = "Mitglied"
verbose_name_plural = "Mitglieder"
def get_name(self):
return u"%s %s" % (self.first_name, self.last_name)
def get_phone(self):
if self.mobile_phone != "":
return self.mobile_phone
return self.phone
class Anteilschein(models.Model):
number = models.CharField("Anteilsschein-Nummer", blank=True, max_length=6)
number.help_text = "Interne Anteilsschein-Nummer"
loco = models.ForeignKey(Loco, null=True, blank=True, on_delete=models.SET_NULL)
loco.help_text = "Eigner des Anteilsscheins"
paid = models.BooleanField(default=False, verbose_name="Bezahlt")
paid.help_text = "Dieser Anteilsschein wurde vollständig bezahlt."
canceled = models.BooleanField(default=False, verbose_name="Gekündigt")
def __unicode__(self):
return u"Anteilschein #%s" % (self.number)
class Meta:
verbose_name = "Anteilschein"
ver | :
name = models.CharField("Name", max_length=100, unique=True)
description = models.TextField("Beschreibung", max_length=1000, default="")
core = models.BooleanField("Kernbereich", default=False)
hidden = models.BooleanField("versteckt", default=False)
coordinator = models.ForeignKey(Loco, on_delete=models.PROTECT)
locos = models.ManyToManyField(Loco, related_name="areas", blank=True, | bose_name_plural = "Anteilscheine"
class Taetigkeitsbereich(models.Model) | identifier_body |
models.py |
print 'get_abos_by_size', self, result
return result
"""
def small_abos(self):
return len(self.active_abos().filter(Q(groesse=1) | Q(groesse=3)))
def big_abos(self):
return len(self.active_abos().filter(Q(groesse=2) | Q(groesse=3) | Q(groesse=4))) + len(self.active_abos().filter(groesse=4))
"""
class Meta:
verbose_name = "Depot"
verbose_name_plural = "Depots"
class ExtraAboType(models.Model):
"""
Types of extra abos, e.g. eggs, cheese, fruit
"""
name = models.CharField("Name", max_length=100, unique=True)
description = models.TextField("Beschreibung", max_length=1000)
def __unicode__(self):
return u"%s %s" % (self.id, self.name)
class Meta:
verbose_name = "Zusatz-Abo"
verbose_name_plural = "Zusatz-Abos"
class Abo(models.Model):
"""
One Abo that may be shared among several people.
"""
SIZE_NONE = 0
SIZE_HALF = 1
SIZE_SMALL = 2
SIZE_BIG = 4
SIZE_HOUSE = 10
# required_bohnen are per abo, not per person
AboTyp = namedtuple('AboTyp', ['size', 'name_short', 'name_long', 'description', 'min_anteilsscheine', 'visible', 'required_bohnen', 'cost']);
abo_types = {
SIZE_NONE: AboTyp( size=SIZE_NONE, name_short='Keins', name_long='Kein Abo',
min_anteilsscheine=1, visible=True, required_bohnen = 0,
cost = 0,
description=u"Du kannst auch ohne Gemüseabo "+settings.SITE_NAME+"-GenossenschafterIn sein. Bleibe auf dem Laufenden und mach mit, wenn du Lust hast"),
SIZE_HALF: AboTyp( size=SIZE_HALF, name_short='Halb', name_long='Halbes Abo',
min_anteilsscheine=1, visible=False, required_bohnen = 10,
cost = 550,
description=u"Halbe Abos können in Ausnahmefällen vergeben werden"),
SIZE_SMALL: AboTyp( size=SIZE_SMALL, name_short='Klein', name_long='Kleines Abo',
min_anteilsscheine=2, visible=True, required_bohnen = 20,
cost = 1100,
description=u"Das kleine Abo ist für 2-3 Personen geeignet und benötigt mindestens zwei Anteilscheine"),
SIZE_BIG: AboTyp( size=SIZE_BIG, name_short='Gross', name_long='Grosses Abo',
min_anteilsscheine=4, visible=True, required_bohnen = 40,
cost = 2200,
description=u"Das grosse Abo empfiehlt sich für WG's oder Familien (ca. 4-6 Personen) und benötigt vier Anteilscheine")
}
SIZE_CHOICES = ((k, v.name_short) for k, v in abo_types.iteritems())
number = models.CharField("Abo-Nummer", blank=True, max_length=6)
number.help_text = "Interne Abo-Nummer"
depot = models.ForeignKey(Depot, on_delete=models.PROTECT)
groesse = models.PositiveIntegerField(choices=SIZE_CHOICES,default=SIZE_SMALL)
extra_abos = models.ManyToManyField(ExtraAboType, null=True, blank=True)
extra_abos.help_text = "Zusatz-Abos existieren vorderhand nicht, dieses Feld bleibt leer."
primary_loco = models.ForeignKey("Loco", related_name="abo_primary", null=True, blank=True,
on_delete=models.PROTECT)
primary_loco.help_text = "Primärer Ansprechpartner dieses Abos"
paid = models.BooleanField(default=False, verbose_name="Bezahlt")
paid.help_text = "Dieses Abo wurde vollständig bezahlt."
active = models.BooleanField(default=False, verbose_name="Aktiv")
active.help_text = "An dieses Abo wird Gemüse geliefert"
def __unicode__(self):
if self.SIZE_HALF == self.groesse:
namelist = ["1/2 Einheit"]
elif self.SIZE_SMALL == self.groesse:
namelist = ["1 Einheit"]
else:
namelist = ["%i Einheiten" % int(self.groesse / float(self.SIZE_SMALL))]
namelist.extend(extra.name for extra in self.extra_abos.all())
return u"Abo (%s) #%s" % (" + ".join(namelist), self.number)
def bezieher(self):
locos = self.locos.all()
return ", ".join(unicode(loco) for loco in locos)
def andere_bezieher(self):
locos = self.bezieher_locos().exclude(email=self.primary_loco.email)
return ", ".join(unicode(loco) for loco in locos)
def bezieher_locos(self):
return self.locos.all()
def verantwortlicher_bezieher(self):
loco = self.primary_loco
return unicode(loco) if loco is not None else ""
def groesse_name(self):
return self.abo_types[self.groesse].name_long
def groesse_name_short(self):
return self.get_groesse_display()
class Meta:
verbose_name = "Abo"
verbose_name_plural = "Abos"
class Loco(models.Model):
"""
Additional fields for Django's default user class.
"""
# user class is only used for logins, permissions, and other builtin django stuff
# all user information should be stored in the Loco model
user = models.OneToOneField(User, related_name='loco', null=True, blank=True)
first_name = models.CharField("Vorname", max_length=30)
last_name = models.CharField("Nachname", max_length=30)
email = models.EmailField(unique=True)
SEX = [
("M", "Herr"),
("F", "Frau")
]
sex = models.CharField("Geschlecht", max_length=1, choices=SEX, default='F')
addr_street = models.CharField("Strasse", max_length=100)
addr_zipcode = models.CharField("PLZ", max_length=10)
addr_location = models.CharField("Ort", max_length=50)
birthday = models.DateField("Geburtsdatum", null=True, blank=True)
phone = models.CharField("Telefonnr", max_length=50)
mobile_phone = models.CharField("Mobile", max_length=50, null=True, blank=True)
abo = models.ForeignKey(Abo, related_name="locos", null=True, blank=True,
on_delete=models.SET_NULL)
abo.help_text = "Um dieses Mitglied einem Abo zuzuweisen oder die Abozuordnung zu ändern, bitte wie die Abo-Seite gehen."
confirmed = models.BooleanField("bestätigt", default=True)
confirmed.help_text = "Neu-Anmeldungen über die Webseite sind zuerst nicht bestätigt. Dieses Feld muss danach manuell gesetzt werden."
def get_salutation(self):
if self.sex is 'M':
return 'Herr'
else:
return 'Frau'
def get_full_salutation(self):
if self.sex is 'M':
return 'Lieber '+self.get_name()
else:
return 'Liebe '+self.get_name()
def get_taetigkeitsbereiche(self):
tbs = []
for tb in Taetigkeitsbereich.objects.all():
if tb.locos.all().filter(id=self.id).__len__() > 0:
tbs.append(tb)
return tbs
def __unicode__(self):
return self.get_name()
@classmethod
def create(cls, sender, instance, created, **kdws):
"""
Callback to create corresponding loco when new user is created.
"""
if created:
username = helpers.make_username(instance.first_name, instance.last_name, instance.email)
user = User(username=username)
user.save()
user = User.objects.get(username=username)
instance.user = user
instance.save()
@classmethod
def post_delete(cls, sender, instance, **kwds):
instance.user.delete()
class Meta:
verbose_name = "Mitglied"
verbose_name_plural = "Mitglieder"
def get_name(self):
return u"%s %s" % (self.first_name, self.last_name)
def get_phone | if abo_size is not Abo.SIZE_NONE:
result[abo_size] = len(self.active_abos().filter(groesse=abo_size)) | conditional_block |
|
models.py |
SIZE_BIG = 4
SIZE_HOUSE = 10
# required_bohnen are per abo, not per person
AboTyp = namedtuple('AboTyp', ['size', 'name_short', 'name_long', 'description', 'min_anteilsscheine', 'visible', 'required_bohnen', 'cost']);
abo_types = {
SIZE_NONE: AboTyp( size=SIZE_NONE, name_short='Keins', name_long='Kein Abo',
min_anteilsscheine=1, visible=True, required_bohnen = 0,
cost = 0,
description=u"Du kannst auch ohne Gemüseabo "+settings.SITE_NAME+"-GenossenschafterIn sein. Bleibe auf dem Laufenden und mach mit, wenn du Lust hast"),
SIZE_HALF: AboTyp( size=SIZE_HALF, name_short='Halb', name_long='Halbes Abo',
min_anteilsscheine=1, visible=False, required_bohnen = 10,
cost = 550,
description=u"Halbe Abos können in Ausnahmefällen vergeben werden"),
SIZE_SMALL: AboTyp( size=SIZE_SMALL, name_short='Klein', name_long='Kleines Abo',
min_anteilsscheine=2, visible=True, required_bohnen = 20,
cost = 1100,
description=u"Das kleine Abo ist für 2-3 Personen geeignet und benötigt mindestens zwei Anteilscheine"),
SIZE_BIG: AboTyp( size=SIZE_BIG, name_short='Gross', name_long='Grosses Abo',
min_anteilsscheine=4, visible=True, required_bohnen = 40,
cost = 2200,
description=u"Das grosse Abo empfiehlt sich für WG's oder Familien (ca. 4-6 Personen) und benötigt vier Anteilscheine")
}
SIZE_CHOICES = ((k, v.name_short) for k, v in abo_types.iteritems())
number = models.CharField("Abo-Nummer", blank=True, max_length=6)
number.help_text = "Interne Abo-Nummer"
depot = models.ForeignKey(Depot, on_delete=models.PROTECT)
groesse = models.PositiveIntegerField(choices=SIZE_CHOICES,default=SIZE_SMALL)
extra_abos = models.ManyToManyField(ExtraAboType, null=True, blank=True)
extra_abos.help_text = "Zusatz-Abos existieren vorderhand nicht, dieses Feld bleibt leer."
primary_loco = models.ForeignKey("Loco", related_name="abo_primary", null=True, blank=True,
on_delete=models.PROTECT)
primary_loco.help_text = "Primärer Ansprechpartner dieses Abos"
paid = models.BooleanField(default=False, verbose_name="Bezahlt")
paid.help_text = "Dieses Abo wurde vollständig bezahlt."
active = models.BooleanField(default=False, verbose_name="Aktiv")
active.help_text = "An dieses Abo wird Gemüse geliefert"
def __unicode__(self):
if self.SIZE_HALF == self.groesse:
namelist = ["1/2 Einheit"]
elif self.SIZE_SMALL == self.groesse:
namelist = ["1 Einheit"]
else:
namelist = ["%i Einheiten" % int(self.groesse / float(self.SIZE_SMALL))]
namelist.extend(extra.name for extra in self.extra_abos.all())
return u"Abo (%s) #%s" % (" + ".join(namelist), self.number)
def bezieher(self):
locos = self.locos.all()
return ", ".join(unicode(loco) for loco in locos)
def andere_bezieher(self):
locos = self.bezieher_locos().exclude(email=self.primary_loco.email)
return ", ".join(unicode(loco) for loco in locos)
def bezieher_locos(self):
return self.locos.all()
def verantwortlicher_bezieher(self):
loco = self.primary_loco
return unicode(loco) if loco is not None else ""
def groesse_name(self):
return self.abo_types[self.groesse].name_long
def groesse_name_short(self):
return self.get_groesse_display()
class Meta:
verbose_name = "Abo"
verbose_name_plural = "Abos"
class Loco(models.Model):
"""
Additional fields for Django's default user class.
"""
| # user class is only used for logins, permissions, and other builtin django stuff
# all user information should be stored in the Loco model
user = models.OneToOneField(User, related_name='loco', null=True, blank=True)
first_name = models.CharField("Vorname", max_length=30)
last_name = models.CharField("Nachname", max_length=30)
email = models.EmailField(unique=True)
SEX = [
("M", "Herr"),
("F", "Frau")
]
sex = models.CharField("Geschlecht", max_length=1, choices=SEX, default='F')
addr_street = models.CharField("Strasse", max_length=100)
addr_zipcode = models.CharField("PLZ", max_length=10)
addr_location = models.CharField("Ort", max_length=50)
birthday = models.DateField("Geburtsdatum", null=True, blank=True)
phone = models.CharField("Telefonnr", max_length=50)
mobile_phone = models.CharField("Mobile", max_length=50, null=True, blank=True)
abo = models.ForeignKey(Abo, related_name="locos", null=True, blank=True,
on_delete=models.SET_NULL)
abo.help_text = "Um dieses Mitglied einem Abo zuzuweisen oder die Abozuordnung zu ändern, bitte wie die Abo-Seite gehen."
confirmed = models.BooleanField("bestätigt", default=True)
confirmed.help_text = "Neu-Anmeldungen über die Webseite sind zuerst nicht bestätigt. Dieses Feld muss danach manuell gesetzt werden."
def get_salutation(self):
if self.sex is 'M':
return 'Herr'
else:
return 'Frau'
def get_full_salutation(self):
if self.sex is 'M':
return 'Lieber '+self.get_name()
else:
return 'Liebe '+self.get_name()
def get_taetigkeitsbereiche(self):
tbs = []
for tb in Taetigkeitsbereich.objects.all():
if tb.locos.all().filter(id=self.id).__len__() > 0:
tbs.append(tb)
return tbs
def __unicode__(self):
return self.get_name()
@classmethod
def create(cls, sender, instance, created, **kdws):
"""
Callback to create corresponding loco when new user is created.
"""
if created:
username = helpers.make_username(instance.first_name, instance.last_name, instance.email)
user = User(username=username)
user.save()
user = User.objects.get(username=username)
instance.user = user
instance.save()
@classmethod
def post_delete(cls, sender, instance, **kwds):
instance.user.delete()
class Meta:
verbose_name = "Mitglied"
verbose_name_plural = "Mitglieder"
def get_name(self):
return u"%s %s" % (self.first_name, self.last_name)
def get_phone(self):
if self.mobile_phone != "":
return self.mobile_phone
return self.phone
class Anteilschein(models.Model):
number = models.CharField("Anteilsschein-Nummer", blank=True, max_length=6)
number.help_text = "Interne Anteilsschein-Nummer"
loco = models.ForeignKey(Loco, null=True, blank=True, on_delete=models.SET_NULL)
loco.help_text = "Eigner des Anteilsscheins"
paid = models.BooleanField(default=False, verbose_name="Bezahlt")
paid.help_text = "Dieser Anteilsschein wurde vollständig bezahlt."
canceled = models.BooleanField(default=False, verbose_name="Gekündigt")
def __unicode__(self):
return u"Anteilschein #%s" % (self.number)
class Meta:
verbose_name = "Anteilschein"
verbose_name_plural = "Anteilscheine"
class Taetigkeitsbereich(models.Model):
name = models.CharField("Name", max_length=100, unique=True)
description = models.TextField("Beschreibung", max_length=1000, default="")
core = models.BooleanField("Kernbereich", default=False)
hidden = models.BooleanField("versteckt", default=False)
coordinator = models.ForeignKey(Loco, on_delete=models.PROTECT)
locos = models.ManyToManyField(Loco, related_name="areas", blank=True, null=True | random_line_split |
|
models.py |
SIZE_BIG = 4
SIZE_HOUSE = 10
# required_bohnen are per abo, not per person
AboTyp = namedtuple('AboTyp', ['size', 'name_short', 'name_long', 'description', 'min_anteilsscheine', 'visible', 'required_bohnen', 'cost']);
abo_types = {
SIZE_NONE: AboTyp( size=SIZE_NONE, name_short='Keins', name_long='Kein Abo',
min_anteilsscheine=1, visible=True, required_bohnen = 0,
cost = 0,
description=u"Du kannst auch ohne Gemüseabo "+settings.SITE_NAME+"-GenossenschafterIn sein. Bleibe auf dem Laufenden und mach mit, wenn du Lust hast"),
SIZE_HALF: AboTyp( size=SIZE_HALF, name_short='Halb', name_long='Halbes Abo',
min_anteilsscheine=1, visible=False, required_bohnen = 10,
cost = 550,
description=u"Halbe Abos können in Ausnahmefällen vergeben werden"),
SIZE_SMALL: AboTyp( size=SIZE_SMALL, name_short='Klein', name_long='Kleines Abo',
min_anteilsscheine=2, visible=True, required_bohnen = 20,
cost = 1100,
description=u"Das kleine Abo ist für 2-3 Personen geeignet und benötigt mindestens zwei Anteilscheine"),
SIZE_BIG: AboTyp( size=SIZE_BIG, name_short='Gross', name_long='Grosses Abo',
min_anteilsscheine=4, visible=True, required_bohnen = 40,
cost = 2200,
description=u"Das grosse Abo empfiehlt sich für WG's oder Familien (ca. 4-6 Personen) und benötigt vier Anteilscheine")
}
SIZE_CHOICES = ((k, v.name_short) for k, v in abo_types.iteritems())
number = models.CharField("Abo-Nummer", blank=True, max_length=6)
number.help_text = "Interne Abo-Nummer"
depot = models.ForeignKey(Depot, on_delete=models.PROTECT)
groesse = models.PositiveIntegerField(choices=SIZE_CHOICES,default=SIZE_SMALL)
extra_abos = models.ManyToManyField(ExtraAboType, null=True, blank=True)
extra_abos.help_text = "Zusatz-Abos existieren vorderhand nicht, dieses Feld bleibt leer."
primary_loco = models.ForeignKey("Loco", related_name="abo_primary", null=True, blank=True,
on_delete=models.PROTECT)
primary_loco.help_text = "Primärer Ansprechpartner dieses Abos"
paid = models.BooleanField(default=False, verbose_name="Bezahlt")
paid.help_text = "Dieses Abo wurde vollständig bezahlt."
active = models.BooleanField(default=False, verbose_name="Aktiv")
active.help_text = "An dieses Abo wird Gemüse geliefert"
def __unicode__(self):
if self.SIZE_HALF == self.groesse:
namelist = ["1/2 Einheit"]
elif self.SIZE_SMALL == self.groesse:
namelist = ["1 Einheit"]
else:
namelist = ["%i Einheiten" % int(self.groesse / float(self.SIZE_SMALL))]
namelist.extend(extra.name for extra in self.extra_abos.all())
return u"Abo (%s) #%s" % (" + ".join(namelist), self.number)
def bezieher(self):
locos = self.locos.all()
return ", ".join(unicode(loco) for loco in locos)
def andere_bezieher(self):
locos = self.bezieher_locos().exclude(email=self.primary_loco.email)
return ", ".join(unicode(loco) for loco in locos)
def bezieher_locos(self):
return self.locos.all()
def verantwortlicher_bezieher(self):
loco = self.primary_loco
return unicode(loco) if loco is not None else ""
def groesse_name(self):
return self.abo_types[self.groesse].name_long
def groesse_name_short(self):
return self.get_groesse_display()
class Meta:
verbose_name = "Abo"
verbose_name_plural = "Abos"
class Loco(models.Model):
"""
Additional fields for Django's default user class.
"""
# user class is only used for logins, permissions, and other builtin django stuff
# all user information should be stored in the Loco model
user = models.OneToOneField(User, related_name='loco', null=True, blank=True)
first_name = models.CharField("Vorname", max_length=30)
last_name = models.CharField("Nachname", max_length=30)
email = models.EmailField(unique=True)
SEX = [
("M", "Herr"),
("F", "Frau")
]
sex = models.CharField("Geschlecht", max_length=1, choices=SEX, default='F')
addr_street = models.CharField("Strasse", max_length=100)
addr_zipcode = models.CharField("PLZ", max_length=10)
addr_location = models.CharField("Ort", max_length=50)
birthday = models.DateField("Geburtsdatum", null=True, blank=True)
phone = models.CharField("Telefonnr", max_length=50)
mobile_phone = models.CharField("Mobile", max_length=50, null=True, blank=True)
abo = models.ForeignKey(Abo, related_name="locos", null=True, blank=True,
on_delete=models.SET_NULL)
abo.help_text = "Um dieses Mitglied einem Abo zuzuweisen oder die Abozuordnung zu ändern, bitte wie die Abo-Seite gehen."
confirmed = models.BooleanField("bestätigt", default=True)
confirmed.help_text = "Neu-Anmeldungen über die Webseite sind zuerst nicht bestätigt. Dieses Feld muss danach manuell gesetzt werden."
def get_salutation(self):
if self.sex is 'M':
return 'Herr'
else:
return 'Frau'
def get_full_salutation(self):
if self.sex is 'M':
return 'Lieber '+self.get_name()
else:
return 'Liebe '+self.get_name()
def get_taetigkeitsbereiche(self):
tbs = []
for tb in Taetigkeitsbereich.objects.all():
if tb.locos.all().filter(id=self.id).__len__() > 0:
tbs.append(tb)
return tbs
def __unicode__(self):
return self.get_name()
@classmethod
def create(cls, sender, instance, created, | ):
"""
Callback to create corresponding loco when new user is created.
"""
if created:
username = helpers.make_username(instance.first_name, instance.last_name, instance.email)
user = User(username=username)
user.save()
user = User.objects.get(username=username)
instance.user = user
instance.save()
@classmethod
def post_delete(cls, sender, instance, **kwds):
instance.user.delete()
class Meta:
verbose_name = "Mitglied"
verbose_name_plural = "Mitglieder"
def get_name(self):
return u"%s %s" % (self.first_name, self.last_name)
def get_phone(self):
if self.mobile_phone != "":
return self.mobile_phone
return self.phone
class Anteilschein(models.Model):
number = models.CharField("Anteilsschein-Nummer", blank=True, max_length=6)
number.help_text = "Interne Anteilsschein-Nummer"
loco = models.ForeignKey(Loco, null=True, blank=True, on_delete=models.SET_NULL)
loco.help_text = "Eigner des Anteilsscheins"
paid = models.BooleanField(default=False, verbose_name="Bezahlt")
paid.help_text = "Dieser Anteilsschein wurde vollständig bezahlt."
canceled = models.BooleanField(default=False, verbose_name="Gekündigt")
def __unicode__(self):
return u"Anteilschein #%s" % (self.number)
class Meta:
verbose_name = "Anteilschein"
verbose_name_plural = "Anteilscheine"
class Taetigkeitsbereich(models.Model):
name = models.CharField("Name", max_length=100, unique=True)
description = models.TextField("Beschreibung", max_length=1000, default="")
core = models.BooleanField("Kernbereich", default=False)
hidden = models.BooleanField("versteckt", default=False)
coordinator = models.ForeignKey(Loco, on_delete=models.PROTECT)
locos = models.ManyToManyField(Loco, related_name="areas", blank=True, null | **kdws | identifier_name |
jwt.rs | ;
pub static JWT_AUDIENCE_FIRESTORE: &str =
"https://firestore.googleapis.com/google.firestore.v1.Firestore";
pub static JWT_AUDIENCE_IDENTITY: &str =
"https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit";
pub trait PrivateClaims
where
Self: Serialize + DeserializeOwned + Clone + Default,
{
fn get_scopes(&self) -> HashSet<String>;
fn get_client_id(&self) -> Option<String>;
fn get_uid(&self) -> Option<String>;
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtOAuthPrivateClaims {
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub uid: Option<String>, // Probably the firebase User ID if set
}
impl JwtOAuthPrivateClaims {
pub fn new<S: AsRef<str>>(
scope: Option<Iter<S>>,
client_id: Option<String>,
user_id: Option<String>,
) -> Self {
JwtOAuthPrivateClaims {
scope: scope.and_then(|f| {
Some(f.fold(String::new(), |acc, x| {
let x: &str = x.as_ref();
return acc + x + " ";
}))
}),
client_id,
uid: user_id,
}
}
}
impl PrivateClaims for JwtOAuthPrivateClaims {
fn get_scopes(&self) -> HashSet<String> {
match self.scope {
Some(ref v) => v.split(" ").map(|f| f.to_owned()).collect(),
None => HashSet::new(),
}
}
fn get_client_id(&self) -> Option<String> {
self.client_id.clone()
}
fn get_uid(&self) -> Option<String> {
self.uid.clone()
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtCustomClaims {
pub uid: String,
pub claims: HashMap<String, Value>,
}
impl JwtCustomClaims {
pub fn new<T: Serialize>(uid: &str, claims: T) -> Self {
let dev_claims = {
let val = serde_json::to_string(&claims).unwrap_or("".to_string());
serde_json::from_str::<HashMap<String, Value>>(&val).unwrap_or_default()
};
JwtCustomClaims {
claims: dev_claims,
uid: uid.to_string(),
}
}
}
impl PrivateClaims for JwtCustomClaims {
fn get_scopes(&self) -> HashSet<String> {
HashSet::new()
}
fn get_client_id(&self) -> Option<String> {
None
}
fn get_uid(&self) -> Option<String> {
Some(self.uid.clone())
}
}
pub(crate) type AuthClaimsJWT = biscuit::JWT<JwtOAuthPrivateClaims, biscuit::Empty>;
#[derive(Serialize, Deserialize, Default, Clone)]
pub struct JWSEntry {
#[serde(flatten)]
pub(crate) headers: biscuit::jws::RegisteredHeader,
#[serde(flatten)]
pub(crate) ne: biscuit::jwk::RSAKeyParameters,
}
#[derive(Serialize, Deserialize)]
pub struct JWKSetDTO {
pub keys: Vec<JWSEntry>,
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications.
pub fn download_google_jwks(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::blocking::Client::new()
.get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()?;
let jwk_set: JWKSetDTO = resp.json()?;
Ok(jwk_set)
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications. | .get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()
.await?;
let jwk_set: JWKSetDTO = resp.json().await?;
Ok(jwk_set)
}
/// Returns true if the access token (assumed to be a jwt) has expired
///
/// An error is returned if the given access token string is not a jwt
pub(crate) fn is_expired(
access_token: &str,
tolerance_in_minutes: i64,
) -> Result<bool, FirebaseError> {
let token = AuthClaimsJWT::new_encoded(&access_token);
let claims = token.unverified_payload()?;
if let Some(expiry) = claims.registered.expiry.as_ref() {
let diff: Duration = Utc::now().signed_duration_since(expiry.deref().clone());
return Ok(diff.num_minutes() - tolerance_in_minutes > 0);
}
Ok(true)
}
/// Returns true if the jwt was updated and needs signing
pub(crate) fn jwt_update_expiry_if(jwt: &mut AuthClaimsJWT, expire_in_minutes: i64) -> bool {
let ref mut claims = jwt.payload_mut().unwrap().registered;
let now = biscuit::Timestamp::from(Utc::now());
if let Some(issued_at) = claims.issued_at.as_ref() {
let diff: Duration = Utc::now().signed_duration_since(issued_at.deref().clone());
if diff.num_minutes() > expire_in_minutes {
claims.issued_at = Some(now);
} else {
return false;
}
} else {
claims.issued_at = Some(now);
}
true
}
pub(crate) fn create_jwt<S>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<AuthClaimsJWT, Error>
where
S: AsRef<str>,
{
let claims = JwtOAuthPrivateClaims::new(scope, client_id, user_id);
create_jwt_with_claims(credentials, duration, audience, claims)
}
pub(crate) fn create_jwt_encoded<S: AsRef<str>>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<String, Error> {
let jwt = create_jwt(credentials, scope, duration, client_id, user_id, audience)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(Error::Generic("No private key added via add_keypair_key!"))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
fn create_jwt_with_claims<T>(
credentials: &Credentials,
duration: chrono::Duration,
audience: &str,
claims: T,
) -> Result<biscuit::JWT<T, biscuit::Empty>, Error>
where
T: Serialize + DeserializeOwned,
{
use biscuit::{
jws::{Header, RegisteredHeader},
ClaimsSet, Empty, RegisteredClaims,
};
let header: Header<Empty> = Header::from(RegisteredHeader {
algorithm: SignatureAlgorithm::RS256,
key_id: Some(credentials.private_key_id.to_owned()),
..Default::default()
});
let expected_claims = ClaimsSet::<T> {
registered: RegisteredClaims {
issuer: Some(FromStr::from_str(&credentials.client_email)?),
audience: Some(SingleOrMultiple::Single(StringOrUri::from_str(audience)?)),
expiry: Some(biscuit::Timestamp::from(Utc::now().add(duration))),
subject: Some(StringOrUri::from_str(&credentials.client_email)?),
issued_at: Some(biscuit::Timestamp::from(Utc::now())),
..Default::default()
},
private: claims,
};
Ok(biscuit::JWT::new_decoded(header, expected_claims))
}
pub fn create_custom_jwt_encoded<T: PrivateClaims>(
credentials: &Credentials,
claims: T,
) -> Result<String, Error> {
let jwt = create_jwt_with_claims(
&credentials,
Duration::hours(1),
JWT_AUDIENCE_IDENTITY,
claims,
)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(FirebaseError::Generic(
"No private key added via add_keypair_key!",
))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
pub struct TokenValidationResult<T: PrivateClaims = JwtOAuthPrivateClaims> {
pub claims: T,
pub audience: String,
pub subject: String,
}
impl TokenValidationResult {
pub fn get_scopes(&self) -> HashSet<String> {
self.claims.get_scopes()
}
}
pub(crate) fn verify_access_token(
credentials: &Credentials,
access_token: &str,
) -> Result<TokenValidationResult, Error> {
verify_access_token_with_claims(credentials, access_token)
}
pub fn verify_access_token_with_claims<T: PrivateClaims | pub async fn download_google_jwks_async(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::Client::new() | random_line_split |
jwt.rs | pub static JWT_AUDIENCE_FIRESTORE: &str =
"https://firestore.googleapis.com/google.firestore.v1.Firestore";
pub static JWT_AUDIENCE_IDENTITY: &str =
"https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit";
pub trait PrivateClaims
where
Self: Serialize + DeserializeOwned + Clone + Default,
{
fn get_scopes(&self) -> HashSet<String>;
fn get_client_id(&self) -> Option<String>;
fn get_uid(&self) -> Option<String>;
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtOAuthPrivateClaims {
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub uid: Option<String>, // Probably the firebase User ID if set
}
impl JwtOAuthPrivateClaims {
pub fn new<S: AsRef<str>>(
scope: Option<Iter<S>>,
client_id: Option<String>,
user_id: Option<String>,
) -> Self {
JwtOAuthPrivateClaims {
scope: scope.and_then(|f| {
Some(f.fold(String::new(), |acc, x| {
let x: &str = x.as_ref();
return acc + x + " ";
}))
}),
client_id,
uid: user_id,
}
}
}
impl PrivateClaims for JwtOAuthPrivateClaims {
fn get_scopes(&self) -> HashSet<String> {
match self.scope {
Some(ref v) => v.split(" ").map(|f| f.to_owned()).collect(),
None => HashSet::new(),
}
}
fn get_client_id(&self) -> Option<String> {
self.client_id.clone()
}
fn get_uid(&self) -> Option<String> {
self.uid.clone()
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtCustomClaims {
pub uid: String,
pub claims: HashMap<String, Value>,
}
impl JwtCustomClaims {
pub fn new<T: Serialize>(uid: &str, claims: T) -> Self {
let dev_claims = {
let val = serde_json::to_string(&claims).unwrap_or("".to_string());
serde_json::from_str::<HashMap<String, Value>>(&val).unwrap_or_default()
};
JwtCustomClaims {
claims: dev_claims,
uid: uid.to_string(),
}
}
}
impl PrivateClaims for JwtCustomClaims {
fn get_scopes(&self) -> HashSet<String> {
HashSet::new()
}
fn get_client_id(&self) -> Option<String> {
None
}
fn get_uid(&self) -> Option<String> {
Some(self.uid.clone())
}
}
pub(crate) type AuthClaimsJWT = biscuit::JWT<JwtOAuthPrivateClaims, biscuit::Empty>;
#[derive(Serialize, Deserialize, Default, Clone)]
pub struct | {
#[serde(flatten)]
pub(crate) headers: biscuit::jws::RegisteredHeader,
#[serde(flatten)]
pub(crate) ne: biscuit::jwk::RSAKeyParameters,
}
#[derive(Serialize, Deserialize)]
pub struct JWKSetDTO {
pub keys: Vec<JWSEntry>,
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications.
pub fn download_google_jwks(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::blocking::Client::new()
.get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()?;
let jwk_set: JWKSetDTO = resp.json()?;
Ok(jwk_set)
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications.
pub async fn download_google_jwks_async(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::Client::new()
.get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()
.await?;
let jwk_set: JWKSetDTO = resp.json().await?;
Ok(jwk_set)
}
/// Returns true if the access token (assumed to be a jwt) has expired
///
/// An error is returned if the given access token string is not a jwt
pub(crate) fn is_expired(
access_token: &str,
tolerance_in_minutes: i64,
) -> Result<bool, FirebaseError> {
let token = AuthClaimsJWT::new_encoded(&access_token);
let claims = token.unverified_payload()?;
if let Some(expiry) = claims.registered.expiry.as_ref() {
let diff: Duration = Utc::now().signed_duration_since(expiry.deref().clone());
return Ok(diff.num_minutes() - tolerance_in_minutes > 0);
}
Ok(true)
}
/// Returns true if the jwt was updated and needs signing
pub(crate) fn jwt_update_expiry_if(jwt: &mut AuthClaimsJWT, expire_in_minutes: i64) -> bool {
let ref mut claims = jwt.payload_mut().unwrap().registered;
let now = biscuit::Timestamp::from(Utc::now());
if let Some(issued_at) = claims.issued_at.as_ref() {
let diff: Duration = Utc::now().signed_duration_since(issued_at.deref().clone());
if diff.num_minutes() > expire_in_minutes {
claims.issued_at = Some(now);
} else {
return false;
}
} else {
claims.issued_at = Some(now);
}
true
}
pub(crate) fn create_jwt<S>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<AuthClaimsJWT, Error>
where
S: AsRef<str>,
{
let claims = JwtOAuthPrivateClaims::new(scope, client_id, user_id);
create_jwt_with_claims(credentials, duration, audience, claims)
}
pub(crate) fn create_jwt_encoded<S: AsRef<str>>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<String, Error> {
let jwt = create_jwt(credentials, scope, duration, client_id, user_id, audience)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(Error::Generic("No private key added via add_keypair_key!"))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
fn create_jwt_with_claims<T>(
credentials: &Credentials,
duration: chrono::Duration,
audience: &str,
claims: T,
) -> Result<biscuit::JWT<T, biscuit::Empty>, Error>
where
T: Serialize + DeserializeOwned,
{
use biscuit::{
jws::{Header, RegisteredHeader},
ClaimsSet, Empty, RegisteredClaims,
};
let header: Header<Empty> = Header::from(RegisteredHeader {
algorithm: SignatureAlgorithm::RS256,
key_id: Some(credentials.private_key_id.to_owned()),
..Default::default()
});
let expected_claims = ClaimsSet::<T> {
registered: RegisteredClaims {
issuer: Some(FromStr::from_str(&credentials.client_email)?),
audience: Some(SingleOrMultiple::Single(StringOrUri::from_str(audience)?)),
expiry: Some(biscuit::Timestamp::from(Utc::now().add(duration))),
subject: Some(StringOrUri::from_str(&credentials.client_email)?),
issued_at: Some(biscuit::Timestamp::from(Utc::now())),
..Default::default()
},
private: claims,
};
Ok(biscuit::JWT::new_decoded(header, expected_claims))
}
pub fn create_custom_jwt_encoded<T: PrivateClaims>(
credentials: &Credentials,
claims: T,
) -> Result<String, Error> {
let jwt = create_jwt_with_claims(
&credentials,
Duration::hours(1),
JWT_AUDIENCE_IDENTITY,
claims,
)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(FirebaseError::Generic(
"No private key added via add_keypair_key!",
))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
pub struct TokenValidationResult<T: PrivateClaims = JwtOAuthPrivateClaims> {
pub claims: T,
pub audience: String,
pub subject: String,
}
impl TokenValidationResult {
pub fn get_scopes(&self) -> HashSet<String> {
self.claims.get_scopes()
}
}
pub(crate) fn verify_access_token(
credentials: &Credentials,
access_token: &str,
) -> Result<TokenValidationResult, Error> {
verify_access_token_with_claims(credentials, access_token)
}
pub fn verify_access_token_with_claims<T: Private | JWSEntry | identifier_name |
jwt.rs | pub static JWT_AUDIENCE_FIRESTORE: &str =
"https://firestore.googleapis.com/google.firestore.v1.Firestore";
pub static JWT_AUDIENCE_IDENTITY: &str =
"https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit";
pub trait PrivateClaims
where
Self: Serialize + DeserializeOwned + Clone + Default,
{
fn get_scopes(&self) -> HashSet<String>;
fn get_client_id(&self) -> Option<String>;
fn get_uid(&self) -> Option<String>;
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtOAuthPrivateClaims {
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub uid: Option<String>, // Probably the firebase User ID if set
}
impl JwtOAuthPrivateClaims {
pub fn new<S: AsRef<str>>(
scope: Option<Iter<S>>,
client_id: Option<String>,
user_id: Option<String>,
) -> Self {
JwtOAuthPrivateClaims {
scope: scope.and_then(|f| {
Some(f.fold(String::new(), |acc, x| {
let x: &str = x.as_ref();
return acc + x + " ";
}))
}),
client_id,
uid: user_id,
}
}
}
impl PrivateClaims for JwtOAuthPrivateClaims {
fn get_scopes(&self) -> HashSet<String> {
match self.scope {
Some(ref v) => v.split(" ").map(|f| f.to_owned()).collect(),
None => HashSet::new(),
}
}
fn get_client_id(&self) -> Option<String> {
self.client_id.clone()
}
fn get_uid(&self) -> Option<String> {
self.uid.clone()
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtCustomClaims {
pub uid: String,
pub claims: HashMap<String, Value>,
}
impl JwtCustomClaims {
pub fn new<T: Serialize>(uid: &str, claims: T) -> Self {
let dev_claims = {
let val = serde_json::to_string(&claims).unwrap_or("".to_string());
serde_json::from_str::<HashMap<String, Value>>(&val).unwrap_or_default()
};
JwtCustomClaims {
claims: dev_claims,
uid: uid.to_string(),
}
}
}
impl PrivateClaims for JwtCustomClaims {
fn get_scopes(&self) -> HashSet<String> {
HashSet::new()
}
fn get_client_id(&self) -> Option<String> {
None
}
fn get_uid(&self) -> Option<String> {
Some(self.uid.clone())
}
}
pub(crate) type AuthClaimsJWT = biscuit::JWT<JwtOAuthPrivateClaims, biscuit::Empty>;
#[derive(Serialize, Deserialize, Default, Clone)]
pub struct JWSEntry {
#[serde(flatten)]
pub(crate) headers: biscuit::jws::RegisteredHeader,
#[serde(flatten)]
pub(crate) ne: biscuit::jwk::RSAKeyParameters,
}
#[derive(Serialize, Deserialize)]
pub struct JWKSetDTO {
pub keys: Vec<JWSEntry>,
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications.
pub fn download_google_jwks(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::blocking::Client::new()
.get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()?;
let jwk_set: JWKSetDTO = resp.json()?;
Ok(jwk_set)
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications.
pub async fn download_google_jwks_async(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::Client::new()
.get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()
.await?;
let jwk_set: JWKSetDTO = resp.json().await?;
Ok(jwk_set)
}
/// Returns true if the access token (assumed to be a jwt) has expired
///
/// An error is returned if the given access token string is not a jwt
pub(crate) fn is_expired(
access_token: &str,
tolerance_in_minutes: i64,
) -> Result<bool, FirebaseError> {
let token = AuthClaimsJWT::new_encoded(&access_token);
let claims = token.unverified_payload()?;
if let Some(expiry) = claims.registered.expiry.as_ref() {
let diff: Duration = Utc::now().signed_duration_since(expiry.deref().clone());
return Ok(diff.num_minutes() - tolerance_in_minutes > 0);
}
Ok(true)
}
/// Returns true if the jwt was updated and needs signing
pub(crate) fn jwt_update_expiry_if(jwt: &mut AuthClaimsJWT, expire_in_minutes: i64) -> bool {
let ref mut claims = jwt.payload_mut().unwrap().registered;
let now = biscuit::Timestamp::from(Utc::now());
if let Some(issued_at) = claims.issued_at.as_ref() {
let diff: Duration = Utc::now().signed_duration_since(issued_at.deref().clone());
if diff.num_minutes() > expire_in_minutes {
claims.issued_at = Some(now);
} else {
return false;
}
} else {
claims.issued_at = Some(now);
}
true
}
pub(crate) fn create_jwt<S>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<AuthClaimsJWT, Error>
where
S: AsRef<str>,
{
let claims = JwtOAuthPrivateClaims::new(scope, client_id, user_id);
create_jwt_with_claims(credentials, duration, audience, claims)
}
pub(crate) fn create_jwt_encoded<S: AsRef<str>>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<String, Error> {
let jwt = create_jwt(credentials, scope, duration, client_id, user_id, audience)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(Error::Generic("No private key added via add_keypair_key!"))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
fn create_jwt_with_claims<T>(
credentials: &Credentials,
duration: chrono::Duration,
audience: &str,
claims: T,
) -> Result<biscuit::JWT<T, biscuit::Empty>, Error>
where
T: Serialize + DeserializeOwned,
{
use biscuit::{
jws::{Header, RegisteredHeader},
ClaimsSet, Empty, RegisteredClaims,
};
let header: Header<Empty> = Header::from(RegisteredHeader {
algorithm: SignatureAlgorithm::RS256,
key_id: Some(credentials.private_key_id.to_owned()),
..Default::default()
});
let expected_claims = ClaimsSet::<T> {
registered: RegisteredClaims {
issuer: Some(FromStr::from_str(&credentials.client_email)?),
audience: Some(SingleOrMultiple::Single(StringOrUri::from_str(audience)?)),
expiry: Some(biscuit::Timestamp::from(Utc::now().add(duration))),
subject: Some(StringOrUri::from_str(&credentials.client_email)?),
issued_at: Some(biscuit::Timestamp::from(Utc::now())),
..Default::default()
},
private: claims,
};
Ok(biscuit::JWT::new_decoded(header, expected_claims))
}
pub fn create_custom_jwt_encoded<T: PrivateClaims>(
credentials: &Credentials,
claims: T,
) -> Result<String, Error> {
let jwt = create_jwt_with_claims(
&credentials,
Duration::hours(1),
JWT_AUDIENCE_IDENTITY,
claims,
)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(FirebaseError::Generic(
"No private key added via add_keypair_key!",
))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
pub struct TokenValidationResult<T: PrivateClaims = JwtOAuthPrivateClaims> {
pub claims: T,
pub audience: String,
pub subject: String,
}
impl TokenValidationResult {
pub fn get_scopes(&self) -> HashSet<String> |
}
pub(crate) fn verify_access_token(
credentials: &Credentials,
access_token: &str,
) -> Result<TokenValidationResult, Error> {
verify_access_token_with_claims(credentials, access_token)
}
pub fn verify_access_token_with_claims<T: Private | {
self.claims.get_scopes()
} | identifier_body |
jwt.rs | pub static JWT_AUDIENCE_FIRESTORE: &str =
"https://firestore.googleapis.com/google.firestore.v1.Firestore";
pub static JWT_AUDIENCE_IDENTITY: &str =
"https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit";
pub trait PrivateClaims
where
Self: Serialize + DeserializeOwned + Clone + Default,
{
fn get_scopes(&self) -> HashSet<String>;
fn get_client_id(&self) -> Option<String>;
fn get_uid(&self) -> Option<String>;
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtOAuthPrivateClaims {
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub uid: Option<String>, // Probably the firebase User ID if set
}
impl JwtOAuthPrivateClaims {
pub fn new<S: AsRef<str>>(
scope: Option<Iter<S>>,
client_id: Option<String>,
user_id: Option<String>,
) -> Self {
JwtOAuthPrivateClaims {
scope: scope.and_then(|f| {
Some(f.fold(String::new(), |acc, x| {
let x: &str = x.as_ref();
return acc + x + " ";
}))
}),
client_id,
uid: user_id,
}
}
}
impl PrivateClaims for JwtOAuthPrivateClaims {
fn get_scopes(&self) -> HashSet<String> {
match self.scope {
Some(ref v) => v.split(" ").map(|f| f.to_owned()).collect(),
None => HashSet::new(),
}
}
fn get_client_id(&self) -> Option<String> {
self.client_id.clone()
}
fn get_uid(&self) -> Option<String> {
self.uid.clone()
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Default)]
pub struct JwtCustomClaims {
pub uid: String,
pub claims: HashMap<String, Value>,
}
impl JwtCustomClaims {
pub fn new<T: Serialize>(uid: &str, claims: T) -> Self {
let dev_claims = {
let val = serde_json::to_string(&claims).unwrap_or("".to_string());
serde_json::from_str::<HashMap<String, Value>>(&val).unwrap_or_default()
};
JwtCustomClaims {
claims: dev_claims,
uid: uid.to_string(),
}
}
}
impl PrivateClaims for JwtCustomClaims {
fn get_scopes(&self) -> HashSet<String> {
HashSet::new()
}
fn get_client_id(&self) -> Option<String> {
None
}
fn get_uid(&self) -> Option<String> {
Some(self.uid.clone())
}
}
pub(crate) type AuthClaimsJWT = biscuit::JWT<JwtOAuthPrivateClaims, biscuit::Empty>;
#[derive(Serialize, Deserialize, Default, Clone)]
pub struct JWSEntry {
#[serde(flatten)]
pub(crate) headers: biscuit::jws::RegisteredHeader,
#[serde(flatten)]
pub(crate) ne: biscuit::jwk::RSAKeyParameters,
}
#[derive(Serialize, Deserialize)]
pub struct JWKSetDTO {
pub keys: Vec<JWSEntry>,
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications.
pub fn download_google_jwks(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::blocking::Client::new()
.get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()?;
let jwk_set: JWKSetDTO = resp.json()?;
Ok(jwk_set)
}
/// Download the Google JWK Set for a given service account.
/// The resulting set of JWKs need to be added to a credentials object
/// for jwk verifications.
pub async fn download_google_jwks_async(account_mail: &str) -> Result<JWKSetDTO, Error> {
let resp = reqwest::Client::new()
.get(&format!(
"https://www.googleapis.com/service_accounts/v1/jwk/{}",
account_mail
))
.send()
.await?;
let jwk_set: JWKSetDTO = resp.json().await?;
Ok(jwk_set)
}
/// Returns true if the access token (assumed to be a jwt) has expired
///
/// An error is returned if the given access token string is not a jwt
pub(crate) fn is_expired(
access_token: &str,
tolerance_in_minutes: i64,
) -> Result<bool, FirebaseError> {
let token = AuthClaimsJWT::new_encoded(&access_token);
let claims = token.unverified_payload()?;
if let Some(expiry) = claims.registered.expiry.as_ref() |
Ok(true)
}
/// Returns true if the jwt was updated and needs signing
pub(crate) fn jwt_update_expiry_if(jwt: &mut AuthClaimsJWT, expire_in_minutes: i64) -> bool {
let ref mut claims = jwt.payload_mut().unwrap().registered;
let now = biscuit::Timestamp::from(Utc::now());
if let Some(issued_at) = claims.issued_at.as_ref() {
let diff: Duration = Utc::now().signed_duration_since(issued_at.deref().clone());
if diff.num_minutes() > expire_in_minutes {
claims.issued_at = Some(now);
} else {
return false;
}
} else {
claims.issued_at = Some(now);
}
true
}
pub(crate) fn create_jwt<S>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<AuthClaimsJWT, Error>
where
S: AsRef<str>,
{
let claims = JwtOAuthPrivateClaims::new(scope, client_id, user_id);
create_jwt_with_claims(credentials, duration, audience, claims)
}
pub(crate) fn create_jwt_encoded<S: AsRef<str>>(
credentials: &Credentials,
scope: Option<Iter<S>>,
duration: chrono::Duration,
client_id: Option<String>,
user_id: Option<String>,
audience: &str,
) -> Result<String, Error> {
let jwt = create_jwt(credentials, scope, duration, client_id, user_id, audience)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(Error::Generic("No private key added via add_keypair_key!"))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
fn create_jwt_with_claims<T>(
credentials: &Credentials,
duration: chrono::Duration,
audience: &str,
claims: T,
) -> Result<biscuit::JWT<T, biscuit::Empty>, Error>
where
T: Serialize + DeserializeOwned,
{
use biscuit::{
jws::{Header, RegisteredHeader},
ClaimsSet, Empty, RegisteredClaims,
};
let header: Header<Empty> = Header::from(RegisteredHeader {
algorithm: SignatureAlgorithm::RS256,
key_id: Some(credentials.private_key_id.to_owned()),
..Default::default()
});
let expected_claims = ClaimsSet::<T> {
registered: RegisteredClaims {
issuer: Some(FromStr::from_str(&credentials.client_email)?),
audience: Some(SingleOrMultiple::Single(StringOrUri::from_str(audience)?)),
expiry: Some(biscuit::Timestamp::from(Utc::now().add(duration))),
subject: Some(StringOrUri::from_str(&credentials.client_email)?),
issued_at: Some(biscuit::Timestamp::from(Utc::now())),
..Default::default()
},
private: claims,
};
Ok(biscuit::JWT::new_decoded(header, expected_claims))
}
pub fn create_custom_jwt_encoded<T: PrivateClaims>(
credentials: &Credentials,
claims: T,
) -> Result<String, Error> {
let jwt = create_jwt_with_claims(
&credentials,
Duration::hours(1),
JWT_AUDIENCE_IDENTITY,
claims,
)?;
let secret = credentials
.keys
.secret
.as_ref()
.ok_or(FirebaseError::Generic(
"No private key added via add_keypair_key!",
))?;
Ok(jwt.encode(&secret.deref())?.encoded()?.encode())
}
pub struct TokenValidationResult<T: PrivateClaims = JwtOAuthPrivateClaims> {
pub claims: T,
pub audience: String,
pub subject: String,
}
impl TokenValidationResult {
pub fn get_scopes(&self) -> HashSet<String> {
self.claims.get_scopes()
}
}
pub(crate) fn verify_access_token(
credentials: &Credentials,
access_token: &str,
) -> Result<TokenValidationResult, Error> {
verify_access_token_with_claims(credentials, access_token)
}
pub fn verify_access_token_with_claims<T: Private | {
let diff: Duration = Utc::now().signed_duration_since(expiry.deref().clone());
return Ok(diff.num_minutes() - tolerance_in_minutes > 0);
} | conditional_block |
spy.rs | Html {
match col.index {
// timestamp
0 => render_timestamp(&self.0),
// device id
1 => self.device().into(),
// payload
2 => render_data_short(&self.0),
// ignore
_ => html! {},
}
}
fn render_details(&self) -> Vec<Span> {
vec![Span::max(render_details(&self.0)).truncate()]
}
}
impl Entry {
fn device(&self) -> String {
let app_id = self.extension_as_string(EXT_APPLICATION);
let device_id = self.extension_as_string(EXT_DEVICE);
format!("{} / {}", app_id, device_id)
}
fn extension_as_string(&self, name: &str) -> String {
self.0
.extension(name)
.map(|s| match s {
ExtensionValue::String(s) => s.clone(),
ExtensionValue::Integer(i) => i.to_string(),
ExtensionValue::Boolean(true) => "true".into(),
ExtensionValue::Boolean(false) => "false".into(),
})
.unwrap_or_default()
}
}
impl Component for Spy {
type Message = Msg;
type Properties = ();
fn create(_props: Self::Properties, link: ComponentLink<Self>) -> Self {
Self {
events: Default::default(),
link,
source: None,
running: false,
total_received: 0,
application: String::new(),
}
}
fn update(&mut self, msg: Self::Message) -> ShouldRender {
match msg {
Msg::Start(app_id) => {
log::info!("Starting: {:?}", app_id);
self.start(app_id);
}
Msg::StartPressed => {
self.link.send_message(Msg::Start(self.app_id_filter()));
}
Msg::Stop => {
self.stop();
}
Msg::Event(event) => {
// log::debug!("Pushing event: {:?}", event);
self.total_received += 1;
self.events.insert(0, Entry(*event));
while self.events.len() > DEFAULT_MAX_SIZE {
self.events.pop();
}
}
Msg::Error(err) => {
error("Failed to process event", err);
}
Msg::Failed => {
error("Source error", "Failed to connect to the event source");
self.running = false;
}
Msg::SetApplication(application) => {
self.application = application;
}
}
true
}
fn change(&mut self, _props: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
let is_valid = self.app_id_filter().is_some();
let is_running = self.running;
let v = |value: &str| match value {
"" => InputState::Error,
_ => InputState::Default,
};
return html! {
<>
<PageSection variant=PageSectionVariant::Light limit_width=true>
<Content>
<Title>{"Device Message Spy"}</Title>
</Content>
</PageSection>
<PageSection>
<Toolbar>
<ToolbarGroup>
<ToolbarItem>
<TextInput
disabled=self.running
onchange=self.link.callback(|app|Msg::SetApplication(app))
validator=Validator::from(v)
placeholder="Application ID to spy on"/>
</ToolbarItem>
<ToolbarItem>
{if is_running {
html!{<Button
disabled=!is_valid
label="Stop"
icon=Icon::Pause
variant=Variant::Secondary
onclick=self.link.callback(|_|Msg::Stop)
/>}
} else {
html!{<Button
disabled=!is_valid
label="Start"
icon=Icon::Play
variant=Variant::Primary
onclick=self.link.callback(|_|Msg::StartPressed)
/>}
}}
</ToolbarItem>
</ToolbarGroup>
<ToolbarItem modifiers=vec![ToolbarElementModifier::Right.all()]>
{ if self.running { html!{
<strong>{"events received: "}{self.total_received}</strong>
} } else { html!{} } }
</ToolbarItem>
</Toolbar>
<Table<SharedTableModel<Entry>>
entries=self.events.clone()
mode=TableMode::CompactExpandable
header={html_nested!{
<TableHeader>
<TableColumn label="Timestamp (UTC)"/>
<TableColumn label="Device ID"/>
<TableColumn label="Payload"/>
</TableHeader>
}}
>
</Table<SharedTableModel<Entry>>>
{ if self.events.is_empty() {
self.render_empty()
} else {
html!{}
}}
</PageSection>
</>
};
}
fn destroy(&mut self) {
if let Some(source) = self.source.take() {
source.close();
}
}
}
impl Spy {
fn app_id_filter(&self) -> Option<String> {
let value = self.application.clone();
match value.is_empty() {
true => None,
false => Some(value),
}
}
fn start(&mut self, app_id: Option<String>) {
let mut url = Backend::url("/api/console/v1alpha1/spy").unwrap();
// add optional filter
if let Some(app_id) = &app_id {
url.query_pairs_mut().append_pair("app", app_id);
}
// EventSource doesn't support passing headers, so we cannot send
// the bearer token the normal way
url.query_pairs_mut()
.append_pair("token", &Backend::access_token().unwrap_or_default());
// create source
let source =
EventSource::new_with_event_source_init_dict(&url.to_string(), &EventSourceInit::new())
.unwrap();
// setup onmessage
let link = self.link.clone();
let on_message = Closure::wrap(Box::new(move |msg: &JsValue| {
let msg = extract_event(msg);
link.send_message(msg);
}) as Box<dyn FnMut(&JsValue)>);
source.set_onmessage(Some(&on_message.into_js_value().into()));
| let on_error = Closure::wrap(Box::new(move || {
link.send_message(Msg::Failed);
}) as Box<dyn FnMut()>);
source.set_onerror(Some(&on_error.into_js_value().into()));
// store result
self.running = true;
self.source = Some(source);
}
fn stop(&mut self) {
if let Some(source) = self.source.take() {
source.close();
}
self.running = false
}
fn render_empty(&self) -> Html {
return html! {
<div style="padding-bottom: 10rem; height: 100%;">
<Bullseye>
<EmptyState
title="No new messages"
icon=Icon::Pending
size=Size::XLarge
>
{ "The " } <q> {"message spy"} </q> { " will only show "} <strong> {"new"} </strong> {" messages received by the system.
When the next message arrives, you will see it right here." }
</EmptyState>
</Bullseye>
</div>
};
}
}
fn extract_event(msg: &JsValue) -> Msg {
// web_sys::console::debug_2(&JsValue::from("event: "), msg);
let data: String = js_sys::Reflect::get(msg, &JsValue::from("data"))
.unwrap()
.as_string()
.unwrap();
match serde_json::from_str(&data) {
Ok(event) => Msg::Event(event),
Err(e) => Msg::Error(e.to_string()),
}
}
fn render_data(event: &Event) -> Html {
// let data: Option<Data> = event.get_data();
match event.data() {
None => html! {},
Some(Data::String(text)) => html! { <pre> {text} </pre> },
Some(Data::Binary(blob)) => html! { <>
<pre> { pretty_hex::pretty_hex(&blob) } </pre>
<pre> { base64_block(&blob) } </pre>
</> },
Some(Data::Json(value)) => {
let value = serde_json::to_string_pretty(&value).unwrap();
return html! { <pre> {value} </pre> };
}
}
}
fn base64_block(input: &[u8]) -> String {
base64::encode(input)
.chars()
.collect::<Vec<_>>()
.chunks(120)
.map(|chunk| chunk.iter().collect::<String>())
.join("\n")
}
fn render_blob(blob: &[u8]) -> String {
let max = blob.len().min(25);
let ellipsis = if blob.len() > max { ", …" } else { "" };
format!("[{}; {:02x?}{}]", blob.len(), &blob[0..max], ellipsis)
}
fn truncate_str(len: usize, string: &str) -> String {
let mut r = String::new();
for c in string.graphemes(true) {
if r.len() > len || r.contains('\n') || r.contains('\r') {
r.push('…');
break;
}
r.push_str(c);
}
r
| // setup onerror
let link = self.link.clone(); | random_line_split |
spy.rs | type Properties = ();
fn create(_props: Self::Properties, link: ComponentLink<Self>) -> Self {
Self {
events: Default::default(),
link,
source: None,
running: false,
total_received: 0,
application: String::new(),
}
}
fn update(&mut self, msg: Self::Message) -> ShouldRender {
match msg {
Msg::Start(app_id) => {
log::info!("Starting: {:?}", app_id);
self.start(app_id);
}
Msg::StartPressed => {
self.link.send_message(Msg::Start(self.app_id_filter()));
}
Msg::Stop => {
self.stop();
}
Msg::Event(event) => {
// log::debug!("Pushing event: {:?}", event);
self.total_received += 1;
self.events.insert(0, Entry(*event));
while self.events.len() > DEFAULT_MAX_SIZE {
self.events.pop();
}
}
Msg::Error(err) => {
error("Failed to process event", err);
}
Msg::Failed => {
error("Source error", "Failed to connect to the event source");
self.running = false;
}
Msg::SetApplication(application) => {
self.application = application;
}
}
true
}
fn change(&mut self, _props: Self::Properties) -> ShouldRender {
false
}
fn view(&self) -> Html {
let is_valid = self.app_id_filter().is_some();
let is_running = self.running;
let v = |value: &str| match value {
"" => InputState::Error,
_ => InputState::Default,
};
return html! {
<>
<PageSection variant=PageSectionVariant::Light limit_width=true>
<Content>
<Title>{"Device Message Spy"}</Title>
</Content>
</PageSection>
<PageSection>
<Toolbar>
<ToolbarGroup>
<ToolbarItem>
<TextInput
disabled=self.running
onchange=self.link.callback(|app|Msg::SetApplication(app))
validator=Validator::from(v)
placeholder="Application ID to spy on"/>
</ToolbarItem>
<ToolbarItem>
{if is_running {
html!{<Button
disabled=!is_valid
label="Stop"
icon=Icon::Pause
variant=Variant::Secondary
onclick=self.link.callback(|_|Msg::Stop)
/>}
} else {
html!{<Button
disabled=!is_valid
label="Start"
icon=Icon::Play
variant=Variant::Primary
onclick=self.link.callback(|_|Msg::StartPressed)
/>}
}}
</ToolbarItem>
</ToolbarGroup>
<ToolbarItem modifiers=vec![ToolbarElementModifier::Right.all()]>
{ if self.running { html!{
<strong>{"events received: "}{self.total_received}</strong>
} } else { html!{} } }
</ToolbarItem>
</Toolbar>
<Table<SharedTableModel<Entry>>
entries=self.events.clone()
mode=TableMode::CompactExpandable
header={html_nested!{
<TableHeader>
<TableColumn label="Timestamp (UTC)"/>
<TableColumn label="Device ID"/>
<TableColumn label="Payload"/>
</TableHeader>
}}
>
</Table<SharedTableModel<Entry>>>
{ if self.events.is_empty() {
self.render_empty()
} else {
html!{}
}}
</PageSection>
</>
};
}
fn destroy(&mut self) {
if let Some(source) = self.source.take() {
source.close();
}
}
}
impl Spy {
fn app_id_filter(&self) -> Option<String> {
let value = self.application.clone();
match value.is_empty() {
true => None,
false => Some(value),
}
}
fn start(&mut self, app_id: Option<String>) {
let mut url = Backend::url("/api/console/v1alpha1/spy").unwrap();
// add optional filter
if let Some(app_id) = &app_id {
url.query_pairs_mut().append_pair("app", app_id);
}
// EventSource doesn't support passing headers, so we cannot send
// the bearer token the normal way
url.query_pairs_mut()
.append_pair("token", &Backend::access_token().unwrap_or_default());
// create source
let source =
EventSource::new_with_event_source_init_dict(&url.to_string(), &EventSourceInit::new())
.unwrap();
// setup onmessage
let link = self.link.clone();
let on_message = Closure::wrap(Box::new(move |msg: &JsValue| {
let msg = extract_event(msg);
link.send_message(msg);
}) as Box<dyn FnMut(&JsValue)>);
source.set_onmessage(Some(&on_message.into_js_value().into()));
// setup onerror
let link = self.link.clone();
let on_error = Closure::wrap(Box::new(move || {
link.send_message(Msg::Failed);
}) as Box<dyn FnMut()>);
source.set_onerror(Some(&on_error.into_js_value().into()));
// store result
self.running = true;
self.source = Some(source);
}
fn stop(&mut self) {
if let Some(source) = self.source.take() {
source.close();
}
self.running = false
}
fn render_empty(&self) -> Html {
return html! {
<div style="padding-bottom: 10rem; height: 100%;">
<Bullseye>
<EmptyState
title="No new messages"
icon=Icon::Pending
size=Size::XLarge
>
{ "The " } <q> {"message spy"} </q> { " will only show "} <strong> {"new"} </strong> {" messages received by the system.
When the next message arrives, you will see it right here." }
</EmptyState>
</Bullseye>
</div>
};
}
}
fn extract_event(msg: &JsValue) -> Msg {
// web_sys::console::debug_2(&JsValue::from("event: "), msg);
let data: String = js_sys::Reflect::get(msg, &JsValue::from("data"))
.unwrap()
.as_string()
.unwrap();
match serde_json::from_str(&data) {
Ok(event) => Msg::Event(event),
Err(e) => Msg::Error(e.to_string()),
}
}
fn render_data(event: &Event) -> Html {
// let data: Option<Data> = event.get_data();
match event.data() {
None => html! {},
Some(Data::String(text)) => html! { <pre> {text} </pre> },
Some(Data::Binary(blob)) => html! { <>
<pre> { pretty_hex::pretty_hex(&blob) } </pre>
<pre> { base64_block(&blob) } </pre>
</> },
Some(Data::Json(value)) => {
let value = serde_json::to_string_pretty(&value).unwrap();
return html! { <pre> {value} </pre> };
}
}
}
fn base64_block(input: &[u8]) -> String {
base64::encode(input)
.chars()
.collect::<Vec<_>>()
.chunks(120)
.map(|chunk| chunk.iter().collect::<String>())
.join("\n")
}
fn render_blob(blob: &[u8]) -> String {
let max = blob.len().min(25);
let ellipsis = if blob.len() > max { ", …" } else { "" };
format!("[{}; {:02x?}{}]", blob.len(), &blob[0..max], ellipsis)
}
fn truncate_str(len: usize, string: &str) -> String {
let mut r = String::new();
for c in string.graphemes(true) {
if r.len() > len || r.contains('\n') || r.contains('\r') {
r.push('…');
break;
}
r.push_str(c);
}
r
}
fn render_data_short(event: &Event) -> Html {
match event.data() {
None => html! {},
Some(Data::String(text)) => html! {
<pre>
<Label label="String" color=Color::Purple/>{" "}{truncate_str(100, text)}
</pre>
},
Some(Data::Binary(blob)) => html! {
<pre>
<Label label="BLOB" color=Color::Blue/>{" "}{render_blob(&blob)}
</pre>
},
Some(Data::Json(value)) => html! {
<pre>
<Label label="JSON" color=Color::Cyan/>{" "}{truncate_str(100, &value.to_string())}
</pre>
},
}
}
fn render_timestamp(event: &Event) -> Html {
event
.time()
.map(|ts| {
return html! {
<span>
<pre>{ts.format("%H:%M:%S%.3f %Y-%m-%d")}</pre>
</span>
};
})
.unwrap_or_default()
}
#[derive(Clone, Debug, PartialEq)]
struct Attr | ibuteEntry(pub | identifier_name |
|
service.rs | _cpu_usage: f64,
pub max_instances: i64,
pub instances: i64,
pub tasks: HashMap<String, String>,
}
#[derive(Debug)]
pub struct Statistic {
pub timestamp: f64,
pub cpu_time: f64,
pub cpu_usage: f64,
pub mem_usage: f64,
}
#[derive(Debug, Deserialize)]
struct TaskStatistic {
cpus_limit: f64,
cpus_system_time_secs: f64,
cpus_user_time_secs: f64,
mem_limit_bytes: i64,
mem_rss_bytes: i64,
timestamp: f64,
}
pub struct Service {
handle: Handle,
marathon_url: String,
mesos_url: String,
max_mem_usage: f64,
max_cpu_usage: f64,
multiplier: f64,
max_instances: i64,
}
impl Service {
pub fn new(handle: Handle, marathon_url: String, mesos_url: String,
max_mem_usage: f64, max_cpu_usage: f64,
multiplier: f64, max_instances: i64)
-> Service {
Service {
handle: handle,
marathon_url: marathon_url,
mesos_url: mesos_url,
max_mem_usage: max_mem_usage,
max_cpu_usage: max_cpu_usage,
multiplier: multiplier,
max_instances: max_instances,
}
}
pub fn get_apps(&mut self) -> Fut<Vec<String>> {
let url = format!("{}/v2/apps", &self.marathon_url);
self.send_get(&url).map(|body| {
let data = from_str::<Value>(&body).unwrap();
let data = data["apps"].as_array().unwrap();
let mut apps = Vec::new();
for x in data.iter() {
let id = x["id"].as_str().unwrap();
apps.push(id[1..].to_string());
}
apps
}).boxed()
}
pub fn get_app(&mut self, app: &str) -> Fut<Option<App>> {
let url = format!("{}/v2/apps/{}", &self.marathon_url, &app);
let app = app.to_string();
let mut max_instances = self.max_instances.clone();
let mut max_mem_usage = self.max_mem_usage.clone();
let mut max_cpu_usage = self.max_cpu_usage.clone();
self.send_get(&url).map(move |body| {
let data = from_str::<Value>(&body).unwrap();
let instances = data.pointer("/app/instances").unwrap();
let instances = instances.as_i64().unwrap();
let labels = data.pointer("/app/labels").unwrap();
let labels = labels.as_object().unwrap();
for (label, value) in labels {
match (label.as_ref(), value) {
("AUTOSCALE_MAX_INSTANCES", v) => {
max_instances = from_value(v.clone()).unwrap();
}
("AUTOSCALE_MEM_PERCENT", v) => {
max_mem_usage = from_value(v.clone()).unwrap();
}
("AUTOSCALE_CPU_PERCENT", v) => {
max_cpu_usage = from_value(v.clone()).unwrap();
}
_ => {}
}
}
let xs = data.pointer("/app/tasks").unwrap();
let xs = xs.as_array().unwrap();
let mut tasks = HashMap::new();
for x in xs.iter() {
let id = x["id"].as_str().unwrap();
let slave_id = x["slaveId"].as_str().unwrap();
tasks.insert(id.clone().to_string(),
slave_id.clone().to_string());
}
Some(App {
name: app,
max_instances: max_instances,
max_mem_usage: max_mem_usage,
max_cpu_usage: max_cpu_usage,
instances: instances,
tasks: tasks,
})
}).boxed()
}
pub fn get_slaves(&mut self) -> Fut<HashMap<String, String>> {
let url = format!("{}/master/slaves", &self.mesos_url);
self.send_get(&url).map(|body| {
let data = from_str::<Value>(&body).unwrap();
let data = data["slaves"].as_array().unwrap();
let mut slaves = HashMap::new();
for slave in data.iter() {
let id = slave["id"].as_str().unwrap();
let hostname = slave["hostname"].as_str().unwrap();
let port = slave["port"].as_i64().unwrap();
let addr = format!("{}:{}", hostname, port);
slaves.insert(id.clone().to_string(), addr.to_string());
}
slaves
}).boxed()
}
pub fn get_statistic(&mut self, app: &App,
slaves: &HashMap<String, String>,
prev: Option<&Statistic>)
-> Fut<Statistic> {
let mut futs = Vec::new();
for (id, slave_id) in &app.tasks {
let url = slaves.get::<String>(&slave_id).unwrap().to_string();
futs.push(self.get_task_statistic(url, id));
}
let mut prev_timestamp = 0.0;
let mut prev_cpu_time = 0.0;
if let Some(p) = prev {
prev_timestamp = p.timestamp;
prev_cpu_time = p.cpu_time;
}
futures::collect(futs).map(move |tasks| {
let mut mems: Vec<f64> = Vec::new();
let mut cpus: Vec<f64> = Vec::new(); | if task.is_none() {
continue;
}
let task = task.unwrap();
timestamp = task.timestamp;
cpus.push(task.cpus_user_time_secs + task.cpus_system_time_secs);
mems.push(100.0 * task.mem_rss_bytes as f64 /
task.mem_limit_bytes as f64);
}
let mem_usage = mems.iter()
.fold(0.0, |a, &b| a + b) / mems.len() as f64;
let cpu_time = cpus.iter()
.fold(0.0, |a, &b| a + b) / cpus.len() as f64;
let sampling_duration = timestamp - prev_timestamp;
let cpu_time_usage = cpu_time - prev_cpu_time;
let cpu_usage = cpu_time_usage / sampling_duration * 100.0;
Statistic {
timestamp: timestamp,
cpu_time: cpu_time,
mem_usage: mem_usage,
cpu_usage: cpu_usage,
}
}).boxed()
}
pub fn scale(&mut self, app: &App) -> Fut<()> {
let instances = (app.instances as f64 * self.multiplier).ceil() as i64;
if instances > app.max_instances {
info!("Cannot scale {}, reached maximum instances of: {}",
app.name, app.max_instances);
return futures::done(Ok(())).boxed();
}
let url = format!("{}/v2/apps/{}", &self.marathon_url, &app.name);
let body = format!(r#"{{"instances": {}}}"#, instances);
let session = Session::new(self.handle.clone());
let mut req = Easy::new();
req.url(&url).unwrap();
req.put(true).unwrap();
let mut list = List::new();
list.append("Content-Type: application/json").unwrap();
req.http_headers(list).unwrap();
req.post_field_size(body.as_bytes().len() as u64).unwrap();
req.read_function(move |buf| {
let mut data = body.as_bytes();
Ok(data.read(buf).unwrap_or(0))
}).unwrap();
session.perform(req).map(|mut r| {
info!("Scaling response code: {}", r.response_code().unwrap());
}).boxed()
}
fn get_task_statistic(&mut self, slave: String, id: &str)
-> Fut<Option<TaskStatistic>> {
let url = format!("http://{}/monitor/statistics", &slave);
let id = id.to_string();
self.send_get(&url).map(move |body| {
let data = from_str::<Value>(&body).unwrap();
let data = data.as_array().unwrap();
data.iter().find(|x| {
x["executor_id"].as_str().unwrap() == id
}).map(|x| {
from_value(x["statistics"].clone()).unwrap()
})
}).boxed()
}
fn send_get(&mut self, url: &str) -> Fut<String> {
let session = Session::new(self.handle.clone());
let response = Arc::new(Mutex::new(Vec::new()));
let headers = Arc::new(Mutex::new(Vec::new()));
let mut req = Easy::new();
req.get(true).unwrap();
req.url(url).unwrap();
let response2 = response.clone();
req.write_function(move |data| {
response2.lock().unwrap().extend_from_slice(data);
Ok(data.len())
}).unwrap();
let headers2 = headers.clone();
req.header_function(move |header| {
headers2.lock().unwrap().push(header.to_vec());
true
}).unwrap();
session.perform(req).map(move |_| {
let response = response.lock().unwrap();
let response = String::from_utf8_lossy(&response);
response.into | let mut timestamp: f64 = 0.0;
for task in tasks { | random_line_split |
service.rs | _usage: f64,
pub max_instances: i64,
pub instances: i64,
pub tasks: HashMap<String, String>,
}
#[derive(Debug)]
pub struct Statistic {
pub timestamp: f64,
pub cpu_time: f64,
pub cpu_usage: f64,
pub mem_usage: f64,
}
#[derive(Debug, Deserialize)]
struct TaskStatistic {
cpus_limit: f64,
cpus_system_time_secs: f64,
cpus_user_time_secs: f64,
mem_limit_bytes: i64,
mem_rss_bytes: i64,
timestamp: f64,
}
pub struct Service {
handle: Handle,
marathon_url: String,
mesos_url: String,
max_mem_usage: f64,
max_cpu_usage: f64,
multiplier: f64,
max_instances: i64,
}
impl Service {
pub fn new(handle: Handle, marathon_url: String, mesos_url: String,
max_mem_usage: f64, max_cpu_usage: f64,
multiplier: f64, max_instances: i64)
-> Service {
Service {
handle: handle,
marathon_url: marathon_url,
mesos_url: mesos_url,
max_mem_usage: max_mem_usage,
max_cpu_usage: max_cpu_usage,
multiplier: multiplier,
max_instances: max_instances,
}
}
pub fn get_apps(&mut self) -> Fut<Vec<String>> {
let url = format!("{}/v2/apps", &self.marathon_url);
self.send_get(&url).map(|body| {
let data = from_str::<Value>(&body).unwrap();
let data = data["apps"].as_array().unwrap();
let mut apps = Vec::new();
for x in data.iter() {
let id = x["id"].as_str().unwrap();
apps.push(id[1..].to_string());
}
apps
}).boxed()
}
pub fn get_app(&mut self, app: &str) -> Fut<Option<App>> {
let url = format!("{}/v2/apps/{}", &self.marathon_url, &app);
let app = app.to_string();
let mut max_instances = self.max_instances.clone();
let mut max_mem_usage = self.max_mem_usage.clone();
let mut max_cpu_usage = self.max_cpu_usage.clone();
self.send_get(&url).map(move |body| {
let data = from_str::<Value>(&body).unwrap();
let instances = data.pointer("/app/instances").unwrap();
let instances = instances.as_i64().unwrap();
let labels = data.pointer("/app/labels").unwrap();
let labels = labels.as_object().unwrap();
for (label, value) in labels {
match (label.as_ref(), value) {
("AUTOSCALE_MAX_INSTANCES", v) => {
max_instances = from_value(v.clone()).unwrap();
}
("AUTOSCALE_MEM_PERCENT", v) => {
max_mem_usage = from_value(v.clone()).unwrap();
}
("AUTOSCALE_CPU_PERCENT", v) => {
max_cpu_usage = from_value(v.clone()).unwrap();
}
_ => {}
}
}
let xs = data.pointer("/app/tasks").unwrap();
let xs = xs.as_array().unwrap();
let mut tasks = HashMap::new();
for x in xs.iter() {
let id = x["id"].as_str().unwrap();
let slave_id = x["slaveId"].as_str().unwrap();
tasks.insert(id.clone().to_string(),
slave_id.clone().to_string());
}
Some(App {
name: app,
max_instances: max_instances,
max_mem_usage: max_mem_usage,
max_cpu_usage: max_cpu_usage,
instances: instances,
tasks: tasks,
})
}).boxed()
}
pub fn get_slaves(&mut self) -> Fut<HashMap<String, String>> {
let url = format!("{}/master/slaves", &self.mesos_url);
self.send_get(&url).map(|body| {
let data = from_str::<Value>(&body).unwrap();
let data = data["slaves"].as_array().unwrap();
let mut slaves = HashMap::new();
for slave in data.iter() {
let id = slave["id"].as_str().unwrap();
let hostname = slave["hostname"].as_str().unwrap();
let port = slave["port"].as_i64().unwrap();
let addr = format!("{}:{}", hostname, port);
slaves.insert(id.clone().to_string(), addr.to_string());
}
slaves
}).boxed()
}
pub fn get_statistic(&mut self, app: &App,
slaves: &HashMap<String, String>,
prev: Option<&Statistic>)
-> Fut<Statistic> |
for task in tasks {
if task.is_none() {
continue;
}
let task = task.unwrap();
timestamp = task.timestamp;
cpus.push(task.cpus_user_time_secs + task.cpus_system_time_secs);
mems.push(100.0 * task.mem_rss_bytes as f64 /
task.mem_limit_bytes as f64);
}
let mem_usage = mems.iter()
.fold(0.0, |a, &b| a + b) / mems.len() as f64;
let cpu_time = cpus.iter()
.fold(0.0, |a, &b| a + b) / cpus.len() as f64;
let sampling_duration = timestamp - prev_timestamp;
let cpu_time_usage = cpu_time - prev_cpu_time;
let cpu_usage = cpu_time_usage / sampling_duration * 100.0;
Statistic {
timestamp: timestamp,
cpu_time: cpu_time,
mem_usage: mem_usage,
cpu_usage: cpu_usage,
}
}).boxed()
}
pub fn scale(&mut self, app: &App) -> Fut<()> {
let instances = (app.instances as f64 * self.multiplier).ceil() as i64;
if instances > app.max_instances {
info!("Cannot scale {}, reached maximum instances of: {}",
app.name, app.max_instances);
return futures::done(Ok(())).boxed();
}
let url = format!("{}/v2/apps/{}", &self.marathon_url, &app.name);
let body = format!(r#"{{"instances": {}}}"#, instances);
let session = Session::new(self.handle.clone());
let mut req = Easy::new();
req.url(&url).unwrap();
req.put(true).unwrap();
let mut list = List::new();
list.append("Content-Type: application/json").unwrap();
req.http_headers(list).unwrap();
req.post_field_size(body.as_bytes().len() as u64).unwrap();
req.read_function(move |buf| {
let mut data = body.as_bytes();
Ok(data.read(buf).unwrap_or(0))
}).unwrap();
session.perform(req).map(|mut r| {
info!("Scaling response code: {}", r.response_code().unwrap());
}).boxed()
}
fn get_task_statistic(&mut self, slave: String, id: &str)
-> Fut<Option<TaskStatistic>> {
let url = format!("http://{}/monitor/statistics", &slave);
let id = id.to_string();
self.send_get(&url).map(move |body| {
let data = from_str::<Value>(&body).unwrap();
let data = data.as_array().unwrap();
data.iter().find(|x| {
x["executor_id"].as_str().unwrap() == id
}).map(|x| {
from_value(x["statistics"].clone()).unwrap()
})
}).boxed()
}
fn send_get(&mut self, url: &str) -> Fut<String> {
let session = Session::new(self.handle.clone());
let response = Arc::new(Mutex::new(Vec::new()));
let headers = Arc::new(Mutex::new(Vec::new()));
let mut req = Easy::new();
req.get(true).unwrap();
req.url(url).unwrap();
let response2 = response.clone();
req.write_function(move |data| {
response2.lock().unwrap().extend_from_slice(data);
Ok(data.len())
}).unwrap();
let headers2 = headers.clone();
req.header_function(move |header| {
headers2.lock().unwrap().push(header.to_vec());
true
}).unwrap();
session.perform(req).map(move |_| {
let response = response.lock().unwrap();
let response = String::from_utf8_lossy(&response);
response | {
let mut futs = Vec::new();
for (id, slave_id) in &app.tasks {
let url = slaves.get::<String>(&slave_id).unwrap().to_string();
futs.push(self.get_task_statistic(url, id));
}
let mut prev_timestamp = 0.0;
let mut prev_cpu_time = 0.0;
if let Some(p) = prev {
prev_timestamp = p.timestamp;
prev_cpu_time = p.cpu_time;
}
futures::collect(futs).map(move |tasks| {
let mut mems: Vec<f64> = Vec::new();
let mut cpus: Vec<f64> = Vec::new();
let mut timestamp: f64 = 0.0; | identifier_body |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.