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 |
|---|---|---|---|---|
texture.rs | 112, 104, 218, 246, 97, 228, 251,
34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249,
14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115,
121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72,
243, 141, 128, 195, 78, 66, 215, 61, 156, 180
];
pub type TextureFloat = Textures<Float, Float>;
pub type TextureSpec = Textures<Spectrum, Spectrum>;
#[enum_dispatch]
pub trait Texture<T2> {
fn evaluate(&self, s: &SurfaceInteraction) -> T2;
}
// All Texture generic types must implement these traits
pub trait SpectrumT<T>:
Copy +
Send +
Sync +
num::Zero +
Clampable +
AddAssign +
From<Float> +
From<SampledSpectrum> +
From<RGBSpectrum> +
Mul<T, Output = T> +
Mul<Float, Output = T> +
Div<Float, Output = T> +
Add<T, Output = T>{}
// Implementations for valid Texture generic types
impl SpectrumT<Float> for Float{}
impl SpectrumT<RGBSpectrum> for RGBSpectrum{}
impl SpectrumT<SampledSpectrum> for SampledSpectrum{}
#[enum_dispatch(Texture<T2>)]
pub enum Textures<T1, T2>
where T1: SpectrumT<T1> + Mul<T2, Output = T2>,
T2: SpectrumT<T2> + From<T1>
{
MarbleTexture,
UVTexture,
FBmTexture,
WrinkledTexture,
WindyTexture,
MixTexture(MixTexture<T2>),
BilerTexture(BilerTexture<T2>),
ScaleTexture(ScaleTexture<T1, T2>),
DotsTexture(DotsTexture<T2>),
ImageTextureFloat(ImageTextureFloat),
ImageTextureRGB(ImageTextureRGB),
ConstantTexture(ConstantTexture<T2>),
Checkerboard2DTexture(Checkerboard2DTexture<T2>),
Checkerboard3DTexture(Checkerboard3DTexture<T2>)
}
#[enum_dispatch]
pub trait TextureMapping2D {
fn map(&self, si: &SurfaceInteraction,
dstdx: &mut Vector2f, dstdy: &mut Vector2f) -> Point2f;
}
#[enum_dispatch(TextureMapping2D)]
pub enum TextureMapping2Ds {
UVMapping2D,
PlannarMapping2D,
SphericalMapping2D,
CylindricalMapping2D
}
pub struct UVMapping2D {
su: Float,
sv: Float,
du: Float,
dv: Float,
}
impl UVMapping2D {
pub fn new(su: Float, sv: Float, du: Float, dv: Float) -> Self {
Self { su, sv, du, dv }
}
}
impl TextureMapping2D for UVMapping2D {
fn map(&self, si: &SurfaceInteraction,
dstdx: &mut Vector2f, dstdy: &mut Vector2f) -> Point2f {
// Compute texture differentials for sphere (u, v) mapping
*dstdx = Vector2f::new(self.su * si.dudx.get() , self.sv * si.dvdx.get());
*dstdy = Vector2f::new(self.su * si.dudy.get(), self.sv * si.dvdy.get());
Point2f::new(self.su * si.uv[0] + self.du, self.sv * si.uv[1] + self.dv)
}
}
impl Default for UVMapping2D {
fn default() -> Self {
Self {
su: 1.0,
sv: 1.0,
du: 0.0,
dv: 0.0
}
}
}
pub struct SphericalMapping2D {
world_to_texture: Transform
}
impl SphericalMapping2D {
pub fn new(wtt: &Transform) -> Self {
Self { world_to_texture: *wtt }
}
fn sphere(&self, p: &Point3f) -> Point2f {
let vec = (
self.world_to_texture.transform_point(p) -
Point3f::new(0.0, 0.0, 0.0))
.normalize();
let theta = spherical_theta(&vec);
let phi = spherical_phi(&vec);
Point2f::new(theta * INV_PI, phi * INV2_PI)
}
}
impl TextureMapping2D for SphericalMapping2D {
fn map(&self, si: &SurfaceInteraction, dstdx: &mut Vector2f,
dstdy: &mut Vector2f) -> Point2f {
let st = self.sphere(&si.p);
// Compute texture coordinate differentials for sphere (u, v) mapping
let delta = 0.1;
let st_deltax = self.sphere(&(si.p + si.dpdx.get() * delta));
*dstdx = (st_deltax - st) / delta;
let st_deltay = self.sphere(&(si.p + si.dpdy.get() * delta));
*dstdy = (st_deltay - st) / delta;
// Handle sphere mapping discontinuity for coordinate differentials
if dstdx[1] > 0.5 { dstdx[1] = 1.0 - dstdx[1]; }
else if (*dstdx)[1] < -0.5 { (*dstdx)[1] = -((*dstdx)[1] + 1.0); }
if dstdy[1] > 0.5 { dstdy[1] = 1.0 - dstdy[1]; }
else if dstdy[1] < -0.5 { dstdy[1] = -(dstdy[1] + 1.0); }
st
}
}
pub struct CylindricalMapping2D {
world_to_texture: Transform
}
impl CylindricalMapping2D {
pub fn new(wtt: &Transform) -> Self {
Self { world_to_texture: *wtt }
}
fn cylinder(&self, p: &Point3f) -> Point2f {
let vec = (
self.world_to_texture.transform_point(p) -
Point3f::new(0.0, 0.0, 0.0))
.normalize();
Point2f::new(PI + vec.y.atan2(vec.x) * INV2_PI, vec.z)
}
}
impl TextureMapping2D for CylindricalMapping2D {
fn map(&self, si: &SurfaceInteraction,
dstdx: &mut Vector2f, dstdy: &mut Vector2f) -> Point2f {
let st = self.cylinder(&si.p);
// Compute texture coordinate differentials for cylinder (u, v) mapping
let delta = 0.1;
let st_deltax = self.cylinder(&(si.p + si.dpdx.get() * delta));
*dstdx = (st_deltax - st) / delta;
let st_deltay = self.cylinder(&(si.p + si.dpdy.get() * delta));
*dstdy = (st_deltay - st) / delta;
// Handle sphere mapping discontinuity for coordinate differentials
if dstdx[1] > 0.5 { dstdx[1] = 1.0 - dstdx[1]; }
else if (*dstdx)[1] < -0.5 { (*dstdx)[1] = -((*dstdx)[1] + 1.0); }
if dstdy[1] > 0.5 { dstdy[1] = 1.0 - dstdy[1]; }
else if dstdy[1] < -0.5 { dstdy[1] = -(dstdy[1] + 1.0); }
st
}
}
pub struct PlannarMapping2D {
vs: Vector3f,
vt: Vector3f,
ds: Float,
dt: Float
}
impl PlannarMapping2D {
pub fn | new | identifier_name | |
texture.rs | 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66,
215, 61, 156, 180, 151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194,
233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6,
148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32,
57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74,
165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60,
211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25,
63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135,
130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226,
250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59,
227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2,
44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19,
98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251,
34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249,
14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115,
121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72,
243, 141, 128, 195, 78, 66, 215, 61, 156, 180
];
pub type TextureFloat = Textures<Float, Float>;
pub type TextureSpec = Textures<Spectrum, Spectrum>;
#[enum_dispatch]
pub trait Texture<T2> {
fn evaluate(&self, s: &SurfaceInteraction) -> T2;
}
// All Texture generic types must implement these traits
pub trait SpectrumT<T>:
Copy +
Send +
Sync +
num::Zero +
Clampable +
AddAssign +
From<Float> +
From<SampledSpectrum> +
From<RGBSpectrum> +
Mul<T, Output = T> +
Mul<Float, Output = T> +
Div<Float, Output = T> +
Add<T, Output = T>{}
// Implementations for valid Texture generic types
impl SpectrumT<Float> for Float{}
impl SpectrumT<RGBSpectrum> for RGBSpectrum{}
impl SpectrumT<SampledSpectrum> for SampledSpectrum{}
#[enum_dispatch(Texture<T2>)]
pub enum Textures<T1, T2>
where T1: SpectrumT<T1> + Mul<T2, Output = T2>,
T2: SpectrumT<T2> + From<T1>
{
MarbleTexture,
UVTexture,
FBmTexture,
WrinkledTexture,
WindyTexture,
MixTexture(MixTexture<T2>),
BilerTexture(BilerTexture<T2>),
ScaleTexture(ScaleTexture<T1, T2>),
DotsTexture(DotsTexture<T2>),
ImageTextureFloat(ImageTextureFloat),
ImageTextureRGB(ImageTextureRGB),
ConstantTexture(ConstantTexture<T2>),
Checkerboard2DTexture(Checkerboard2DTexture<T2>),
Checkerboard3DTexture(Checkerboard3DTexture<T2>)
}
#[enum_dispatch]
pub trait TextureMapping2D {
fn map(&self, si: &SurfaceInteraction,
dstdx: &mut Vector2f, dstdy: &mut Vector2f) -> Point2f;
}
#[enum_dispatch(TextureMapping2D)]
pub enum TextureMapping2Ds {
UVMapping2D,
PlannarMapping2D,
SphericalMapping2D,
CylindricalMapping2D
}
pub struct UVMapping2D {
su: Float,
sv: Float,
du: Float,
dv: Float,
}
impl UVMapping2D {
pub fn new(su: Float, sv: Float, du: Float, dv: Float) -> Self |
}
impl TextureMapping2D for UVMapping2D {
fn map(&self, si: &SurfaceInteraction,
dstdx: &mut Vector2f, dstdy: &mut Vector2f) -> Point2f {
// Compute texture differentials for sphere (u, v) mapping
*dstdx = Vector2f::new(self.su * si.dudx.get() , self.sv * si.dvdx.get());
*dstdy = Vector2f::new(self.su * si.dudy.get(), self.sv * si.dvdy.get());
Point2f::new(self.su * si.uv[0] + self.du, self.sv * si.uv[1] + self.dv)
}
}
impl Default for UVMapping2D {
fn default() -> Self {
| {
Self { su, sv, du, dv }
} | identifier_body |
batches.rs | author(crate_authors!("\n"))
.about("Handles the maintance work for karmator")
.subcommand(
Command::new("runs")
.about("Detect runs of votes")
.arg(
Arg::new("min")
.short('m')
.help("Min count of runs before outputting")
.default_value("20")
.value_parser(value_parser!(u32).range(1..)),
)
.arg(
Arg::new("delete")
.long("delete")
.help("Delete the runs detected")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("FILE")
.help("Database file to operate on")
.required(true),
),
)
.subcommand(
Command::new("prune")
.about("Prune and pack up old backups")
.arg(
Arg::new("delete")
.long("delete")
.help("Delete the old files")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("skip")
.long("skip")
.help("Skip compacting old files")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("BACKUPS")
.help("Backup directory to prune")
.required(true),
),
)
.get_matches();
match matches.subcommand() {
Some(("runs", m)) => {
let filename = m.get_one::<String>("FILE").unwrap();
let min = m.get_one::<u32>("min").unwrap();
let delete = m.contains_id("delete");
run(filename, *min, delete)
},
Some(("prune", m)) => {
let directory = m.get_one::<String>("BACKUPS").unwrap();
let delete = m.contains_id("delete");
let skip = m.contains_id("skip");
prune(directory, delete, skip)
}
_ => {
println!("meh do --help yourself");
Ok(())
},
}.unwrap();
}
#[derive(Debug, Clone)]
struct Vote {
id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
}
impl PartialEq for Vote {
fn eq(&self, other: &Self) -> bool {
(self.by_whom_name == other.by_whom_name)
&& (self.for_what_name == other.for_what_name)
&& (self.amount == other.amount)
}
}
#[derive(Debug)]
struct RunVal {
oldest_id: i32,
newest_id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
count: u32,
}
fn get_run_val(srv: &Vote, pv: &Vote, count: u32) -> RunVal {
RunVal {
oldest_id: srv.id,
newest_id: pv.id,
by_whom_name: srv.by_whom_name.clone(),
for_what_name: srv.for_what_name.clone(),
amount: srv.amount,
count: count,
}
}
fn str_amount(amount: i8) -> &'static str {
match amount {
-1 => "Down",
0 => "Side",
1 => "Up",
_ => panic!("invalid amount"),
}
}
fn run(filename: &str, min: u32, delete: bool) -> Result<(), Box<dyn Error>> {
let conn =
rs::Connection::open_with_flags(Path::new(filename), rs::OpenFlags::SQLITE_OPEN_READ_WRITE)
.expect(&format!("Connection error: {}", filename));
let mut stmt = conn.prepare("SELECT id, by_whom_name, for_what_name, amount FROM votes")?;
let vote_iter = stmt.query_map(rs::params![], |row| {
Ok(Vote {
id: row.get(0)?,
by_whom_name: row.get(1)?,
for_what_name: row.get(2)?,
amount: row.get(3)?,
})
})?;
// Time to compute the run
let mut runs = Vec::new();
let mut start_run_vote = None;
let mut prev_vote = None;
let mut count = 0;
for rvote in vote_iter {
let vote = rvote?;
match (&start_run_vote, &prev_vote) {
(None, None) => {
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
(Some(srv), Some(pv)) => {
if pv == &vote {
// Current vote + prev vote are the same, inc prev vote
prev_vote = Some(vote);
count += 1;
} else {
// Current vote != prev vote, record the run, and reset
runs.push(get_run_val(srv, pv, count));
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
}
(_, _) => panic!("Shouldn't happen"),
};
}
// Record the last run
runs.push(get_run_val(
&start_run_vote.unwrap(),
&prev_vote.unwrap(),
count,
));
if delete {
// Scan and delete the offenders
let mut stmt = conn.prepare("DELETE FROM votes WHERE id >= ? and id <= ?")?;
for r in &runs {
if r.count > min {
let deleted = stmt.execute(rs::params![r.oldest_id, r.newest_id])?;
if (r.count as usize) != deleted {
panic!("Expected: {} to be deleted, got {}", r.count, deleted);
}
}
}
} else {
// Now we can scan for anything that > min and print them
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
"start_id", "end_id", "by_whom_name", "for_what_name", "amount", "count"
);
for r in &runs {
if r.count > min {
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
r.oldest_id,
r.newest_id,
r.by_whom_name,
r.for_what_name,
str_amount(r.amount),
r.count
);
}
}
}
Ok(())
}
fn prune(directory: &str, delete: bool, skip: bool) -> Result<(), Box<dyn Error>> {
let now: DateTime<Local> = Local::now();
let year = now.year();
let month = now.month();
// Fetch a set of all of the files
let all_files = collect_glob(directory, "/db-backup-????-??-??.sqlite.zst");
// Fetch a set of all of the file in the current month+year
let current_month_year = collect_glob(directory, &format!("/db-backup-{}-{:02}-??.sqlite.zst", year, month));
// Fetch a set of all of the file that is in previous year + first of the month
let previous_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year - 1));
// Fetch a set of all of the file that is in current year + first of the month
let current_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year));
// Calculate the initial set of files to prune
let mut delete_files = delete_set(&all_files, vec![¤t_month_year, &previous_first_month, ¤t_first_month]);
// Compact pfm + cfm into their years
if skip {
println!("Compacting: Skipped");
} else {
if previous_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year-1);
print_compact(&previous_first_month, &tarfile)?;
delete_files.extend(previous_first_month.iter().map(|e| e.clone()));
}
if current_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year);
print_compact(¤t_first_month, &tarfile)?;
delete_files.extend(current_first_month.iter().map(|e| e.clone()));
}
}
// List the files we are going to delete
print_delete(&delete_files, delete)?;
Ok(())
}
fn collect_glob(directory: &str, glob_str: &str) -> HashSet<OsString> {
glob(&(directory.to_string() + glob_str)).unwrap()
.flatten()
.map(|e| e.into_os_string())
.collect::<HashSet<OsString>>()
}
fn delete_set(all: &HashSet<OsString>, keep: Vec<&HashSet<OsString>>) -> HashSet<OsString> {
let mut delete = all.clone();
for hs in keep {
let out = delete.difference(&hs).map(|e| e.clone()).collect();
delete = out;
}
delete
}
fn | compact | identifier_name | |
batches.rs | _version!())
.author(crate_authors!("\n"))
.about("Handles the maintance work for karmator")
.subcommand(
Command::new("runs")
.about("Detect runs of votes")
.arg(
Arg::new("min")
.short('m')
.help("Min count of runs before outputting")
.default_value("20")
.value_parser(value_parser!(u32).range(1..)),
)
.arg(
Arg::new("delete")
.long("delete")
.help("Delete the runs detected")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("FILE")
.help("Database file to operate on")
.required(true),
),
)
.subcommand(
Command::new("prune")
.about("Prune and pack up old backups")
.arg(
Arg::new("delete")
.long("delete")
.help("Delete the old files")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("skip")
.long("skip")
.help("Skip compacting old files")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("BACKUPS")
.help("Backup directory to prune")
.required(true),
),
)
.get_matches();
match matches.subcommand() {
Some(("runs", m)) => {
let filename = m.get_one::<String>("FILE").unwrap();
let min = m.get_one::<u32>("min").unwrap();
let delete = m.contains_id("delete");
run(filename, *min, delete)
},
Some(("prune", m)) => {
let directory = m.get_one::<String>("BACKUPS").unwrap();
let delete = m.contains_id("delete");
let skip = m.contains_id("skip");
prune(directory, delete, skip)
}
_ => {
println!("meh do --help yourself");
Ok(())
},
}.unwrap();
}
#[derive(Debug, Clone)]
struct Vote {
id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
}
impl PartialEq for Vote {
fn eq(&self, other: &Self) -> bool {
(self.by_whom_name == other.by_whom_name)
&& (self.for_what_name == other.for_what_name)
&& (self.amount == other.amount)
}
}
#[derive(Debug)]
struct RunVal {
oldest_id: i32,
newest_id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
count: u32,
}
fn get_run_val(srv: &Vote, pv: &Vote, count: u32) -> RunVal {
RunVal {
oldest_id: srv.id,
newest_id: pv.id,
by_whom_name: srv.by_whom_name.clone(),
for_what_name: srv.for_what_name.clone(),
amount: srv.amount,
count: count,
}
}
fn str_amount(amount: i8) -> &'static str {
match amount {
-1 => "Down",
0 => "Side",
1 => "Up",
_ => panic!("invalid amount"),
}
}
fn run(filename: &str, min: u32, delete: bool) -> Result<(), Box<dyn Error>> {
let conn =
rs::Connection::open_with_flags(Path::new(filename), rs::OpenFlags::SQLITE_OPEN_READ_WRITE)
.expect(&format!("Connection error: {}", filename));
let mut stmt = conn.prepare("SELECT id, by_whom_name, for_what_name, amount FROM votes")?;
let vote_iter = stmt.query_map(rs::params![], |row| {
Ok(Vote {
id: row.get(0)?,
by_whom_name: row.get(1)?,
for_what_name: row.get(2)?,
amount: row.get(3)?,
})
})?;
// Time to compute the run
let mut runs = Vec::new();
let mut start_run_vote = None;
let mut prev_vote = None;
let mut count = 0;
for rvote in vote_iter {
let vote = rvote?;
match (&start_run_vote, &prev_vote) {
(None, None) => {
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
(Some(srv), Some(pv)) => {
if pv == &vote {
// Current vote + prev vote are the same, inc prev vote
prev_vote = Some(vote);
count += 1;
} else {
// Current vote != prev vote, record the run, and reset
runs.push(get_run_val(srv, pv, count));
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
}
(_, _) => panic!("Shouldn't happen"),
};
}
// Record the last run
runs.push(get_run_val(
&start_run_vote.unwrap(),
&prev_vote.unwrap(),
count,
));
if delete {
// Scan and delete the offenders
let mut stmt = conn.prepare("DELETE FROM votes WHERE id >= ? and id <= ?")?;
for r in &runs {
if r.count > min {
let deleted = stmt.execute(rs::params![r.oldest_id, r.newest_id])?;
if (r.count as usize) != deleted {
panic!("Expected: {} to be deleted, got {}", r.count, deleted);
}
}
}
} else {
// Now we can scan for anything that > min and print them
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
"start_id", "end_id", "by_whom_name", "for_what_name", "amount", "count"
);
for r in &runs {
if r.count > min {
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
r.oldest_id,
r.newest_id,
r.by_whom_name,
r.for_what_name,
str_amount(r.amount),
r.count
);
}
}
}
Ok(())
}
fn prune(directory: &str, delete: bool, skip: bool) -> Result<(), Box<dyn Error>> {
let now: DateTime<Local> = Local::now();
let year = now.year();
let month = now.month();
// Fetch a set of all of the files
let all_files = collect_glob(directory, "/db-backup-????-??-??.sqlite.zst");
// Fetch a set of all of the file in the current month+year
let current_month_year = collect_glob(directory, &format!("/db-backup-{}-{:02}-??.sqlite.zst", year, month));
// Fetch a set of all of the file that is in previous year + first of the month
let previous_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year - 1));
// Fetch a set of all of the file that is in current year + first of the month
let current_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year));
// Calculate the initial set of files to prune
let mut delete_files = delete_set(&all_files, vec![¤t_month_year, &previous_first_month, ¤t_first_month]);
// Compact pfm + cfm into their years
if skip {
println!("Compacting: Skipped");
} else {
if previous_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year-1);
print_compact(&previous_first_month, &tarfile)?;
delete_files.extend(previous_first_month.iter().map(|e| e.clone()));
}
if current_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year);
print_compact(¤t_first_month, &tarfile)?;
delete_files.extend(current_first_month.iter().map(|e| e.clone()));
}
}
// List the files we are going to delete
print_delete(&delete_files, delete)?;
Ok(())
}
fn collect_glob(directory: &str, glob_str: &str) -> HashSet<OsString> |
fn delete_set(all: &HashSet<OsString>, keep: Vec<&HashSet<OsString>>) -> HashSet<OsString> {
let mut delete = all.clone();
for hs in keep {
let out = delete.difference(&hs).map(|e| e.clone()).collect();
delete = out;
}
| {
glob(&(directory.to_string() + glob_str)).unwrap()
.flatten()
.map(|e| e.into_os_string())
.collect::<HashSet<OsString>>()
} | identifier_body |
batches.rs | _version!())
.author(crate_authors!("\n"))
.about("Handles the maintance work for karmator")
.subcommand(
Command::new("runs")
.about("Detect runs of votes")
.arg(
Arg::new("min")
.short('m')
.help("Min count of runs before outputting")
.default_value("20")
.value_parser(value_parser!(u32).range(1..)),
)
.arg(
Arg::new("delete")
.long("delete")
.help("Delete the runs detected")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("FILE")
.help("Database file to operate on")
.required(true),
),
)
.subcommand(
Command::new("prune")
.about("Prune and pack up old backups")
.arg(
Arg::new("delete")
.long("delete")
.help("Delete the old files")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("skip")
.long("skip")
.help("Skip compacting old files")
.action(ArgAction::SetTrue),
)
.arg(
Arg::new("BACKUPS")
.help("Backup directory to prune")
.required(true),
),
)
.get_matches();
match matches.subcommand() {
Some(("runs", m)) => { | let delete = m.contains_id("delete");
run(filename, *min, delete)
},
Some(("prune", m)) => {
let directory = m.get_one::<String>("BACKUPS").unwrap();
let delete = m.contains_id("delete");
let skip = m.contains_id("skip");
prune(directory, delete, skip)
}
_ => {
println!("meh do --help yourself");
Ok(())
},
}.unwrap();
}
#[derive(Debug, Clone)]
struct Vote {
id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
}
impl PartialEq for Vote {
fn eq(&self, other: &Self) -> bool {
(self.by_whom_name == other.by_whom_name)
&& (self.for_what_name == other.for_what_name)
&& (self.amount == other.amount)
}
}
#[derive(Debug)]
struct RunVal {
oldest_id: i32,
newest_id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
count: u32,
}
fn get_run_val(srv: &Vote, pv: &Vote, count: u32) -> RunVal {
RunVal {
oldest_id: srv.id,
newest_id: pv.id,
by_whom_name: srv.by_whom_name.clone(),
for_what_name: srv.for_what_name.clone(),
amount: srv.amount,
count: count,
}
}
fn str_amount(amount: i8) -> &'static str {
match amount {
-1 => "Down",
0 => "Side",
1 => "Up",
_ => panic!("invalid amount"),
}
}
fn run(filename: &str, min: u32, delete: bool) -> Result<(), Box<dyn Error>> {
let conn =
rs::Connection::open_with_flags(Path::new(filename), rs::OpenFlags::SQLITE_OPEN_READ_WRITE)
.expect(&format!("Connection error: {}", filename));
let mut stmt = conn.prepare("SELECT id, by_whom_name, for_what_name, amount FROM votes")?;
let vote_iter = stmt.query_map(rs::params![], |row| {
Ok(Vote {
id: row.get(0)?,
by_whom_name: row.get(1)?,
for_what_name: row.get(2)?,
amount: row.get(3)?,
})
})?;
// Time to compute the run
let mut runs = Vec::new();
let mut start_run_vote = None;
let mut prev_vote = None;
let mut count = 0;
for rvote in vote_iter {
let vote = rvote?;
match (&start_run_vote, &prev_vote) {
(None, None) => {
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
(Some(srv), Some(pv)) => {
if pv == &vote {
// Current vote + prev vote are the same, inc prev vote
prev_vote = Some(vote);
count += 1;
} else {
// Current vote != prev vote, record the run, and reset
runs.push(get_run_val(srv, pv, count));
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
}
(_, _) => panic!("Shouldn't happen"),
};
}
// Record the last run
runs.push(get_run_val(
&start_run_vote.unwrap(),
&prev_vote.unwrap(),
count,
));
if delete {
// Scan and delete the offenders
let mut stmt = conn.prepare("DELETE FROM votes WHERE id >= ? and id <= ?")?;
for r in &runs {
if r.count > min {
let deleted = stmt.execute(rs::params![r.oldest_id, r.newest_id])?;
if (r.count as usize) != deleted {
panic!("Expected: {} to be deleted, got {}", r.count, deleted);
}
}
}
} else {
// Now we can scan for anything that > min and print them
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
"start_id", "end_id", "by_whom_name", "for_what_name", "amount", "count"
);
for r in &runs {
if r.count > min {
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
r.oldest_id,
r.newest_id,
r.by_whom_name,
r.for_what_name,
str_amount(r.amount),
r.count
);
}
}
}
Ok(())
}
fn prune(directory: &str, delete: bool, skip: bool) -> Result<(), Box<dyn Error>> {
let now: DateTime<Local> = Local::now();
let year = now.year();
let month = now.month();
// Fetch a set of all of the files
let all_files = collect_glob(directory, "/db-backup-????-??-??.sqlite.zst");
// Fetch a set of all of the file in the current month+year
let current_month_year = collect_glob(directory, &format!("/db-backup-{}-{:02}-??.sqlite.zst", year, month));
// Fetch a set of all of the file that is in previous year + first of the month
let previous_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year - 1));
// Fetch a set of all of the file that is in current year + first of the month
let current_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year));
// Calculate the initial set of files to prune
let mut delete_files = delete_set(&all_files, vec![¤t_month_year, &previous_first_month, ¤t_first_month]);
// Compact pfm + cfm into their years
if skip {
println!("Compacting: Skipped");
} else {
if previous_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year-1);
print_compact(&previous_first_month, &tarfile)?;
delete_files.extend(previous_first_month.iter().map(|e| e.clone()));
}
if current_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year);
print_compact(¤t_first_month, &tarfile)?;
delete_files.extend(current_first_month.iter().map(|e| e.clone()));
}
}
// List the files we are going to delete
print_delete(&delete_files, delete)?;
Ok(())
}
fn collect_glob(directory: &str, glob_str: &str) -> HashSet<OsString> {
glob(&(directory.to_string() + glob_str)).unwrap()
.flatten()
.map(|e| e.into_os_string())
.collect::<HashSet<OsString>>()
}
fn delete_set(all: &HashSet<OsString>, keep: Vec<&HashSet<OsString>>) -> HashSet<OsString> {
let mut delete = all.clone();
for hs in keep {
let out = delete.difference(&hs).map(|e| e.clone()).collect();
delete = out;
}
delete | let filename = m.get_one::<String>("FILE").unwrap();
let min = m.get_one::<u32>("min").unwrap(); | random_line_split |
batches.rs | }
_ => {
println!("meh do --help yourself");
Ok(())
},
}.unwrap();
}
#[derive(Debug, Clone)]
struct Vote {
id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
}
impl PartialEq for Vote {
fn eq(&self, other: &Self) -> bool {
(self.by_whom_name == other.by_whom_name)
&& (self.for_what_name == other.for_what_name)
&& (self.amount == other.amount)
}
}
#[derive(Debug)]
struct RunVal {
oldest_id: i32,
newest_id: i32,
by_whom_name: String,
for_what_name: String,
amount: i8,
count: u32,
}
fn get_run_val(srv: &Vote, pv: &Vote, count: u32) -> RunVal {
RunVal {
oldest_id: srv.id,
newest_id: pv.id,
by_whom_name: srv.by_whom_name.clone(),
for_what_name: srv.for_what_name.clone(),
amount: srv.amount,
count: count,
}
}
fn str_amount(amount: i8) -> &'static str {
match amount {
-1 => "Down",
0 => "Side",
1 => "Up",
_ => panic!("invalid amount"),
}
}
fn run(filename: &str, min: u32, delete: bool) -> Result<(), Box<dyn Error>> {
let conn =
rs::Connection::open_with_flags(Path::new(filename), rs::OpenFlags::SQLITE_OPEN_READ_WRITE)
.expect(&format!("Connection error: {}", filename));
let mut stmt = conn.prepare("SELECT id, by_whom_name, for_what_name, amount FROM votes")?;
let vote_iter = stmt.query_map(rs::params![], |row| {
Ok(Vote {
id: row.get(0)?,
by_whom_name: row.get(1)?,
for_what_name: row.get(2)?,
amount: row.get(3)?,
})
})?;
// Time to compute the run
let mut runs = Vec::new();
let mut start_run_vote = None;
let mut prev_vote = None;
let mut count = 0;
for rvote in vote_iter {
let vote = rvote?;
match (&start_run_vote, &prev_vote) {
(None, None) => {
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
(Some(srv), Some(pv)) => {
if pv == &vote {
// Current vote + prev vote are the same, inc prev vote
prev_vote = Some(vote);
count += 1;
} else {
// Current vote != prev vote, record the run, and reset
runs.push(get_run_val(srv, pv, count));
start_run_vote = Some(vote.clone());
prev_vote = Some(vote);
count = 1; // Run of 1
}
}
(_, _) => panic!("Shouldn't happen"),
};
}
// Record the last run
runs.push(get_run_val(
&start_run_vote.unwrap(),
&prev_vote.unwrap(),
count,
));
if delete {
// Scan and delete the offenders
let mut stmt = conn.prepare("DELETE FROM votes WHERE id >= ? and id <= ?")?;
for r in &runs {
if r.count > min {
let deleted = stmt.execute(rs::params![r.oldest_id, r.newest_id])?;
if (r.count as usize) != deleted {
panic!("Expected: {} to be deleted, got {}", r.count, deleted);
}
}
}
} else {
// Now we can scan for anything that > min and print them
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
"start_id", "end_id", "by_whom_name", "for_what_name", "amount", "count"
);
for r in &runs {
if r.count > min {
println!(
"{: >8}, {: >8}, {: >14.14}, {: >14.14}, {: >6}, {: >5}",
r.oldest_id,
r.newest_id,
r.by_whom_name,
r.for_what_name,
str_amount(r.amount),
r.count
);
}
}
}
Ok(())
}
fn prune(directory: &str, delete: bool, skip: bool) -> Result<(), Box<dyn Error>> {
let now: DateTime<Local> = Local::now();
let year = now.year();
let month = now.month();
// Fetch a set of all of the files
let all_files = collect_glob(directory, "/db-backup-????-??-??.sqlite.zst");
// Fetch a set of all of the file in the current month+year
let current_month_year = collect_glob(directory, &format!("/db-backup-{}-{:02}-??.sqlite.zst", year, month));
// Fetch a set of all of the file that is in previous year + first of the month
let previous_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year - 1));
// Fetch a set of all of the file that is in current year + first of the month
let current_first_month = collect_glob(directory, &format!("/db-backup-{}-??-01.sqlite.zst", year));
// Calculate the initial set of files to prune
let mut delete_files = delete_set(&all_files, vec![¤t_month_year, &previous_first_month, ¤t_first_month]);
// Compact pfm + cfm into their years
if skip {
println!("Compacting: Skipped");
} else {
if previous_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year-1);
print_compact(&previous_first_month, &tarfile)?;
delete_files.extend(previous_first_month.iter().map(|e| e.clone()));
}
if current_first_month.len() == 12 {
let tarfile = format!("{}/db-backup-{}.tar.zst", directory, year);
print_compact(¤t_first_month, &tarfile)?;
delete_files.extend(current_first_month.iter().map(|e| e.clone()));
}
}
// List the files we are going to delete
print_delete(&delete_files, delete)?;
Ok(())
}
fn collect_glob(directory: &str, glob_str: &str) -> HashSet<OsString> {
glob(&(directory.to_string() + glob_str)).unwrap()
.flatten()
.map(|e| e.into_os_string())
.collect::<HashSet<OsString>>()
}
fn delete_set(all: &HashSet<OsString>, keep: Vec<&HashSet<OsString>>) -> HashSet<OsString> {
let mut delete = all.clone();
for hs in keep {
let out = delete.difference(&hs).map(|e| e.clone()).collect();
delete = out;
}
delete
}
fn compact(compact: &HashSet<OsString>, filename: &str) -> Result<(), Box<dyn Error>> {
let tarfile = OpenOptions::new()
.write(true)
.create_new(true)
.open(filename);
let mut tar = Builder::new(Encoder::new(tarfile?, 21)?.auto_finish());
for f in compact.iter() {
let mut file = File::open(f)?;
let filename = Path::new(f).file_name().unwrap();
let filesize = {
let mut count = CountWrite::from(std::io::sink());
copy_decode(&file, &mut count)?;
count.count()
};
let mut header = Header::new_gnu();
header.set_path(filename)?;
header.set_size(filesize);
header.set_cksum();
file.seek(SeekFrom::Start(0))?;
tar.append(
&header,
Decoder::new(std::fs::File::open(f)?)?
)?;
}
tar.finish()?;
Ok(())
}
fn print_compact(to_compact: &HashSet<OsString>, tarfile: &str) -> Result<(), Box<dyn Error>> {
println!("Compacting: {}", tarfile);
let mut print = to_compact.iter()
.map(|e| Path::new(e).file_name().unwrap())
.collect::<Vec<&OsStr>>();
print.sort();
for i in print.iter() {
println!("\t{:?}", i);
}
compact(&to_compact, &tarfile)?;
Ok(())
}
fn print_delete(to_delete: &HashSet<OsString>, delete: bool) -> Result<(), Box<dyn Error>> {
println!("Deleting:");
let mut print = to_delete.iter().collect::<Vec<&OsString>>();
print.sort();
for i in print.iter() {
let path = Path::new(i);
println!("\t{:?}", path.file_name().unwrap());
if delete | {
std::fs::remove_file(path)?;
} | conditional_block | |
reconcile_keyspaces.go | planetscalev2 "planetscale.dev/vitess-operator/pkg/apis/planetscale/v2"
"planetscale.dev/vitess-operator/pkg/operator/lockserver"
"planetscale.dev/vitess-operator/pkg/operator/reconciler"
"planetscale.dev/vitess-operator/pkg/operator/rollout"
"planetscale.dev/vitess-operator/pkg/operator/update"
"planetscale.dev/vitess-operator/pkg/operator/vitesskeyspace"
)
func (r *ReconcileVitessCluster) reconcileKeyspaces(ctx context.Context, vt *planetscalev2.VitessCluster) error {
labels := map[string]string{
planetscalev2.ClusterLabel: vt.Name,
}
// Generate keys (object names) for all desired keyspaces.
// Keep a map back from generated names to the keyspace specs.
// Oh boy it's awkward right now that the k8s client calls object names keys.
keys := make([]client.ObjectKey, 0, len(vt.Spec.Keyspaces))
keyspaceMap := make(map[client.ObjectKey]*planetscalev2.VitessKeyspaceTemplate, len(vt.Spec.Keyspaces))
for i := range vt.Spec.Keyspaces {
keyspace := &vt.Spec.Keyspaces[i]
key := client.ObjectKey{Namespace: vt.Namespace, Name: vitesskeyspace.Name(vt.Name, keyspace.Name)}
keys = append(keys, key)
keyspaceMap[key] = keyspace
// Initialize a status entry for every desired keyspace, so it will be
// listed even if we end up not having anything to report about it.
vt.Status.Keyspaces[keyspace.Name] = planetscalev2.NewVitessClusterKeyspaceStatus(keyspace)
}
return r.reconciler.ReconcileObjectSet(ctx, vt, keys, labels, reconciler.Strategy{
Kind: &planetscalev2.VitessKeyspace{},
New: func(key client.ObjectKey) runtime.Object {
return newVitessKeyspace(key, vt, labels, keyspaceMap[key])
},
UpdateInPlace: func(key client.ObjectKey, obj runtime.Object) {
newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key])
return
}
updateVitessKeyspaceInPlace(key, newObj, vt, labels, keyspaceMap[key])
},
UpdateRollingInPlace: func(key client.ObjectKey, obj runtime.Object) {
newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
// In this case we should use UpdateInPlace for all updates.
return
}
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key])
},
Status: func(key client.ObjectKey, obj runtime.Object) {
curObj := obj.(*planetscalev2.VitessKeyspace)
status := vt.Status.Keyspaces[curObj.Spec.Name]
status.PendingChanges = curObj.Annotations[rollout.ScheduledAnnotation]
status.Shards = int32(len(curObj.Status.Shards))
status.ReadyShards = 0
status.UpdatedShards = 0
status.Tablets = 0
status.ReadyTablets = 0
status.UpdatedTablets = 0
cells := map[string]struct{}{}
for _, shard := range curObj.Status.Shards {
if shard.ReadyTablets == shard.DesiredTablets {
status.ReadyShards++
}
if shard.UpdatedTablets == shard.Tablets {
status.UpdatedShards++
}
status.Tablets += shard.Tablets
status.ReadyTablets += shard.ReadyTablets
status.UpdatedTablets += shard.UpdatedTablets
for _, cell := range shard.Cells {
cells[cell] = struct{}{}
}
}
for cell := range cells {
status.Cells = append(status.Cells, cell)
}
sort.Strings(status.Cells)
vt.Status.Keyspaces[curObj.Spec.Name] = status
},
OrphanStatus: func(key client.ObjectKey, obj runtime.Object, orphanStatus *planetscalev2.OrphanStatus) {
curObj := obj.(*planetscalev2.VitessKeyspace)
vt.Status.OrphanedKeyspaces[curObj.Spec.Name] = *orphanStatus
},
PrepareForTurndown: func(key client.ObjectKey, obj runtime.Object) *planetscalev2.OrphanStatus {
curObj := obj.(*planetscalev2.VitessKeyspace)
// Make sure it's ok to delete this keyspace.
// The user may specify to skip turndown safety checks.
if curObj.Spec.TurndownPolicy == planetscalev2.VitessKeyspaceTurndownPolicyImmediate {
return nil
}
// Otherwise, we err on the safe side since losing a keyspace accidentally is very disruptive.
if curObj.Status.Idle == corev1.ConditionTrue {
// The keyspace is not depoyed in any cells.
return nil
}
// The keyspace is either not idle (Idle=False),
// or we can't be sure whether it's idle (Idle=Unknown).
return planetscalev2.NewOrphanStatus("NotIdle", "The keyspace can't be turned down because it's not idle. You must remove all tablet pools before removing the keyspace.")
},
})
}
// newVitessKeyspace expands a complete VitessKeyspace from a VitessKeyspaceTemplate.
//
// A VitessKeyspace consists of both user-configured parts, which come from VitessKeyspaceTemplate,
// plus auto-filled data that we propagate into each VitessKeyspace from here.
// This allows VitessKeyspace to do its job without looking at any other objects,
// and also lets us control when global changes roll out to each keyspace.
func newVitessKeyspace(key client.ObjectKey, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) *planetscalev2.VitessKeyspace {
template := keyspace.DeepCopy()
images := planetscalev2.VitessKeyspaceImages{}
planetscalev2.DefaultVitessKeyspaceImages(&images, &vt.Spec.Images)
// Copy parent labels map and add keyspace-specific label.
labels := make(map[string]string, len(parentLabels)+1)
for k, v := range parentLabels {
labels[k] = v
}
labels[planetscalev2.KeyspaceLabel] = keyspace.Name
var backupLocations []planetscalev2.VitessBackupLocation
var backupEngine planetscalev2.VitessBackupEngine
if vt.Spec.Backup != nil {
backupLocations = vt.Spec.Backup.Locations
backupEngine = vt.Spec.Backup.Engine
}
return &planetscalev2.VitessKeyspace{
ObjectMeta: metav1.ObjectMeta{
Namespace: key.Namespace,
Name: key.Name,
Labels: labels,
Annotations: keyspace.Annotations,
},
Spec: planetscalev2.VitessKeyspaceSpec{
VitessKeyspaceTemplate: *template,
GlobalLockserver: *lockserver.GlobalConnectionParams(&vt.Spec.GlobalLockserver, vt.Namespace, vt.Name),
Images: images,
ImagePullPolicies: vt.Spec.ImagePullPolicies,
ImagePullSecrets: vt.Spec.ImagePullSecrets,
ZoneMap: vt.Spec.ZoneMap(),
BackupLocations: backupLocations,
BackupEngine: backupEngine,
ExtraVitessFlags: vt.Spec.ExtraVitessFlags,
TopologyReconciliation: vt.Spec.TopologyReconciliation,
UpdateStrategy: vt.Spec.UpdateStrategy,
},
}
}
func updateVitessKeyspace(key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, vt, parentLabels, keyspace)
// Update labels, but ignore existing ones we don't set.
update.Labels(&vtk.Labels, newKeyspace.Labels)
// Add or remove annotations requested in vts.Spec.Annotations.
// This must be done before we update vtk.Spec.
updateVitessKeyspaceAnnotations(vtk, newKeyspace)
// For now, everything in Spec is safe to update.
vtk.Spec = newKeyspace.Spec
}
func | (key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, vt | updateVitessKeyspaceInPlace | identifier_name |
reconcile_keyspaces.go | planetscalev2 "planetscale.dev/vitess-operator/pkg/apis/planetscale/v2"
"planetscale.dev/vitess-operator/pkg/operator/lockserver"
"planetscale.dev/vitess-operator/pkg/operator/reconciler"
"planetscale.dev/vitess-operator/pkg/operator/rollout"
"planetscale.dev/vitess-operator/pkg/operator/update"
"planetscale.dev/vitess-operator/pkg/operator/vitesskeyspace"
)
func (r *ReconcileVitessCluster) reconcileKeyspaces(ctx context.Context, vt *planetscalev2.VitessCluster) error {
labels := map[string]string{
planetscalev2.ClusterLabel: vt.Name,
}
// Generate keys (object names) for all desired keyspaces.
// Keep a map back from generated names to the keyspace specs.
// Oh boy it's awkward right now that the k8s client calls object names keys.
keys := make([]client.ObjectKey, 0, len(vt.Spec.Keyspaces))
keyspaceMap := make(map[client.ObjectKey]*planetscalev2.VitessKeyspaceTemplate, len(vt.Spec.Keyspaces))
for i := range vt.Spec.Keyspaces {
keyspace := &vt.Spec.Keyspaces[i]
key := client.ObjectKey{Namespace: vt.Namespace, Name: vitesskeyspace.Name(vt.Name, keyspace.Name)}
keys = append(keys, key)
keyspaceMap[key] = keyspace
// Initialize a status entry for every desired keyspace, so it will be
// listed even if we end up not having anything to report about it.
vt.Status.Keyspaces[keyspace.Name] = planetscalev2.NewVitessClusterKeyspaceStatus(keyspace)
}
return r.reconciler.ReconcileObjectSet(ctx, vt, keys, labels, reconciler.Strategy{
Kind: &planetscalev2.VitessKeyspace{},
New: func(key client.ObjectKey) runtime.Object {
return newVitessKeyspace(key, vt, labels, keyspaceMap[key])
},
UpdateInPlace: func(key client.ObjectKey, obj runtime.Object) {
newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key])
return
}
updateVitessKeyspaceInPlace(key, newObj, vt, labels, keyspaceMap[key])
},
UpdateRollingInPlace: func(key client.ObjectKey, obj runtime.Object) {
newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
// In this case we should use UpdateInPlace for all updates.
return
}
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key])
},
Status: func(key client.ObjectKey, obj runtime.Object) {
curObj := obj.(*planetscalev2.VitessKeyspace)
status := vt.Status.Keyspaces[curObj.Spec.Name]
status.PendingChanges = curObj.Annotations[rollout.ScheduledAnnotation]
status.Shards = int32(len(curObj.Status.Shards))
status.ReadyShards = 0
status.UpdatedShards = 0
status.Tablets = 0
status.ReadyTablets = 0
status.UpdatedTablets = 0
cells := map[string]struct{}{}
for _, shard := range curObj.Status.Shards {
if shard.ReadyTablets == shard.DesiredTablets {
status.ReadyShards++
}
if shard.UpdatedTablets == shard.Tablets {
status.UpdatedShards++
}
status.Tablets += shard.Tablets
status.ReadyTablets += shard.ReadyTablets
status.UpdatedTablets += shard.UpdatedTablets
for _, cell := range shard.Cells {
cells[cell] = struct{}{}
}
}
for cell := range cells |
sort.Strings(status.Cells)
vt.Status.Keyspaces[curObj.Spec.Name] = status
},
OrphanStatus: func(key client.ObjectKey, obj runtime.Object, orphanStatus *planetscalev2.OrphanStatus) {
curObj := obj.(*planetscalev2.VitessKeyspace)
vt.Status.OrphanedKeyspaces[curObj.Spec.Name] = *orphanStatus
},
PrepareForTurndown: func(key client.ObjectKey, obj runtime.Object) *planetscalev2.OrphanStatus {
curObj := obj.(*planetscalev2.VitessKeyspace)
// Make sure it's ok to delete this keyspace.
// The user may specify to skip turndown safety checks.
if curObj.Spec.TurndownPolicy == planetscalev2.VitessKeyspaceTurndownPolicyImmediate {
return nil
}
// Otherwise, we err on the safe side since losing a keyspace accidentally is very disruptive.
if curObj.Status.Idle == corev1.ConditionTrue {
// The keyspace is not depoyed in any cells.
return nil
}
// The keyspace is either not idle (Idle=False),
// or we can't be sure whether it's idle (Idle=Unknown).
return planetscalev2.NewOrphanStatus("NotIdle", "The keyspace can't be turned down because it's not idle. You must remove all tablet pools before removing the keyspace.")
},
})
}
// newVitessKeyspace expands a complete VitessKeyspace from a VitessKeyspaceTemplate.
//
// A VitessKeyspace consists of both user-configured parts, which come from VitessKeyspaceTemplate,
// plus auto-filled data that we propagate into each VitessKeyspace from here.
// This allows VitessKeyspace to do its job without looking at any other objects,
// and also lets us control when global changes roll out to each keyspace.
func newVitessKeyspace(key client.ObjectKey, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) *planetscalev2.VitessKeyspace {
template := keyspace.DeepCopy()
images := planetscalev2.VitessKeyspaceImages{}
planetscalev2.DefaultVitessKeyspaceImages(&images, &vt.Spec.Images)
// Copy parent labels map and add keyspace-specific label.
labels := make(map[string]string, len(parentLabels)+1)
for k, v := range parentLabels {
labels[k] = v
}
labels[planetscalev2.KeyspaceLabel] = keyspace.Name
var backupLocations []planetscalev2.VitessBackupLocation
var backupEngine planetscalev2.VitessBackupEngine
if vt.Spec.Backup != nil {
backupLocations = vt.Spec.Backup.Locations
backupEngine = vt.Spec.Backup.Engine
}
return &planetscalev2.VitessKeyspace{
ObjectMeta: metav1.ObjectMeta{
Namespace: key.Namespace,
Name: key.Name,
Labels: labels,
Annotations: keyspace.Annotations,
},
Spec: planetscalev2.VitessKeyspaceSpec{
VitessKeyspaceTemplate: *template,
GlobalLockserver: *lockserver.GlobalConnectionParams(&vt.Spec.GlobalLockserver, vt.Namespace, vt.Name),
Images: images,
ImagePullPolicies: vt.Spec.ImagePullPolicies,
ImagePullSecrets: vt.Spec.ImagePullSecrets,
ZoneMap: vt.Spec.ZoneMap(),
BackupLocations: backupLocations,
BackupEngine: backupEngine,
ExtraVitessFlags: vt.Spec.ExtraVitessFlags,
TopologyReconciliation: vt.Spec.TopologyReconciliation,
UpdateStrategy: vt.Spec.UpdateStrategy,
},
}
}
func updateVitessKeyspace(key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, vt, parentLabels, keyspace)
// Update labels, but ignore existing ones we don't set.
update.Labels(&vtk.Labels, newKeyspace.Labels)
// Add or remove annotations requested in vts.Spec.Annotations.
// This must be done before we update vtk.Spec.
updateVitessKeyspaceAnnotations(vtk, newKeyspace)
// For now, everything in Spec is safe to update.
vtk.Spec = newKeyspace.Spec
}
func updateVitessKeyspaceInPlace(key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, | {
status.Cells = append(status.Cells, cell)
} | conditional_block |
reconcile_keyspaces.go | planetscalev2 "planetscale.dev/vitess-operator/pkg/apis/planetscale/v2"
"planetscale.dev/vitess-operator/pkg/operator/lockserver"
"planetscale.dev/vitess-operator/pkg/operator/reconciler"
"planetscale.dev/vitess-operator/pkg/operator/rollout"
"planetscale.dev/vitess-operator/pkg/operator/update"
"planetscale.dev/vitess-operator/pkg/operator/vitesskeyspace"
)
func (r *ReconcileVitessCluster) reconcileKeyspaces(ctx context.Context, vt *planetscalev2.VitessCluster) error {
labels := map[string]string{
planetscalev2.ClusterLabel: vt.Name,
}
// Generate keys (object names) for all desired keyspaces.
// Keep a map back from generated names to the keyspace specs.
// Oh boy it's awkward right now that the k8s client calls object names keys.
keys := make([]client.ObjectKey, 0, len(vt.Spec.Keyspaces))
keyspaceMap := make(map[client.ObjectKey]*planetscalev2.VitessKeyspaceTemplate, len(vt.Spec.Keyspaces))
for i := range vt.Spec.Keyspaces {
keyspace := &vt.Spec.Keyspaces[i]
key := client.ObjectKey{Namespace: vt.Namespace, Name: vitesskeyspace.Name(vt.Name, keyspace.Name)}
keys = append(keys, key)
keyspaceMap[key] = keyspace
// Initialize a status entry for every desired keyspace, so it will be
// listed even if we end up not having anything to report about it.
vt.Status.Keyspaces[keyspace.Name] = planetscalev2.NewVitessClusterKeyspaceStatus(keyspace)
}
return r.reconciler.ReconcileObjectSet(ctx, vt, keys, labels, reconciler.Strategy{
Kind: &planetscalev2.VitessKeyspace{},
New: func(key client.ObjectKey) runtime.Object {
return newVitessKeyspace(key, vt, labels, keyspaceMap[key])
},
UpdateInPlace: func(key client.ObjectKey, obj runtime.Object) {
newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key]) | newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
// In this case we should use UpdateInPlace for all updates.
return
}
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key])
},
Status: func(key client.ObjectKey, obj runtime.Object) {
curObj := obj.(*planetscalev2.VitessKeyspace)
status := vt.Status.Keyspaces[curObj.Spec.Name]
status.PendingChanges = curObj.Annotations[rollout.ScheduledAnnotation]
status.Shards = int32(len(curObj.Status.Shards))
status.ReadyShards = 0
status.UpdatedShards = 0
status.Tablets = 0
status.ReadyTablets = 0
status.UpdatedTablets = 0
cells := map[string]struct{}{}
for _, shard := range curObj.Status.Shards {
if shard.ReadyTablets == shard.DesiredTablets {
status.ReadyShards++
}
if shard.UpdatedTablets == shard.Tablets {
status.UpdatedShards++
}
status.Tablets += shard.Tablets
status.ReadyTablets += shard.ReadyTablets
status.UpdatedTablets += shard.UpdatedTablets
for _, cell := range shard.Cells {
cells[cell] = struct{}{}
}
}
for cell := range cells {
status.Cells = append(status.Cells, cell)
}
sort.Strings(status.Cells)
vt.Status.Keyspaces[curObj.Spec.Name] = status
},
OrphanStatus: func(key client.ObjectKey, obj runtime.Object, orphanStatus *planetscalev2.OrphanStatus) {
curObj := obj.(*planetscalev2.VitessKeyspace)
vt.Status.OrphanedKeyspaces[curObj.Spec.Name] = *orphanStatus
},
PrepareForTurndown: func(key client.ObjectKey, obj runtime.Object) *planetscalev2.OrphanStatus {
curObj := obj.(*planetscalev2.VitessKeyspace)
// Make sure it's ok to delete this keyspace.
// The user may specify to skip turndown safety checks.
if curObj.Spec.TurndownPolicy == planetscalev2.VitessKeyspaceTurndownPolicyImmediate {
return nil
}
// Otherwise, we err on the safe side since losing a keyspace accidentally is very disruptive.
if curObj.Status.Idle == corev1.ConditionTrue {
// The keyspace is not depoyed in any cells.
return nil
}
// The keyspace is either not idle (Idle=False),
// or we can't be sure whether it's idle (Idle=Unknown).
return planetscalev2.NewOrphanStatus("NotIdle", "The keyspace can't be turned down because it's not idle. You must remove all tablet pools before removing the keyspace.")
},
})
}
// newVitessKeyspace expands a complete VitessKeyspace from a VitessKeyspaceTemplate.
//
// A VitessKeyspace consists of both user-configured parts, which come from VitessKeyspaceTemplate,
// plus auto-filled data that we propagate into each VitessKeyspace from here.
// This allows VitessKeyspace to do its job without looking at any other objects,
// and also lets us control when global changes roll out to each keyspace.
func newVitessKeyspace(key client.ObjectKey, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) *planetscalev2.VitessKeyspace {
template := keyspace.DeepCopy()
images := planetscalev2.VitessKeyspaceImages{}
planetscalev2.DefaultVitessKeyspaceImages(&images, &vt.Spec.Images)
// Copy parent labels map and add keyspace-specific label.
labels := make(map[string]string, len(parentLabels)+1)
for k, v := range parentLabels {
labels[k] = v
}
labels[planetscalev2.KeyspaceLabel] = keyspace.Name
var backupLocations []planetscalev2.VitessBackupLocation
var backupEngine planetscalev2.VitessBackupEngine
if vt.Spec.Backup != nil {
backupLocations = vt.Spec.Backup.Locations
backupEngine = vt.Spec.Backup.Engine
}
return &planetscalev2.VitessKeyspace{
ObjectMeta: metav1.ObjectMeta{
Namespace: key.Namespace,
Name: key.Name,
Labels: labels,
Annotations: keyspace.Annotations,
},
Spec: planetscalev2.VitessKeyspaceSpec{
VitessKeyspaceTemplate: *template,
GlobalLockserver: *lockserver.GlobalConnectionParams(&vt.Spec.GlobalLockserver, vt.Namespace, vt.Name),
Images: images,
ImagePullPolicies: vt.Spec.ImagePullPolicies,
ImagePullSecrets: vt.Spec.ImagePullSecrets,
ZoneMap: vt.Spec.ZoneMap(),
BackupLocations: backupLocations,
BackupEngine: backupEngine,
ExtraVitessFlags: vt.Spec.ExtraVitessFlags,
TopologyReconciliation: vt.Spec.TopologyReconciliation,
UpdateStrategy: vt.Spec.UpdateStrategy,
},
}
}
func updateVitessKeyspace(key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, vt, parentLabels, keyspace)
// Update labels, but ignore existing ones we don't set.
update.Labels(&vtk.Labels, newKeyspace.Labels)
// Add or remove annotations requested in vts.Spec.Annotations.
// This must be done before we update vtk.Spec.
updateVitessKeyspaceAnnotations(vtk, newKeyspace)
// For now, everything in Spec is safe to update.
vtk.Spec = newKeyspace.Spec
}
func updateVitessKeyspaceInPlace(key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, vt | return
}
updateVitessKeyspaceInPlace(key, newObj, vt, labels, keyspaceMap[key])
},
UpdateRollingInPlace: func(key client.ObjectKey, obj runtime.Object) { | random_line_split |
reconcile_keyspaces.go | ) runtime.Object {
return newVitessKeyspace(key, vt, labels, keyspaceMap[key])
},
UpdateInPlace: func(key client.ObjectKey, obj runtime.Object) {
newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key])
return
}
updateVitessKeyspaceInPlace(key, newObj, vt, labels, keyspaceMap[key])
},
UpdateRollingInPlace: func(key client.ObjectKey, obj runtime.Object) {
newObj := obj.(*planetscalev2.VitessKeyspace)
if *vt.Spec.UpdateStrategy.Type == planetscalev2.ImmediateVitessClusterUpdateStrategyType {
// In this case we should use UpdateInPlace for all updates.
return
}
updateVitessKeyspace(key, newObj, vt, labels, keyspaceMap[key])
},
Status: func(key client.ObjectKey, obj runtime.Object) {
curObj := obj.(*planetscalev2.VitessKeyspace)
status := vt.Status.Keyspaces[curObj.Spec.Name]
status.PendingChanges = curObj.Annotations[rollout.ScheduledAnnotation]
status.Shards = int32(len(curObj.Status.Shards))
status.ReadyShards = 0
status.UpdatedShards = 0
status.Tablets = 0
status.ReadyTablets = 0
status.UpdatedTablets = 0
cells := map[string]struct{}{}
for _, shard := range curObj.Status.Shards {
if shard.ReadyTablets == shard.DesiredTablets {
status.ReadyShards++
}
if shard.UpdatedTablets == shard.Tablets {
status.UpdatedShards++
}
status.Tablets += shard.Tablets
status.ReadyTablets += shard.ReadyTablets
status.UpdatedTablets += shard.UpdatedTablets
for _, cell := range shard.Cells {
cells[cell] = struct{}{}
}
}
for cell := range cells {
status.Cells = append(status.Cells, cell)
}
sort.Strings(status.Cells)
vt.Status.Keyspaces[curObj.Spec.Name] = status
},
OrphanStatus: func(key client.ObjectKey, obj runtime.Object, orphanStatus *planetscalev2.OrphanStatus) {
curObj := obj.(*planetscalev2.VitessKeyspace)
vt.Status.OrphanedKeyspaces[curObj.Spec.Name] = *orphanStatus
},
PrepareForTurndown: func(key client.ObjectKey, obj runtime.Object) *planetscalev2.OrphanStatus {
curObj := obj.(*planetscalev2.VitessKeyspace)
// Make sure it's ok to delete this keyspace.
// The user may specify to skip turndown safety checks.
if curObj.Spec.TurndownPolicy == planetscalev2.VitessKeyspaceTurndownPolicyImmediate {
return nil
}
// Otherwise, we err on the safe side since losing a keyspace accidentally is very disruptive.
if curObj.Status.Idle == corev1.ConditionTrue {
// The keyspace is not depoyed in any cells.
return nil
}
// The keyspace is either not idle (Idle=False),
// or we can't be sure whether it's idle (Idle=Unknown).
return planetscalev2.NewOrphanStatus("NotIdle", "The keyspace can't be turned down because it's not idle. You must remove all tablet pools before removing the keyspace.")
},
})
}
// newVitessKeyspace expands a complete VitessKeyspace from a VitessKeyspaceTemplate.
//
// A VitessKeyspace consists of both user-configured parts, which come from VitessKeyspaceTemplate,
// plus auto-filled data that we propagate into each VitessKeyspace from here.
// This allows VitessKeyspace to do its job without looking at any other objects,
// and also lets us control when global changes roll out to each keyspace.
func newVitessKeyspace(key client.ObjectKey, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) *planetscalev2.VitessKeyspace {
template := keyspace.DeepCopy()
images := planetscalev2.VitessKeyspaceImages{}
planetscalev2.DefaultVitessKeyspaceImages(&images, &vt.Spec.Images)
// Copy parent labels map and add keyspace-specific label.
labels := make(map[string]string, len(parentLabels)+1)
for k, v := range parentLabels {
labels[k] = v
}
labels[planetscalev2.KeyspaceLabel] = keyspace.Name
var backupLocations []planetscalev2.VitessBackupLocation
var backupEngine planetscalev2.VitessBackupEngine
if vt.Spec.Backup != nil {
backupLocations = vt.Spec.Backup.Locations
backupEngine = vt.Spec.Backup.Engine
}
return &planetscalev2.VitessKeyspace{
ObjectMeta: metav1.ObjectMeta{
Namespace: key.Namespace,
Name: key.Name,
Labels: labels,
Annotations: keyspace.Annotations,
},
Spec: planetscalev2.VitessKeyspaceSpec{
VitessKeyspaceTemplate: *template,
GlobalLockserver: *lockserver.GlobalConnectionParams(&vt.Spec.GlobalLockserver, vt.Namespace, vt.Name),
Images: images,
ImagePullPolicies: vt.Spec.ImagePullPolicies,
ImagePullSecrets: vt.Spec.ImagePullSecrets,
ZoneMap: vt.Spec.ZoneMap(),
BackupLocations: backupLocations,
BackupEngine: backupEngine,
ExtraVitessFlags: vt.Spec.ExtraVitessFlags,
TopologyReconciliation: vt.Spec.TopologyReconciliation,
UpdateStrategy: vt.Spec.UpdateStrategy,
},
}
}
func updateVitessKeyspace(key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, vt, parentLabels, keyspace)
// Update labels, but ignore existing ones we don't set.
update.Labels(&vtk.Labels, newKeyspace.Labels)
// Add or remove annotations requested in vts.Spec.Annotations.
// This must be done before we update vtk.Spec.
updateVitessKeyspaceAnnotations(vtk, newKeyspace)
// For now, everything in Spec is safe to update.
vtk.Spec = newKeyspace.Spec
}
func updateVitessKeyspaceInPlace(key client.ObjectKey, vtk *planetscalev2.VitessKeyspace, vt *planetscalev2.VitessCluster, parentLabels map[string]string, keyspace *planetscalev2.VitessKeyspaceTemplate) {
newKeyspace := newVitessKeyspace(key, vt, parentLabels, keyspace)
// Update labels, but ignore existing ones we don't set.
update.Labels(&vtk.Labels, newKeyspace.Labels)
// Switching update strategies should always take effect immediately.
vtk.Spec.UpdateStrategy = newKeyspace.Spec.UpdateStrategy
// Update disk size immediately if specified to.
if *vtk.Spec.UpdateStrategy.Type == planetscalev2.ExternalVitessClusterUpdateStrategyType {
if vtk.Spec.UpdateStrategy.External.ResourceChangesAllowed(corev1.ResourceStorage) {
update.KeyspaceDiskSize(&vtk.Spec.VitessKeyspaceTemplate, &newKeyspace.Spec.VitessKeyspaceTemplate)
}
}
// Add or remove partitionings as needed, but don't immediately reconfigure
// partitionings that already exist.
update.PartitioningSet(&vtk.Spec.Partitionings, newKeyspace.Spec.Partitionings)
// Only update things that are safe to roll out immediately.
vtk.Spec.TurndownPolicy = newKeyspace.Spec.TurndownPolicy
// Add or remove annotations requested in vtk.Spec.Annotations.
updateVitessKeyspaceAnnotations(vtk, newKeyspace)
}
func updateVitessKeyspaceAnnotations(vtk *planetscalev2.VitessKeyspace, newKeyspace *planetscalev2.VitessKeyspace) {
differentAnnotations := differentKeys(vtk.Spec.Annotations, newKeyspace.Spec.Annotations)
for _, annotation := range differentAnnotations {
delete(vtk.Annotations, annotation)
}
// Update annotations we set.
update.Annotations(&vtk.Annotations, newKeyspace.Annotations)
vtk.Spec.Annotations = newKeyspace.Spec.Annotations
}
// differentKeys returns keys from an older map instance that are no longer in a newer map instance.
func differentKeys(oldMap, newMap map[string]string) []string | {
var differentKeys []string
for k := range oldMap {
if _, exist := newMap[k]; !exist {
differentKeys = append(differentKeys, k)
}
}
return differentKeys
} | identifier_body | |
elasticsearch_metadata.go | interface {
Perform(*http.Request) (*http.Response, error)
}
// NewBgMetadataElasticSearchConnector : contructor for BgMetadataElasticSearchConnector
func newBgMetadataElasticSearchConnector(elasticSearchClient ElasticSearchClient, registry prometheus.Registerer, bulkSize, maxRetry uint, indexName, IndexDateFmt string) *BgMetadataElasticSearchConnector {
var esc = BgMetadataElasticSearchConnector{
client: elasticSearchClient,
BulkSize: bulkSize,
bulkBuffer: make([]ElasticSearchDocument, 0, bulkSize),
MaxRetry: maxRetry,
IndexName: indexName,
IndexDateFmt: IndexDateFmt,
UpdatedDocuments: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "updated_documents",
Help: "total number of documents updated in ElasticSearch splited between metrics and directories",
}, []string{"status", "type"}),
HTTPErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "http_errors",
Help: "total number of http errors encountered partitionned by status code",
}, []string{"code"}),
WriteDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_duration_ms",
Help: "time spent writing to ElasticSearch based on `took` field of response ",
Buckets: []float64{250, 500, 750, 1000, 1500, 2000, 5000, 10000}}),
RequestSize: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_request_size_bytes",
Help: "Size of batch create requests performed on elasticsearch",
Buckets: []float64{10000, 100000, 1000000, 5000000, 10000000, 20000000, 50000000}}),
DocumentBuildDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "document_build_duration_ms",
Help: "time spent building an ElasticSearch document",
Buckets: []float64{1, 5, 10, 50, 100, 250, 500, 750, 1000, 2000}}),
logger: zap.L(),
}
_ = registry.Register(esc.UpdatedDocuments)
_ = registry.Register(esc.WriteDurationMs)
_ = registry.Register(esc.DocumentBuildDurationMs)
_ = registry.Register(esc.HTTPErrors)
_ = registry.Register(esc.RequestSize)
if esc.IndexName == "" {
esc.IndexName = default_metrics_metadata_index
}
if esc.IndexDateFmt == "" {
esc.DirectoriesIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, directories_index_suffix)
esc.MetricsIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, metrics_index_suffix)
}
esc.KnownIndices = map[string]bool{}
return &esc
}
func createElasticSearchClient(servers []string, username, password string, allow_insecure_tls bool) (*elasticsearch.Client, error) {
cfg := elasticsearch.Config{
Addresses: servers,
Username: username,
Password: password,
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: allow_insecure_tls,
},
},
}
es, err := elasticsearch.NewClient(cfg)
if err != nil {
log.Fatalf("Error creating the ElasticSearch client: %s", err)
}
_, err = es.Info()
if err != nil {
log.Fatalf("Error getting ElasticSearch information response: %s", err)
}
return es, err
}
// NewBgMetadataElasticSearchConnectorWithDefaults is the public contructor of BgMetadataElasticSearchConnector
func NewBgMetadataElasticSearchConnectorWithDefaults(cfg *cfg.BgMetadataESConfig) *BgMetadataElasticSearchConnector {
es, err := createElasticSearchClient(cfg.StorageServers, cfg.Username, cfg.Password, cfg.AllowInsecureTLS)
if err != nil {
log.Fatalf("Could not create ElasticSearch connector: %v", err)
}
return newBgMetadataElasticSearchConnector(es, prometheus.DefaultRegisterer, cfg.BulkSize, cfg.MaxRetry, cfg.IndexName, cfg.IndexDateFmt)
}
func (esc *BgMetadataElasticSearchConnector) Close() {
}
func (esc *BgMetadataElasticSearchConnector) createIndicesAndMapping(metricIndexName, directoryIndexName string) error {
indices := []struct{ name, mapping string }{{metricIndexName, metricsMapping}, {directoryIndexName, dirMapping}}
for _, index := range indices {
indexCreateRequest := esapi.IndicesCreateRequest{Index: index.name}
res, err := indexCreateRequest.Do(context.Background(), esc.client)
esc.logger.Info("using index", zap.String("name", index.name))
// extract TODO error deserialize
r := strings.NewReader(index.mapping)
request := esapi.IndicesPutMappingRequest{Index: []string{index.name}, Body: r, DocumentType: documentType}
res, err = request.Do(context.Background(), esc.client)
if err != nil {
return fmt.Errorf("Could not set ElasticSearch mapping: %w", err)
}
if res.StatusCode != http.StatusOK {
errorMessage, _ := ioutil.ReadAll(res.Body)
return fmt.Errorf("Could not set ElasticSearch mapping (status %d, error: %s)", res.StatusCode, errorMessage)
}
}
return nil
}
// UpdateMetricMetadata stores the metric in a buffer, will bulkupdate when at full cap
// threadsafe
func (esc *BgMetadataElasticSearchConnector) UpdateMetricMetadata(metric *Metric) error {
return esc.addDocumentToBuff(metric)
}
func (esc *BgMetadataElasticSearchConnector) addDocumentToBuff(doc ElasticSearchDocument) error {
esc.mux.Lock()
defer esc.mux.Unlock()
esc.bulkBuffer = append(esc.bulkBuffer, doc)
if len(esc.bulkBuffer) == cap(esc.bulkBuffer) {
esc.sendAndClearBuffer()
}
return nil
}
func (esc *BgMetadataElasticSearchConnector) sendAndClearBuffer() error {
defer esc.clearBuffer()
metricIndex, directoryIndex, err := esc.getIndices()
var errorMessage []byte
var statusCode int
if err != nil {
esc.UpdatedDocuments.WithLabelValues("failure").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not get index: %w", err)
}
timeBeforeBuild := time.Now()
requestBody := BuildElasticSearchDocumentMulti(metricIndex, directoryIndex, esc.bulkBuffer)
esc.DocumentBuildDurationMs.Observe(float64(time.Since(timeBeforeBuild).Milliseconds()))
esc.RequestSize.Observe(float64(len(requestBody)))
for attempt := uint(0); attempt <= esc.MaxRetry; attempt++ {
res, err := esc.bulkUpdate(requestBody)
if err != nil {
// esapi resturns a nil body in case of error
esc.UpdatedDocuments.WithLabelValues("failure", "any").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not write to index: %w", err)
}
if !res.IsError() {
esc.updateInternalMetrics(res)
res.Body.Close()
return nil
} else {
esc.HTTPErrors.WithLabelValues(strconv.Itoa(res.StatusCode)).Inc()
statusCode = res.StatusCode
errorMessage, _ = ioutil.ReadAll(res.Body)
res.Body.Close()
}
}
esc.UpdatedDocuments.WithLabelValues("failure", "any").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not write to index (status %d, error: %s)", statusCode, errorMessage)
}
// updateInternalMetrics increments BGMetadataConnector's metrics,
func (esc *BgMetadataElasticSearchConnector) updateInternalMetrics(res *esapi.Response) {
defer func() {
if err := recover(); err != nil {
esc.logger.Warn("malformed bulk response", zap.Error(err.(error)))
}
}()
var mapResp map[string]interface{}
json.NewDecoder(res.Body).Decode(&mapResp)
esc.WriteDurationMs.Observe(mapResp["took"].(float64))
for _, item := range mapResp["items"].([]interface{}) {
mapCreate := item.(map[string]interface{})["create"].(map[string]interface{})
// protected by esc.Mux currentIndex may not change while looping
if int(mapCreate["status"].(float64)) == http.StatusCreated {
if strings.HasPrefix(mapCreate["_index"].(string), esc.currentIndex) {
esc.UpdatedDocuments.WithLabelValues("created", "metric").Inc()
} else {
esc.UpdatedDocuments.WithLabelValues("created", "directory").Inc()
}
}
}
}
func (esc *BgMetadataElasticSearchConnector) clearBuffer() error {
esc.bulkBuffer = esc.bulkBuffer[:0]
return nil | random_line_split | ||
elasticsearch_metadata.go | `
{
"_doc": {
"properties": {
"depth": {
"type": "long"
},
"name": {
"type": "keyword",
"ignore_above": 1024
},
"uuid": {
"type": "keyword"
},
"parent": {
"type": "keyword"
}
},
"dynamic_templates": [
{
"strings_as_keywords": {
"match": "p*",
"match_mapping_type": "string",
"mapping": {
"type": "keyword",
"ignore_above": 256,
"ignore_malformed": true
}
}
}
]
}
}
`
documentType = "_doc"
)
type BgMetadataElasticSearchConnector struct {
client ElasticSearchClient
UpdatedDocuments *prometheus.CounterVec
HTTPErrors *prometheus.CounterVec
WriteDurationMs prometheus.Histogram
DocumentBuildDurationMs prometheus.Histogram
RequestSize prometheus.Histogram
KnownIndices map[string]bool
bulkBuffer []ElasticSearchDocument
BulkSize uint
mux sync.Mutex
MaxRetry uint
IndexName, currentIndex string
IndexDateFmt string //strftime fmt string
DirectoriesIndexAlias, MetricsIndexAlias string
logger *zap.Logger
}
type ElasticSearchClient interface {
Perform(*http.Request) (*http.Response, error)
}
// NewBgMetadataElasticSearchConnector : contructor for BgMetadataElasticSearchConnector
func newBgMetadataElasticSearchConnector(elasticSearchClient ElasticSearchClient, registry prometheus.Registerer, bulkSize, maxRetry uint, indexName, IndexDateFmt string) *BgMetadataElasticSearchConnector {
var esc = BgMetadataElasticSearchConnector{
client: elasticSearchClient,
BulkSize: bulkSize,
bulkBuffer: make([]ElasticSearchDocument, 0, bulkSize),
MaxRetry: maxRetry,
IndexName: indexName,
IndexDateFmt: IndexDateFmt,
UpdatedDocuments: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "updated_documents",
Help: "total number of documents updated in ElasticSearch splited between metrics and directories",
}, []string{"status", "type"}),
HTTPErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "http_errors",
Help: "total number of http errors encountered partitionned by status code",
}, []string{"code"}),
WriteDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_duration_ms",
Help: "time spent writing to ElasticSearch based on `took` field of response ",
Buckets: []float64{250, 500, 750, 1000, 1500, 2000, 5000, 10000}}),
RequestSize: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_request_size_bytes",
Help: "Size of batch create requests performed on elasticsearch",
Buckets: []float64{10000, 100000, 1000000, 5000000, 10000000, 20000000, 50000000}}),
DocumentBuildDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "document_build_duration_ms",
Help: "time spent building an ElasticSearch document",
Buckets: []float64{1, 5, 10, 50, 100, 250, 500, 750, 1000, 2000}}),
logger: zap.L(),
}
_ = registry.Register(esc.UpdatedDocuments)
_ = registry.Register(esc.WriteDurationMs)
_ = registry.Register(esc.DocumentBuildDurationMs)
_ = registry.Register(esc.HTTPErrors)
_ = registry.Register(esc.RequestSize)
if esc.IndexName == "" {
esc.IndexName = default_metrics_metadata_index
}
if esc.IndexDateFmt == "" {
esc.DirectoriesIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, directories_index_suffix)
esc.MetricsIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, metrics_index_suffix)
}
esc.KnownIndices = map[string]bool{}
return &esc
}
func createElasticSearchClient(servers []string, username, password string, allow_insecure_tls bool) (*elasticsearch.Client, error) | }
return es, err
}
// NewBgMetadataElasticSearchConnectorWithDefaults is the public contructor of BgMetadataElasticSearchConnector
func NewBgMetadataElasticSearchConnectorWithDefaults(cfg *cfg.BgMetadataESConfig) *BgMetadataElasticSearchConnector {
es, err := createElasticSearchClient(cfg.StorageServers, cfg.Username, cfg.Password, cfg.AllowInsecureTLS)
if err != nil {
log.Fatalf("Could not create ElasticSearch connector: %v", err)
}
return newBgMetadataElasticSearchConnector(es, prometheus.DefaultRegisterer, cfg.BulkSize, cfg.MaxRetry, cfg.IndexName, cfg.IndexDateFmt)
}
func (esc *BgMetadataElasticSearchConnector) Close() {
}
func (esc *BgMetadataElasticSearchConnector) createIndicesAndMapping(metricIndexName, directoryIndexName string) error {
indices := []struct{ name, mapping string }{{metricIndexName, metricsMapping}, {directoryIndexName, dirMapping}}
for _, index := range indices {
indexCreateRequest := esapi.IndicesCreateRequest{Index: index.name}
res, err := indexCreateRequest.Do(context.Background(), esc.client)
esc.logger.Info("using index", zap.String("name", index.name))
// extract TODO error deserialize
r := strings.NewReader(index.mapping)
request := esapi.IndicesPutMappingRequest{Index: []string{index.name}, Body: r, DocumentType: documentType}
res, err = request.Do(context.Background(), esc.client)
if err != nil {
return fmt.Errorf("Could not set ElasticSearch mapping: %w", err)
}
if res.StatusCode != http.StatusOK {
errorMessage, _ := ioutil.ReadAll(res.Body)
return fmt.Errorf("Could not set ElasticSearch mapping (status %d, error: %s)", res.StatusCode, errorMessage)
}
}
return nil
}
// UpdateMetricMetadata stores the metric in a buffer, will bulkupdate when at full cap
// threadsafe
func (esc *BgMetadataElasticSearchConnector) UpdateMetricMetadata(metric *Metric) error {
return esc.addDocumentToBuff(metric)
}
func (esc *BgMetadataElasticSearchConnector) addDocumentToBuff(doc ElasticSearchDocument) error {
esc.mux.Lock()
defer esc.mux.Unlock()
esc.bulkBuffer = append(esc.bulkBuffer, doc)
if len(esc.bulkBuffer) == cap(esc.bulkBuffer) {
esc.sendAndClearBuffer()
}
return nil
}
func (esc *BgMetadataElasticSearchConnector) sendAndClearBuffer() error {
defer esc.clearBuffer()
metricIndex, directoryIndex, err := esc.getIndices()
var errorMessage []byte
var statusCode int
if err != nil {
esc.UpdatedDocuments.WithLabelValues("failure").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not get index: %w", err)
}
timeBeforeBuild := time.Now()
requestBody := BuildElasticSearchDocumentMulti(metricIndex, directoryIndex, esc.bulkBuffer)
esc.DocumentBuildDurationMs.Observe(float64(time.Since(timeBeforeBuild).Milliseconds()))
esc.RequestSize.Observe(float64(len(requestBody)))
for attempt := uint(0); attempt <= esc.MaxRetry; attempt++ {
res, err := esc.bulkUpdate(requestBody)
if err != nil {
// esapi resturns a nil body in case of error
esc.UpdatedDocuments.WithLabelValues("failure", "any").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not write to index: %w", err)
}
if !res.IsError() {
esc.updateInternalMetrics(res)
res.Body.Close()
return nil
} else {
esc.HTTPErrors.WithLabelValues(strconv.Itoa(res.StatusCode)).Inc()
statusCode = res.StatusCode
errorMessage, _ = ioutil.ReadAll(res.Body)
res.Body | {
cfg := elasticsearch.Config{
Addresses: servers,
Username: username,
Password: password,
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: allow_insecure_tls,
},
},
}
es, err := elasticsearch.NewClient(cfg)
if err != nil {
log.Fatalf("Error creating the ElasticSearch client: %s", err)
}
_, err = es.Info()
if err != nil {
log.Fatalf("Error getting ElasticSearch information response: %s", err) | identifier_body |
elasticsearch_metadata.go | `
{
"_doc": {
"properties": {
"depth": {
"type": "long"
},
"name": {
"type": "keyword",
"ignore_above": 1024
},
"uuid": {
"type": "keyword"
},
"parent": {
"type": "keyword"
}
},
"dynamic_templates": [
{
"strings_as_keywords": {
"match": "p*",
"match_mapping_type": "string",
"mapping": {
"type": "keyword",
"ignore_above": 256,
"ignore_malformed": true
}
}
}
]
}
}
`
documentType = "_doc"
)
type BgMetadataElasticSearchConnector struct {
client ElasticSearchClient
UpdatedDocuments *prometheus.CounterVec
HTTPErrors *prometheus.CounterVec
WriteDurationMs prometheus.Histogram
DocumentBuildDurationMs prometheus.Histogram
RequestSize prometheus.Histogram
KnownIndices map[string]bool
bulkBuffer []ElasticSearchDocument
BulkSize uint
mux sync.Mutex
MaxRetry uint
IndexName, currentIndex string
IndexDateFmt string //strftime fmt string
DirectoriesIndexAlias, MetricsIndexAlias string
logger *zap.Logger
}
type ElasticSearchClient interface {
Perform(*http.Request) (*http.Response, error)
}
// NewBgMetadataElasticSearchConnector : contructor for BgMetadataElasticSearchConnector
func newBgMetadataElasticSearchConnector(elasticSearchClient ElasticSearchClient, registry prometheus.Registerer, bulkSize, maxRetry uint, indexName, IndexDateFmt string) *BgMetadataElasticSearchConnector {
var esc = BgMetadataElasticSearchConnector{
client: elasticSearchClient,
BulkSize: bulkSize,
bulkBuffer: make([]ElasticSearchDocument, 0, bulkSize),
MaxRetry: maxRetry,
IndexName: indexName,
IndexDateFmt: IndexDateFmt,
UpdatedDocuments: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "updated_documents",
Help: "total number of documents updated in ElasticSearch splited between metrics and directories",
}, []string{"status", "type"}),
HTTPErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "http_errors",
Help: "total number of http errors encountered partitionned by status code",
}, []string{"code"}),
WriteDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_duration_ms",
Help: "time spent writing to ElasticSearch based on `took` field of response ",
Buckets: []float64{250, 500, 750, 1000, 1500, 2000, 5000, 10000}}),
RequestSize: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_request_size_bytes",
Help: "Size of batch create requests performed on elasticsearch",
Buckets: []float64{10000, 100000, 1000000, 5000000, 10000000, 20000000, 50000000}}),
DocumentBuildDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "document_build_duration_ms",
Help: "time spent building an ElasticSearch document",
Buckets: []float64{1, 5, 10, 50, 100, 250, 500, 750, 1000, 2000}}),
logger: zap.L(),
}
_ = registry.Register(esc.UpdatedDocuments)
_ = registry.Register(esc.WriteDurationMs)
_ = registry.Register(esc.DocumentBuildDurationMs)
_ = registry.Register(esc.HTTPErrors)
_ = registry.Register(esc.RequestSize)
if esc.IndexName == "" {
esc.IndexName = default_metrics_metadata_index
}
if esc.IndexDateFmt == "" {
esc.DirectoriesIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, directories_index_suffix)
esc.MetricsIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, metrics_index_suffix)
}
esc.KnownIndices = map[string]bool{}
return &esc
}
func createElasticSearchClient(servers []string, username, password string, allow_insecure_tls bool) (*elasticsearch.Client, error) {
cfg := elasticsearch.Config{
Addresses: servers,
Username: username,
Password: password,
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: allow_insecure_tls,
},
},
}
es, err := elasticsearch.NewClient(cfg)
if err != nil {
log.Fatalf("Error creating the ElasticSearch client: %s", err)
}
_, err = es.Info()
if err != nil {
log.Fatalf("Error getting ElasticSearch information response: %s", err)
}
return es, err
}
// NewBgMetadataElasticSearchConnectorWithDefaults is the public contructor of BgMetadataElasticSearchConnector
func NewBgMetadataElasticSearchConnectorWithDefaults(cfg *cfg.BgMetadataESConfig) *BgMetadataElasticSearchConnector {
es, err := createElasticSearchClient(cfg.StorageServers, cfg.Username, cfg.Password, cfg.AllowInsecureTLS)
if err != nil {
log.Fatalf("Could not create ElasticSearch connector: %v", err)
}
return newBgMetadataElasticSearchConnector(es, prometheus.DefaultRegisterer, cfg.BulkSize, cfg.MaxRetry, cfg.IndexName, cfg.IndexDateFmt)
}
func (esc *BgMetadataElasticSearchConnector) Close() {
}
func (esc *BgMetadataElasticSearchConnector) createIndicesAndMapping(metricIndexName, directoryIndexName string) error {
indices := []struct{ name, mapping string }{{metricIndexName, metricsMapping}, {directoryIndexName, dirMapping}}
for _, index := range indices {
indexCreateRequest := esapi.IndicesCreateRequest{Index: index.name}
res, err := indexCreateRequest.Do(context.Background(), esc.client)
esc.logger.Info("using index", zap.String("name", index.name))
// extract TODO error deserialize
r := strings.NewReader(index.mapping)
request := esapi.IndicesPutMappingRequest{Index: []string{index.name}, Body: r, DocumentType: documentType}
res, err = request.Do(context.Background(), esc.client)
if err != nil {
return fmt.Errorf("Could not set ElasticSearch mapping: %w", err)
}
if res.StatusCode != http.StatusOK {
errorMessage, _ := ioutil.ReadAll(res.Body)
return fmt.Errorf("Could not set ElasticSearch mapping (status %d, error: %s)", res.StatusCode, errorMessage)
}
}
return nil
}
// UpdateMetricMetadata stores the metric in a buffer, will bulkupdate when at full cap
// threadsafe
func (esc *BgMetadataElasticSearchConnector) UpdateMetricMetadata(metric *Metric) error {
return esc.addDocumentToBuff(metric)
}
func (esc *BgMetadataElasticSearchConnector) | (doc ElasticSearchDocument) error {
esc.mux.Lock()
defer esc.mux.Unlock()
esc.bulkBuffer = append(esc.bulkBuffer, doc)
if len(esc.bulkBuffer) == cap(esc.bulkBuffer) {
esc.sendAndClearBuffer()
}
return nil
}
func (esc *BgMetadataElasticSearchConnector) sendAndClearBuffer() error {
defer esc.clearBuffer()
metricIndex, directoryIndex, err := esc.getIndices()
var errorMessage []byte
var statusCode int
if err != nil {
esc.UpdatedDocuments.WithLabelValues("failure").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not get index: %w", err)
}
timeBeforeBuild := time.Now()
requestBody := BuildElasticSearchDocumentMulti(metricIndex, directoryIndex, esc.bulkBuffer)
esc.DocumentBuildDurationMs.Observe(float64(time.Since(timeBeforeBuild).Milliseconds()))
esc.RequestSize.Observe(float64(len(requestBody)))
for attempt := uint(0); attempt <= esc.MaxRetry; attempt++ {
res, err := esc.bulkUpdate(requestBody)
if err != nil {
// esapi resturns a nil body in case of error
esc.UpdatedDocuments.WithLabelValues("failure", "any").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not write to index: %w", err)
}
if !res.IsError() {
esc.updateInternalMetrics(res)
res.Body.Close()
return nil
} else {
esc.HTTPErrors.WithLabelValues(strconv.Itoa(res.StatusCode)).Inc()
statusCode = res.StatusCode
errorMessage, _ = ioutil.ReadAll(res.Body)
res.Body | addDocumentToBuff | identifier_name |
elasticsearch_metadata.go | `
{
"_doc": {
"properties": {
"depth": {
"type": "long"
},
"name": {
"type": "keyword",
"ignore_above": 1024
},
"uuid": {
"type": "keyword"
},
"parent": {
"type": "keyword"
}
},
"dynamic_templates": [
{
"strings_as_keywords": {
"match": "p*",
"match_mapping_type": "string",
"mapping": {
"type": "keyword",
"ignore_above": 256,
"ignore_malformed": true
}
}
}
]
}
}
`
documentType = "_doc"
)
type BgMetadataElasticSearchConnector struct {
client ElasticSearchClient
UpdatedDocuments *prometheus.CounterVec
HTTPErrors *prometheus.CounterVec
WriteDurationMs prometheus.Histogram
DocumentBuildDurationMs prometheus.Histogram
RequestSize prometheus.Histogram
KnownIndices map[string]bool
bulkBuffer []ElasticSearchDocument
BulkSize uint
mux sync.Mutex
MaxRetry uint
IndexName, currentIndex string
IndexDateFmt string //strftime fmt string
DirectoriesIndexAlias, MetricsIndexAlias string
logger *zap.Logger
}
type ElasticSearchClient interface {
Perform(*http.Request) (*http.Response, error)
}
// NewBgMetadataElasticSearchConnector : contructor for BgMetadataElasticSearchConnector
func newBgMetadataElasticSearchConnector(elasticSearchClient ElasticSearchClient, registry prometheus.Registerer, bulkSize, maxRetry uint, indexName, IndexDateFmt string) *BgMetadataElasticSearchConnector {
var esc = BgMetadataElasticSearchConnector{
client: elasticSearchClient,
BulkSize: bulkSize,
bulkBuffer: make([]ElasticSearchDocument, 0, bulkSize),
MaxRetry: maxRetry,
IndexName: indexName,
IndexDateFmt: IndexDateFmt,
UpdatedDocuments: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "updated_documents",
Help: "total number of documents updated in ElasticSearch splited between metrics and directories",
}, []string{"status", "type"}),
HTTPErrors: prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: namespace,
Name: "http_errors",
Help: "total number of http errors encountered partitionned by status code",
}, []string{"code"}),
WriteDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_duration_ms",
Help: "time spent writing to ElasticSearch based on `took` field of response ",
Buckets: []float64{250, 500, 750, 1000, 1500, 2000, 5000, 10000}}),
RequestSize: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "write_request_size_bytes",
Help: "Size of batch create requests performed on elasticsearch",
Buckets: []float64{10000, 100000, 1000000, 5000000, 10000000, 20000000, 50000000}}),
DocumentBuildDurationMs: prometheus.NewHistogram(prometheus.HistogramOpts{
Namespace: namespace,
Name: "document_build_duration_ms",
Help: "time spent building an ElasticSearch document",
Buckets: []float64{1, 5, 10, 50, 100, 250, 500, 750, 1000, 2000}}),
logger: zap.L(),
}
_ = registry.Register(esc.UpdatedDocuments)
_ = registry.Register(esc.WriteDurationMs)
_ = registry.Register(esc.DocumentBuildDurationMs)
_ = registry.Register(esc.HTTPErrors)
_ = registry.Register(esc.RequestSize)
if esc.IndexName == "" {
esc.IndexName = default_metrics_metadata_index
}
if esc.IndexDateFmt == "" {
esc.DirectoriesIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, directories_index_suffix)
esc.MetricsIndexAlias = fmt.Sprintf("%s_%s", esc.IndexName, metrics_index_suffix)
}
esc.KnownIndices = map[string]bool{}
return &esc
}
func createElasticSearchClient(servers []string, username, password string, allow_insecure_tls bool) (*elasticsearch.Client, error) {
cfg := elasticsearch.Config{
Addresses: servers,
Username: username,
Password: password,
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: allow_insecure_tls,
},
},
}
es, err := elasticsearch.NewClient(cfg)
if err != nil {
log.Fatalf("Error creating the ElasticSearch client: %s", err)
}
_, err = es.Info()
if err != nil |
return es, err
}
// NewBgMetadataElasticSearchConnectorWithDefaults is the public contructor of BgMetadataElasticSearchConnector
func NewBgMetadataElasticSearchConnectorWithDefaults(cfg *cfg.BgMetadataESConfig) *BgMetadataElasticSearchConnector {
es, err := createElasticSearchClient(cfg.StorageServers, cfg.Username, cfg.Password, cfg.AllowInsecureTLS)
if err != nil {
log.Fatalf("Could not create ElasticSearch connector: %v", err)
}
return newBgMetadataElasticSearchConnector(es, prometheus.DefaultRegisterer, cfg.BulkSize, cfg.MaxRetry, cfg.IndexName, cfg.IndexDateFmt)
}
func (esc *BgMetadataElasticSearchConnector) Close() {
}
func (esc *BgMetadataElasticSearchConnector) createIndicesAndMapping(metricIndexName, directoryIndexName string) error {
indices := []struct{ name, mapping string }{{metricIndexName, metricsMapping}, {directoryIndexName, dirMapping}}
for _, index := range indices {
indexCreateRequest := esapi.IndicesCreateRequest{Index: index.name}
res, err := indexCreateRequest.Do(context.Background(), esc.client)
esc.logger.Info("using index", zap.String("name", index.name))
// extract TODO error deserialize
r := strings.NewReader(index.mapping)
request := esapi.IndicesPutMappingRequest{Index: []string{index.name}, Body: r, DocumentType: documentType}
res, err = request.Do(context.Background(), esc.client)
if err != nil {
return fmt.Errorf("Could not set ElasticSearch mapping: %w", err)
}
if res.StatusCode != http.StatusOK {
errorMessage, _ := ioutil.ReadAll(res.Body)
return fmt.Errorf("Could not set ElasticSearch mapping (status %d, error: %s)", res.StatusCode, errorMessage)
}
}
return nil
}
// UpdateMetricMetadata stores the metric in a buffer, will bulkupdate when at full cap
// threadsafe
func (esc *BgMetadataElasticSearchConnector) UpdateMetricMetadata(metric *Metric) error {
return esc.addDocumentToBuff(metric)
}
func (esc *BgMetadataElasticSearchConnector) addDocumentToBuff(doc ElasticSearchDocument) error {
esc.mux.Lock()
defer esc.mux.Unlock()
esc.bulkBuffer = append(esc.bulkBuffer, doc)
if len(esc.bulkBuffer) == cap(esc.bulkBuffer) {
esc.sendAndClearBuffer()
}
return nil
}
func (esc *BgMetadataElasticSearchConnector) sendAndClearBuffer() error {
defer esc.clearBuffer()
metricIndex, directoryIndex, err := esc.getIndices()
var errorMessage []byte
var statusCode int
if err != nil {
esc.UpdatedDocuments.WithLabelValues("failure").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not get index: %w", err)
}
timeBeforeBuild := time.Now()
requestBody := BuildElasticSearchDocumentMulti(metricIndex, directoryIndex, esc.bulkBuffer)
esc.DocumentBuildDurationMs.Observe(float64(time.Since(timeBeforeBuild).Milliseconds()))
esc.RequestSize.Observe(float64(len(requestBody)))
for attempt := uint(0); attempt <= esc.MaxRetry; attempt++ {
res, err := esc.bulkUpdate(requestBody)
if err != nil {
// esapi resturns a nil body in case of error
esc.UpdatedDocuments.WithLabelValues("failure", "any").Add(float64(len(esc.bulkBuffer)))
return fmt.Errorf("Could not write to index: %w", err)
}
if !res.IsError() {
esc.updateInternalMetrics(res)
res.Body.Close()
return nil
} else {
esc.HTTPErrors.WithLabelValues(strconv.Itoa(res.StatusCode)).Inc()
statusCode = res.StatusCode
errorMessage, _ = ioutil.ReadAll(res.Body)
res | {
log.Fatalf("Error getting ElasticSearch information response: %s", err)
} | conditional_block |
report_utils.py | y=best_objectives,
title="Best objective found vs. # of iterations",
ylabel=metric_name,
model_transitions=model_transitions,
optimization_direction=optimization_direction,
plot_trial_points=True,
)
def _get_objective_v_param_plot(
search_space: SearchSpace,
model: ModelBridge,
metric_name: str,
trials: Dict[int, BaseTrial],
) -> Optional[go.Figure]:
range_params = list(search_space.range_parameters.keys())
if len(range_params) == 1:
# individual parameter slice plot
output_slice_plot = plot_slice_plotly(
model=not_none(model),
param_name=range_params[0],
metric_name=metric_name,
generator_runs_dict={
str(t.index): not_none(checked_cast(Trial, t).generator_run)
for t in trials.values()
},
)
return output_slice_plot
if len(range_params) > 1:
# contour plot
output_contour_plot = interact_contour_plotly(
model=not_none(model),
metric_name=metric_name,
)
return output_contour_plot
# if search space contains no range params
logger.warning(
"_get_objective_v_param_plot requires a search space with at least one "
"RangeParameter. Returning None."
)
return None
def _get_suffix(input_str: str, delim: str = ".", n_chunks: int = 1) -> str:
return delim.join(input_str.split(delim)[-n_chunks:])
def _get_shortest_unique_suffix_dict(
input_str_list: List[str], delim: str = "."
) -> Dict[str, str]:
"""Maps a list of strings to their shortest unique suffixes
Maps all original strings to the smallest number of chunks, as specified by
delim, that are not a suffix of any other original string. If the original
string was a suffix of another string, map it to its unaltered self.
Args:
input_str_list: a list of strings to create the suffix mapping for
delim: the delimiter used to split up the strings into meaningful chunks
Returns:
dict: A dict with the original strings as keys and their abbreviations as
values
"""
# all input strings must be unique
assert len(input_str_list) == len(set(input_str_list))
if delim == "":
raise ValueError("delim must be a non-empty string.")
suffix_dict = defaultdict(list)
# initialize suffix_dict with last chunk
for istr in input_str_list:
suffix_dict[_get_suffix(istr, delim=delim, n_chunks=1)].append(istr)
max_chunks = max(len(istr.split(delim)) for istr in input_str_list)
if max_chunks == 1:
return {istr: istr for istr in input_str_list}
# the upper range of this loop is `max_chunks + 2` because:
# - `i` needs to take the value of `max_chunks`, hence one +1
# - the contents of the loop are run one more time to check if `all_unique`,
# hence the other +1
for i in range(2, max_chunks + 2):
new_dict = defaultdict(list)
all_unique = True
for suffix, suffix_str_list in suffix_dict.items():
if len(suffix_str_list) > 1:
all_unique = False
for istr in suffix_str_list:
new_dict[_get_suffix(istr, delim=delim, n_chunks=i)].append(istr)
else:
new_dict[suffix] = suffix_str_list
if all_unique:
if len(set(input_str_list)) != len(suffix_dict.keys()):
break
return {
suffix_str_list[0]: suffix
for suffix, suffix_str_list in suffix_dict.items()
}
suffix_dict = new_dict
# If this function has not yet exited, some input strings still share a suffix.
# This is not expected, but in this case, the function will return the identity
# mapping, i.e., a dict with the original strings as both keys and values.
logger.warning(
"Something went wrong. Returning dictionary with original strings as keys and "
"values."
)
return {istr: istr for istr in input_str_list}
def get_standard_plots(
experiment: Experiment, generation_strategy: Optional[GenerationStrategy]
) -> List[go.Figure]:
"""Extract standard plots for single-objective optimization.
Extracts a list of plots from an Experiment and GenerationStrategy of general
interest to an Ax user. Currently not supported are
- TODO: multi-objective optimization
- TODO: ChoiceParameter plots
Args:
- experiment: the Experiment from which to obtain standard plots.
- generation_strategy: the GenerationStrategy used to suggest trial parameters
in experiment
Returns:
- a plot of objective value vs. trial index, to show experiment progression
- a plot of objective value vs. range parameter values, only included if the
model associated with generation_strategy can create predictions. This
consists of:
- a plot_slice plot if the search space contains one range parameter
- an interact_contour plot if the search space contains multiple
range parameters
"""
objective = not_none(experiment.optimization_config).objective
if isinstance(objective, MultiObjective):
logger.warning(
"get_standard_plots does not currently support MultiObjective "
"optimization experiments. Returning an empty list."
)
return []
if isinstance(objective, ScalarizedObjective):
logger.warning(
"get_standard_plots does not currently support ScalarizedObjective "
"optimization experiments. Returning an empty list."
)
return []
if experiment.fetch_data().df.empty:
logger.info(f"Experiment {experiment} does not yet have data, nothing to plot.")
return []
output_plot_list = []
output_plot_list.append(
_get_objective_trace_plot(
experiment=experiment,
metric_name=not_none(experiment.optimization_config).objective.metric.name,
# TODO: Adjust `model_transitions` to case where custom trials are present
# and generation strategy does not start right away.
model_transitions=not_none(generation_strategy).model_transitions
if generation_strategy is not None
else [],
optimization_direction=(
"minimize"
if not_none(experiment.optimization_config).objective.minimize
else "maximize"
),
)
)
# Objective vs. parameter plot requires a `Model`, so add it only if model
# is alrady available. In cases where initially custom trials are attached,
# model might not yet be set on the generation strategy.
if generation_strategy and generation_strategy.model:
model = not_none(not_none(generation_strategy).model)
try:
output_plot_list.append(
_get_objective_v_param_plot(
search_space=experiment.search_space,
model=model,
metric_name=not_none(
experiment.optimization_config
).objective.metric.name,
trials=experiment.trials,
)
)
output_plot_list.append(_get_cross_validation_plot(model))
except NotImplementedError:
# Model does not implement `predict` method.
pass
return [plot for plot in output_plot_list if plot is not None]
def exp_to_df(
exp: Experiment,
metrics: Optional[List[Metric]] = None,
run_metadata_fields: Optional[List[str]] = None,
trial_properties_fields: Optional[List[str]] = None,
**kwargs: Any,
) -> pd.DataFrame:
"""Transforms an experiment to a DataFrame. Only supports Experiment and
SimpleExperiment.
Transforms an Experiment into a dataframe with rows keyed by trial_index
and arm_name, metrics pivoted into one row.
Args:
exp: An Experiment that may have pending trials.
metrics: Override list of metrics to return. Return all metrics if None.
run_metadata_fields: fields to extract from trial.run_metadata for trial
in experiment.trials. If there are multiple arms per trial, these
fields will be replicated across the arms of a trial.
trial_properties_fields: fields to extract from trial._properties for trial
in experiment.trials. If there are multiple arms per trial, these fields
will be replicated across the arms of a trial. Output columns names will be
prepended with "trial_properties_".
**kwargs: Custom named arguments, useful for passing complex
objects from call-site to the `fetch_data` callback.
Returns:
DataFrame: A dataframe of inputs, metadata and metrics by trial and arm. If
no trials are available, returns an empty dataframe. If no metric ouputs are
available, returns a dataframe of inputs and metadata.
"""
def prep_return(
df: pd.DataFrame, drop_col: str, sort_by: List[str]
) -> pd.DataFrame:
return not_none(not_none(df.drop(drop_col, axis=1)).sort_values(sort_by))
# Accept Experiment and SimpleExperiment
if isinstance(exp, MultiTypeExperiment):
raise ValueError("Cannot transform MultiTypeExperiments to DataFrames.")
key_components = ["trial_index", "arm_name"]
# Get each trial-arm with parameters
arms_df = pd.DataFrame()
for trial_index, trial in exp | optimization_direction: Optional[str] = None,
) -> Optional[go.Figure]:
best_objectives = np.array([experiment.fetch_data().df["mean"]])
return optimization_trace_single_method_plotly( | random_line_split | |
report_utils.py | if max_chunks == 1:
return {istr: istr for istr in input_str_list}
# the upper range of this loop is `max_chunks + 2` because:
# - `i` needs to take the value of `max_chunks`, hence one +1
# - the contents of the loop are run one more time to check if `all_unique`,
# hence the other +1
for i in range(2, max_chunks + 2):
new_dict = defaultdict(list)
all_unique = True
for suffix, suffix_str_list in suffix_dict.items():
if len(suffix_str_list) > 1:
all_unique = False
for istr in suffix_str_list:
new_dict[_get_suffix(istr, delim=delim, n_chunks=i)].append(istr)
else:
new_dict[suffix] = suffix_str_list
if all_unique:
if len(set(input_str_list)) != len(suffix_dict.keys()):
break
return {
suffix_str_list[0]: suffix
for suffix, suffix_str_list in suffix_dict.items()
}
suffix_dict = new_dict
# If this function has not yet exited, some input strings still share a suffix.
# This is not expected, but in this case, the function will return the identity
# mapping, i.e., a dict with the original strings as both keys and values.
logger.warning(
"Something went wrong. Returning dictionary with original strings as keys and "
"values."
)
return {istr: istr for istr in input_str_list}
def get_standard_plots(
experiment: Experiment, generation_strategy: Optional[GenerationStrategy]
) -> List[go.Figure]:
"""Extract standard plots for single-objective optimization.
Extracts a list of plots from an Experiment and GenerationStrategy of general
interest to an Ax user. Currently not supported are
- TODO: multi-objective optimization
- TODO: ChoiceParameter plots
Args:
- experiment: the Experiment from which to obtain standard plots.
- generation_strategy: the GenerationStrategy used to suggest trial parameters
in experiment
Returns:
- a plot of objective value vs. trial index, to show experiment progression
- a plot of objective value vs. range parameter values, only included if the
model associated with generation_strategy can create predictions. This
consists of:
- a plot_slice plot if the search space contains one range parameter
- an interact_contour plot if the search space contains multiple
range parameters
"""
objective = not_none(experiment.optimization_config).objective
if isinstance(objective, MultiObjective):
logger.warning(
"get_standard_plots does not currently support MultiObjective "
"optimization experiments. Returning an empty list."
)
return []
if isinstance(objective, ScalarizedObjective):
logger.warning(
"get_standard_plots does not currently support ScalarizedObjective "
"optimization experiments. Returning an empty list."
)
return []
if experiment.fetch_data().df.empty:
logger.info(f"Experiment {experiment} does not yet have data, nothing to plot.")
return []
output_plot_list = []
output_plot_list.append(
_get_objective_trace_plot(
experiment=experiment,
metric_name=not_none(experiment.optimization_config).objective.metric.name,
# TODO: Adjust `model_transitions` to case where custom trials are present
# and generation strategy does not start right away.
model_transitions=not_none(generation_strategy).model_transitions
if generation_strategy is not None
else [],
optimization_direction=(
"minimize"
if not_none(experiment.optimization_config).objective.minimize
else "maximize"
),
)
)
# Objective vs. parameter plot requires a `Model`, so add it only if model
# is alrady available. In cases where initially custom trials are attached,
# model might not yet be set on the generation strategy.
if generation_strategy and generation_strategy.model:
model = not_none(not_none(generation_strategy).model)
try:
output_plot_list.append(
_get_objective_v_param_plot(
search_space=experiment.search_space,
model=model,
metric_name=not_none(
experiment.optimization_config
).objective.metric.name,
trials=experiment.trials,
)
)
output_plot_list.append(_get_cross_validation_plot(model))
except NotImplementedError:
# Model does not implement `predict` method.
pass
return [plot for plot in output_plot_list if plot is not None]
def exp_to_df(
exp: Experiment,
metrics: Optional[List[Metric]] = None,
run_metadata_fields: Optional[List[str]] = None,
trial_properties_fields: Optional[List[str]] = None,
**kwargs: Any,
) -> pd.DataFrame:
"""Transforms an experiment to a DataFrame. Only supports Experiment and
SimpleExperiment.
Transforms an Experiment into a dataframe with rows keyed by trial_index
and arm_name, metrics pivoted into one row.
Args:
exp: An Experiment that may have pending trials.
metrics: Override list of metrics to return. Return all metrics if None.
run_metadata_fields: fields to extract from trial.run_metadata for trial
in experiment.trials. If there are multiple arms per trial, these
fields will be replicated across the arms of a trial.
trial_properties_fields: fields to extract from trial._properties for trial
in experiment.trials. If there are multiple arms per trial, these fields
will be replicated across the arms of a trial. Output columns names will be
prepended with "trial_properties_".
**kwargs: Custom named arguments, useful for passing complex
objects from call-site to the `fetch_data` callback.
Returns:
DataFrame: A dataframe of inputs, metadata and metrics by trial and arm. If
no trials are available, returns an empty dataframe. If no metric ouputs are
available, returns a dataframe of inputs and metadata.
"""
def prep_return(
df: pd.DataFrame, drop_col: str, sort_by: List[str]
) -> pd.DataFrame:
return not_none(not_none(df.drop(drop_col, axis=1)).sort_values(sort_by))
# Accept Experiment and SimpleExperiment
if isinstance(exp, MultiTypeExperiment):
raise ValueError("Cannot transform MultiTypeExperiments to DataFrames.")
key_components = ["trial_index", "arm_name"]
# Get each trial-arm with parameters
arms_df = pd.DataFrame()
for trial_index, trial in exp.trials.items():
for arm in trial.arms:
arms_df = arms_df.append(
{"arm_name": arm.name, "trial_index": trial_index, **arm.parameters},
ignore_index=True,
)
# Fetch results; in case arms_df is empty, return empty results (legacy behavior)
results = exp.fetch_data(metrics, **kwargs).df
if len(arms_df.index) == 0:
if len(results.index) != 0:
raise ValueError(
"exp.fetch_data().df returned more rows than there are experimental "
"arms. This is an inconsistent experimental state. Please report to "
"Ax support."
)
return results
# Create key column from key_components
arms_df["trial_index"] = arms_df["trial_index"].astype(int)
key_col = "-".join(key_components)
key_vals = arms_df[key_components[0]].astype("str") + arms_df[
key_components[1]
].astype("str")
arms_df[key_col] = key_vals
# Add trial status
trials = exp.trials.items()
trial_to_status = {index: trial.status.name for index, trial in trials}
arms_df["trial_status"] = [
trial_to_status[trial_index] for trial_index in arms_df.trial_index
]
# Add generator_run model keys
arms_df["generator_model"] = [
# This accounts for the generic case that generator_runs is a list of arbitrary
# length. If all elements are `None`, this yields an empty string. Repeated
# generator models within a trial are condensed via a set comprehension.
", ".join(
{
not_none(generator_run._model_key)
for generator_run in exp.trials[trial_index].generator_runs
if generator_run._model_key is not None
}
)
if trial_index in exp.trials
else ""
for trial_index in arms_df.trial_index
]
# replace all unknown generator_models (denoted by empty strings) with "Unknown"
arms_df["generator_model"] = [
"Unknown" if generator_model == "" else generator_model
for generator_model in arms_df["generator_model"]
]
# Add any trial properties fields to arms_df
if trial_properties_fields is not None:
| if not (
isinstance(trial_properties_fields, list)
and all(isinstance(field, str) for field in trial_properties_fields)
):
raise ValueError(
"trial_properties_fields must be List[str] or None. "
f"Got {trial_properties_fields}"
)
# add trial._properties fields
for field in trial_properties_fields:
trial_to_properties_field = {
index: (
trial._properties[field] if field in trial._properties else None
)
for index, trial in trials
}
if any(trial_to_properties_field.values()): # field present for any trial
if not all(
trial_to_properties_field.values() | conditional_block | |
report_utils.py | (
"_get_objective_v_param_plot requires a search space with at least one "
"RangeParameter. Returning None."
)
return None
def _get_suffix(input_str: str, delim: str = ".", n_chunks: int = 1) -> str:
return delim.join(input_str.split(delim)[-n_chunks:])
def _get_shortest_unique_suffix_dict(
input_str_list: List[str], delim: str = "."
) -> Dict[str, str]:
"""Maps a list of strings to their shortest unique suffixes
Maps all original strings to the smallest number of chunks, as specified by
delim, that are not a suffix of any other original string. If the original
string was a suffix of another string, map it to its unaltered self.
Args:
input_str_list: a list of strings to create the suffix mapping for
delim: the delimiter used to split up the strings into meaningful chunks
Returns:
dict: A dict with the original strings as keys and their abbreviations as
values
"""
# all input strings must be unique
assert len(input_str_list) == len(set(input_str_list))
if delim == "":
raise ValueError("delim must be a non-empty string.")
suffix_dict = defaultdict(list)
# initialize suffix_dict with last chunk
for istr in input_str_list:
suffix_dict[_get_suffix(istr, delim=delim, n_chunks=1)].append(istr)
max_chunks = max(len(istr.split(delim)) for istr in input_str_list)
if max_chunks == 1:
return {istr: istr for istr in input_str_list}
# the upper range of this loop is `max_chunks + 2` because:
# - `i` needs to take the value of `max_chunks`, hence one +1
# - the contents of the loop are run one more time to check if `all_unique`,
# hence the other +1
for i in range(2, max_chunks + 2):
new_dict = defaultdict(list)
all_unique = True
for suffix, suffix_str_list in suffix_dict.items():
if len(suffix_str_list) > 1:
all_unique = False
for istr in suffix_str_list:
new_dict[_get_suffix(istr, delim=delim, n_chunks=i)].append(istr)
else:
new_dict[suffix] = suffix_str_list
if all_unique:
if len(set(input_str_list)) != len(suffix_dict.keys()):
break
return {
suffix_str_list[0]: suffix
for suffix, suffix_str_list in suffix_dict.items()
}
suffix_dict = new_dict
# If this function has not yet exited, some input strings still share a suffix.
# This is not expected, but in this case, the function will return the identity
# mapping, i.e., a dict with the original strings as both keys and values.
logger.warning(
"Something went wrong. Returning dictionary with original strings as keys and "
"values."
)
return {istr: istr for istr in input_str_list}
def get_standard_plots(
experiment: Experiment, generation_strategy: Optional[GenerationStrategy]
) -> List[go.Figure]:
"""Extract standard plots for single-objective optimization.
Extracts a list of plots from an Experiment and GenerationStrategy of general
interest to an Ax user. Currently not supported are
- TODO: multi-objective optimization
- TODO: ChoiceParameter plots
Args:
- experiment: the Experiment from which to obtain standard plots.
- generation_strategy: the GenerationStrategy used to suggest trial parameters
in experiment
Returns:
- a plot of objective value vs. trial index, to show experiment progression
- a plot of objective value vs. range parameter values, only included if the
model associated with generation_strategy can create predictions. This
consists of:
- a plot_slice plot if the search space contains one range parameter
- an interact_contour plot if the search space contains multiple
range parameters
"""
objective = not_none(experiment.optimization_config).objective
if isinstance(objective, MultiObjective):
logger.warning(
"get_standard_plots does not currently support MultiObjective "
"optimization experiments. Returning an empty list."
)
return []
if isinstance(objective, ScalarizedObjective):
logger.warning(
"get_standard_plots does not currently support ScalarizedObjective "
"optimization experiments. Returning an empty list."
)
return []
if experiment.fetch_data().df.empty:
logger.info(f"Experiment {experiment} does not yet have data, nothing to plot.")
return []
output_plot_list = []
output_plot_list.append(
_get_objective_trace_plot(
experiment=experiment,
metric_name=not_none(experiment.optimization_config).objective.metric.name,
# TODO: Adjust `model_transitions` to case where custom trials are present
# and generation strategy does not start right away.
model_transitions=not_none(generation_strategy).model_transitions
if generation_strategy is not None
else [],
optimization_direction=(
"minimize"
if not_none(experiment.optimization_config).objective.minimize
else "maximize"
),
)
)
# Objective vs. parameter plot requires a `Model`, so add it only if model
# is alrady available. In cases where initially custom trials are attached,
# model might not yet be set on the generation strategy.
if generation_strategy and generation_strategy.model:
model = not_none(not_none(generation_strategy).model)
try:
output_plot_list.append(
_get_objective_v_param_plot(
search_space=experiment.search_space,
model=model,
metric_name=not_none(
experiment.optimization_config
).objective.metric.name,
trials=experiment.trials,
)
)
output_plot_list.append(_get_cross_validation_plot(model))
except NotImplementedError:
# Model does not implement `predict` method.
pass
return [plot for plot in output_plot_list if plot is not None]
def exp_to_df(
exp: Experiment,
metrics: Optional[List[Metric]] = None,
run_metadata_fields: Optional[List[str]] = None,
trial_properties_fields: Optional[List[str]] = None,
**kwargs: Any,
) -> pd.DataFrame:
"""Transforms an experiment to a DataFrame. Only supports Experiment and
SimpleExperiment.
Transforms an Experiment into a dataframe with rows keyed by trial_index
and arm_name, metrics pivoted into one row.
Args:
exp: An Experiment that may have pending trials.
metrics: Override list of metrics to return. Return all metrics if None.
run_metadata_fields: fields to extract from trial.run_metadata for trial
in experiment.trials. If there are multiple arms per trial, these
fields will be replicated across the arms of a trial.
trial_properties_fields: fields to extract from trial._properties for trial
in experiment.trials. If there are multiple arms per trial, these fields
will be replicated across the arms of a trial. Output columns names will be
prepended with "trial_properties_".
**kwargs: Custom named arguments, useful for passing complex
objects from call-site to the `fetch_data` callback.
Returns:
DataFrame: A dataframe of inputs, metadata and metrics by trial and arm. If
no trials are available, returns an empty dataframe. If no metric ouputs are
available, returns a dataframe of inputs and metadata.
"""
def prep_return(
df: pd.DataFrame, drop_col: str, sort_by: List[str]
) -> pd.DataFrame:
|
# Accept Experiment and SimpleExperiment
if isinstance(exp, MultiTypeExperiment):
raise ValueError("Cannot transform MultiTypeExperiments to DataFrames.")
key_components = ["trial_index", "arm_name"]
# Get each trial-arm with parameters
arms_df = pd.DataFrame()
for trial_index, trial in exp.trials.items():
for arm in trial.arms:
arms_df = arms_df.append(
{"arm_name": arm.name, "trial_index": trial_index, **arm.parameters},
ignore_index=True,
)
# Fetch results; in case arms_df is empty, return empty results (legacy behavior)
results = exp.fetch_data(metrics, **kwargs).df
if len(arms_df.index) == 0:
if len(results.index) != 0:
raise ValueError(
"exp.fetch_data().df returned more rows than there are experimental "
"arms. This is an inconsistent experimental state. Please report to "
"Ax support."
)
return results
# Create key column from key_components
arms_df["trial_index"] = arms_df["trial_index"].astype(int)
key_col = "-".join(key_components)
key_vals = arms_df[key_components[0]].astype("str") + arms_df[
key_components[1]
].astype("str")
arms_df[key_col] = key_vals
# Add trial status
trials = exp.trials.items()
trial_to_status = {index: trial.status.name for index, trial in trials}
arms_df["trial_status"] = [
trial_to_status[trial_index] for trial_index in arms_df.trial_index
]
# Add generator_run model keys
arms_df["generator_model"] = [
| return not_none(not_none(df.drop(drop_col, axis=1)).sort_values(sort_by)) | identifier_body |
report_utils.py | (
"_get_objective_v_param_plot requires a search space with at least one "
"RangeParameter. Returning None."
)
return None
def _get_suffix(input_str: str, delim: str = ".", n_chunks: int = 1) -> str:
return delim.join(input_str.split(delim)[-n_chunks:])
def _get_shortest_unique_suffix_dict(
input_str_list: List[str], delim: str = "."
) -> Dict[str, str]:
"""Maps a list of strings to their shortest unique suffixes
Maps all original strings to the smallest number of chunks, as specified by
delim, that are not a suffix of any other original string. If the original
string was a suffix of another string, map it to its unaltered self.
Args:
input_str_list: a list of strings to create the suffix mapping for
delim: the delimiter used to split up the strings into meaningful chunks
Returns:
dict: A dict with the original strings as keys and their abbreviations as
values
"""
# all input strings must be unique
assert len(input_str_list) == len(set(input_str_list))
if delim == "":
raise ValueError("delim must be a non-empty string.")
suffix_dict = defaultdict(list)
# initialize suffix_dict with last chunk
for istr in input_str_list:
suffix_dict[_get_suffix(istr, delim=delim, n_chunks=1)].append(istr)
max_chunks = max(len(istr.split(delim)) for istr in input_str_list)
if max_chunks == 1:
return {istr: istr for istr in input_str_list}
# the upper range of this loop is `max_chunks + 2` because:
# - `i` needs to take the value of `max_chunks`, hence one +1
# - the contents of the loop are run one more time to check if `all_unique`,
# hence the other +1
for i in range(2, max_chunks + 2):
new_dict = defaultdict(list)
all_unique = True
for suffix, suffix_str_list in suffix_dict.items():
if len(suffix_str_list) > 1:
all_unique = False
for istr in suffix_str_list:
new_dict[_get_suffix(istr, delim=delim, n_chunks=i)].append(istr)
else:
new_dict[suffix] = suffix_str_list
if all_unique:
if len(set(input_str_list)) != len(suffix_dict.keys()):
break
return {
suffix_str_list[0]: suffix
for suffix, suffix_str_list in suffix_dict.items()
}
suffix_dict = new_dict
# If this function has not yet exited, some input strings still share a suffix.
# This is not expected, but in this case, the function will return the identity
# mapping, i.e., a dict with the original strings as both keys and values.
logger.warning(
"Something went wrong. Returning dictionary with original strings as keys and "
"values."
)
return {istr: istr for istr in input_str_list}
def get_standard_plots(
experiment: Experiment, generation_strategy: Optional[GenerationStrategy]
) -> List[go.Figure]:
"""Extract standard plots for single-objective optimization.
Extracts a list of plots from an Experiment and GenerationStrategy of general
interest to an Ax user. Currently not supported are
- TODO: multi-objective optimization
- TODO: ChoiceParameter plots
Args:
- experiment: the Experiment from which to obtain standard plots.
- generation_strategy: the GenerationStrategy used to suggest trial parameters
in experiment
Returns:
- a plot of objective value vs. trial index, to show experiment progression
- a plot of objective value vs. range parameter values, only included if the
model associated with generation_strategy can create predictions. This
consists of:
- a plot_slice plot if the search space contains one range parameter
- an interact_contour plot if the search space contains multiple
range parameters
"""
objective = not_none(experiment.optimization_config).objective
if isinstance(objective, MultiObjective):
logger.warning(
"get_standard_plots does not currently support MultiObjective "
"optimization experiments. Returning an empty list."
)
return []
if isinstance(objective, ScalarizedObjective):
logger.warning(
"get_standard_plots does not currently support ScalarizedObjective "
"optimization experiments. Returning an empty list."
)
return []
if experiment.fetch_data().df.empty:
logger.info(f"Experiment {experiment} does not yet have data, nothing to plot.")
return []
output_plot_list = []
output_plot_list.append(
_get_objective_trace_plot(
experiment=experiment,
metric_name=not_none(experiment.optimization_config).objective.metric.name,
# TODO: Adjust `model_transitions` to case where custom trials are present
# and generation strategy does not start right away.
model_transitions=not_none(generation_strategy).model_transitions
if generation_strategy is not None
else [],
optimization_direction=(
"minimize"
if not_none(experiment.optimization_config).objective.minimize
else "maximize"
),
)
)
# Objective vs. parameter plot requires a `Model`, so add it only if model
# is alrady available. In cases where initially custom trials are attached,
# model might not yet be set on the generation strategy.
if generation_strategy and generation_strategy.model:
model = not_none(not_none(generation_strategy).model)
try:
output_plot_list.append(
_get_objective_v_param_plot(
search_space=experiment.search_space,
model=model,
metric_name=not_none(
experiment.optimization_config
).objective.metric.name,
trials=experiment.trials,
)
)
output_plot_list.append(_get_cross_validation_plot(model))
except NotImplementedError:
# Model does not implement `predict` method.
pass
return [plot for plot in output_plot_list if plot is not None]
def exp_to_df(
exp: Experiment,
metrics: Optional[List[Metric]] = None,
run_metadata_fields: Optional[List[str]] = None,
trial_properties_fields: Optional[List[str]] = None,
**kwargs: Any,
) -> pd.DataFrame:
"""Transforms an experiment to a DataFrame. Only supports Experiment and
SimpleExperiment.
Transforms an Experiment into a dataframe with rows keyed by trial_index
and arm_name, metrics pivoted into one row.
Args:
exp: An Experiment that may have pending trials.
metrics: Override list of metrics to return. Return all metrics if None.
run_metadata_fields: fields to extract from trial.run_metadata for trial
in experiment.trials. If there are multiple arms per trial, these
fields will be replicated across the arms of a trial.
trial_properties_fields: fields to extract from trial._properties for trial
in experiment.trials. If there are multiple arms per trial, these fields
will be replicated across the arms of a trial. Output columns names will be
prepended with "trial_properties_".
**kwargs: Custom named arguments, useful for passing complex
objects from call-site to the `fetch_data` callback.
Returns:
DataFrame: A dataframe of inputs, metadata and metrics by trial and arm. If
no trials are available, returns an empty dataframe. If no metric ouputs are
available, returns a dataframe of inputs and metadata.
"""
def | (
df: pd.DataFrame, drop_col: str, sort_by: List[str]
) -> pd.DataFrame:
return not_none(not_none(df.drop(drop_col, axis=1)).sort_values(sort_by))
# Accept Experiment and SimpleExperiment
if isinstance(exp, MultiTypeExperiment):
raise ValueError("Cannot transform MultiTypeExperiments to DataFrames.")
key_components = ["trial_index", "arm_name"]
# Get each trial-arm with parameters
arms_df = pd.DataFrame()
for trial_index, trial in exp.trials.items():
for arm in trial.arms:
arms_df = arms_df.append(
{"arm_name": arm.name, "trial_index": trial_index, **arm.parameters},
ignore_index=True,
)
# Fetch results; in case arms_df is empty, return empty results (legacy behavior)
results = exp.fetch_data(metrics, **kwargs).df
if len(arms_df.index) == 0:
if len(results.index) != 0:
raise ValueError(
"exp.fetch_data().df returned more rows than there are experimental "
"arms. This is an inconsistent experimental state. Please report to "
"Ax support."
)
return results
# Create key column from key_components
arms_df["trial_index"] = arms_df["trial_index"].astype(int)
key_col = "-".join(key_components)
key_vals = arms_df[key_components[0]].astype("str") + arms_df[
key_components[1]
].astype("str")
arms_df[key_col] = key_vals
# Add trial status
trials = exp.trials.items()
trial_to_status = {index: trial.status.name for index, trial in trials}
arms_df["trial_status"] = [
trial_to_status[trial_index] for trial_index in arms_df.trial_index
]
# Add generator_run model keys
arms_df["generator_model"] = [
| prep_return | identifier_name |
getlola.py | ):
pLon2 = pointList[0][0]
pLat2 = pointList[0][1]
else:
# print(i+1)
try:
pLon2 = pointList[i + 1][0]
pLat2 = pointList[i + 1][1]
except IndexError:
break
###转换数值类型
pLon1 = float(pLon1)
pLat1 = float(pLat1)
pLon2 = float(pLon2)
pLat2 = float(pLat2)
aLat = float(aLat)
aLon = float(aLon)
if ((aLat >= pLat1) and (aLat < pLat2)) or ((aLat >= pLat2) and (aLat < pLat1)):
if (abs(pLat1 - pLat2) > 0):
pLon = pLon1 - ((pLon1 - pLon2) * (pLat1 - aLat)) / (pLat1 - pLat2)
if (pLon < aLon):
iSum += 1
if (iSum % 2 != 0):
return True
else:
return False
# 格式化从excel中得到的内容
# def get_file_row(row,file_name):
# wb_1 = openpyxl.load_workbook('%s' % file_name)
# ws_1 = wb_1.active
# colC = ws_1['%s' % row]
# list_1 = [x for x in colC]
# list_2 = []
# for i in list_1:
# list_2.append(i.value)
# return list_2
# 查询获得基站的名称、经度、纬度
def get_station_lo_la():
sql_sec_name_lo_la = "SELECT A.B_STATION_NAME,A.LONGITUDE,A.LATITUDE FROM B_BASE_STATION_INFO A"
list_station_lo_la = Oracle_Query(sql_sec_name_lo_la)
return list_station_lo_la
# 查询获得网格的id、名称、网格坐标圈 指定市
def get_point_2(org_id, orgLevel):
sql_sec_orgid_orgname_point = "select r.org_code,r.org_name,r.point " \
"from (" \
"select a.org_code,a.org_name,a.p_org_id,a.org_level,b.point " \
"from s_orgnization a,p_map_draw b " \
"where a.org_id=b.org_id " \
"and b.state='00A' " \
"and a.state='00A' " \
"and a.org_id in ( " \
"select org_id from s_orgnization start with org_id='%s' " \
"connect by prior org_id=p_org_id)) r,s_orgnization o " \
"where r.p_org_id=o.org_id " \
"and r.org_level='%s'" % (str(org_id), str(orgLevel))
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 查询获得网格的id、名称、网格坐标圈
def get_point():
sql_sec_orgid_orgname_point = "select a.org_id,a.org_name,b.point from s_orgnization a " \
"left join p_map_draw b on b.org_id = a.org_id" \
" where a.org_level='5'"
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 格式化cblob字段
def expand_list(tList):
mList = tList.read().split(";")
flag = 0
for i in mList:
mList[flag] = mList[flag].split(',')
flag += 1
return mList
# 修改基站grid_id bak表
def update_station_grid_id(gridId, bStationName):
sqlUpdateGridId = "update b_base_station_info_bak a " \
"set a.grid_id='%s' " \
"where a.b_station_name='%s'" % (str(gridId), bStationName)
updateResult = Oracle_Exec(sqlUpdateGridId)
return updateResult
# 对比两个b_station_name的grid_id是否相同
def judge_station_name(stationName):
sqlGridIdFromInfo = " select grid_id from b_base_station_info_bak where b_station_name = '%s'" % stationName
sqlGridIdFromMid = "select grid_id from B_STATION_GRID_MID where b_station_name = '%s'" % stationName
gridIdFromInfo = Oracle_Query(sqlGridIdFromInfo)
gridIdFromMid = Oracle_Query(sqlGridIdFromMid)
if gridIdFromInfo == gridIdFromMid:
return False
else:
return gridIdFromMid
# 格式化orgIdNamePoint
def expand_orgidnamepoint(orgIdNamePoint):
flag = 0
for i in orgIdNamePoint:
if i[2] is not None:
orgIdNamePoint[flag] = list(orgIdNamePoint[flag])
orgIdNamePoint[flag][2] = expand_list(i[2])
else:
continue
flag += 1
return orgIdNamePoint
# 获取数据入中间表
def in_station_mid_table(stationLoLa, orgIdNamePoint):
for station_name, station_lo, station_la in stationLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(station_lo, station_la, org_point)
if judge_result:
sql_insert_b_station_grid_mid = "insert into b_station_grid_mid (org_name,grid_id,b_station_name) " \
"values ('%s','%s','%s')" % (org_name, ord_id, station_name)
Oracle_Exec(sql_insert_b_station_grid_mid)
break
# 对照中间表修改正式表中的所有数据
def updata_station_all():
sqlSecStationNameFromMid = "select b_station_name from B_STATION_GRID_MID"
stationNameList = Oracle_Query(sqlSecStationNameFromMid)
for stationNameTup in stationNameList:
gridId = judge_station_name(stationNameTup[0])
if gridId:
print(stationNameTup[0])
print(gridId)
update_station_grid_id(gridId[0][0], stationNameTup[0])
else:
continue
# 获取小区的名称以及经纬度
def get_cell_lo_la(cityId, dayID):
"""
:param cityId: 小区所在的城市ID
:return:
"""
sqlGetCellIdLoLa = "SELECT A.CELL_ID,A.LONGITUDE,A.LATITUDE " \
"FROM B_SUBDISTRICT_INFO A " \
"WHERE CITY_ID='%s' " \
"AND A.LONGITUDE IS NOT NULL " \
"AND A.LATITUDE IS NOT NULL " \
"AND A.DAY_ID='%s'" % (str(cityId), str(dayID))
listCellLoLa = Oracle_Query(sqlGetCellIdLoLa)
return listCellLoLa
# 判断小区的结果并录入中间表
def in_cell_mid_table(cellLoLa, orgIdNamePoint, orgLevel, dayId, cityId):
"""
:param cellLoLa: 小区的坐标信息
:param orgIdNamePoint: 网格的坐标范围信息
:param orgLevel: 网格等级
:return: 无返回值
"""
for cellId, cellLo, cellLa in cellLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(cellLo, cellLa, org_point)
if judge_result:
sql_insert_b_cell_mid = "insert into b_cell_mid (day_id,org_name,grid_id,city_id,org_level,cell_id) " \
"values ('%s','%s','%s','%s','%s','%s')" % (
str(dayId), org_name, ord_id, str(cityId), str(orgLevel), cellId)
Oracle_Exec(sql_insert_b_cell_mid)
break
# 判断小区的结果并录入中间表
def in_cell_mid_table_grid_id(cellLoLa, orgIdNamePoint_5, orgIdNamePoint_4, orgLevel_5, orgLevel_4,dayId, cityId):
"""
:param cellLoLa: 小区的坐标信息
:param orgIdNamePoint: 网格的坐标范围信息
:param orgLevel: 网格等级
:return: 无返回值
"""
for cellId, cellLo, cellLa in cellLoLa: # 获取基站的经纬度
flag = 0
for ord_id, org_name, org_point in orgIdNamePoint_5: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(cellLo, cellLa, org_point)
if judge_result:
sql_insert_b_cell_mid = "insert into b_cell_ | mid (day_id,org_name,grid | identifier_name | |
getlola.py | True
except:
conn.rollback()
print("Exec sql failed: %s" % SqlStr)
return False
finally:
cursor.close()
# conn.close()
# 判断坐标是否再坐标圈内
def is_pt_in_poly(aLon, aLat, pointList):
'''''
:param aLon: double 经度
:param aLat: double 纬度
:param pointList: list [(lon, lat)...] 多边形点的顺序需根据顺时针或逆时针，不能乱
'''
iSum = 0
iCount = len(pointList)
if (iCount < 3):
return False
# print("iCount = " + str(iCount))
for i in range(iCount):
pLon1 = pointList[i][0]
pLat1 = pointList[i][1]
if (i == iCount - 1):
pLon2 = pointList[0][0]
pLat2 = pointList[0][1]
else:
# print(i+1)
try:
pLon2 = pointList[i + 1][0]
pLat2 = pointList[i + 1][1]
except IndexError:
break
###转换数值类型
pLon1 = float(pLon1)
pLat1 = float(pLat1)
pLon2 = float(pLon2)
pLat2 = float(pLat2)
aLat = float(aLat)
aLon = float(aLon)
if ((aLat >= pLat1) and (aLat < pLat2)) or ((aLat >= pLat2) and (aLat < pLat1)):
if (abs(pLat1 - pLat2) > 0):
pLon = pLon1 - ((pLon1 - pLon2) * (pLat1 - aLat)) / (pLat1 - pLat2)
if (pLon < aLon):
iSum += 1
if (iSum % 2 != 0):
return True
else:
return False
# 格式化从excel中得到的内容
# def get_file_row(row,file_name):
# wb_1 = openpyxl.load_workbook('%s' % file_name)
# ws_1 = wb_1.active
# colC = ws_1['%s' % row]
# list_1 = [x for x in colC]
# list_2 = []
# for i in list_1:
# list_2.append(i.value)
# return list_2
# 查询获得基站的名称、经度、纬度
def get_station_lo_la():
sql_sec_name_lo_la = "SELECT A.B_STATION_NAME,A.LONGITUDE,A.LATITUDE FROM B_BASE_STATION_INFO A"
list_station_lo_la = Oracle_Query(sql_sec_name_lo_la)
return list_station_lo_la
# 查询获得网格的id、名称、网格坐标圈 指定市
def get_point_2(org_id, orgLevel):
sql_sec_orgid_orgname_point = "select r.org_code,r.org_name,r.point " \
"from (" \
"select a.org_code,a.org_name,a.p_org_id,a.org_level,b.point " \
"from s_orgnization a,p_map_draw b " \
"where a.org_id=b.org_id " \
"and b.state='00A' " \
"and a.state='00A' " \
"and a.org_id in ( " \
"select org_id from s_orgnization start with org_id='%s' " \
"connect by prior org_id=p_org_id)) r,s_orgnization o " \
"where r.p_org_id=o.org_id " \
"and r.org_level='%s'" % (str(org_id), str(orgLevel))
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 查询获得网格的id、名称、网格坐标圈
def get_point():
sql_sec_orgid_orgname_point = "select a.org_id,a.org_name,b.point from s_orgnization a " \
"left join p_map_draw b on b.org_id = a.org_id" \
" where a.org_level='5'"
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 格式化cblob字段
def expand_list(tList):
mList = tList.read().split(";")
flag = 0
for i in mList:
mList[flag] = mList[flag].split(',')
flag += 1
return mList
# 修改基站grid_id bak表
def update_station_grid_id(gridId, bStationName):
sqlUpdateGridId = "update b_base_station_info_bak a " \
"set a.grid_id='%s' " \
"where a.b_station_name='%s'" % (str(gridId), bStationName)
updateResult = Oracle_Exec(sqlUpdateGridId)
return updateResult
# 对比两个b_station_name的grid_id是否相同
def judge_station_name(stationName):
sqlGridIdFromInfo = " select grid_id from b_base_station_info_bak where b_station_name = '%s'" % stationName
sqlGridIdFromMid = "select grid_id from B_STATION_GRID_MID where b_station_name = '%s'" % stationName
gridIdFromInfo = Oracle_Query(sqlGridIdFromInfo)
gridIdFromMid = Oracle_Query(sqlGridIdFromMid)
if gridIdFromInfo == gridIdFromMid:
return False
else:
return gridIdFromMid
# 格式化orgIdNamePoint
def expand_orgidnamepoint(orgIdNamePoint):
flag = 0
for i in orgIdNamePoint:
if i[2] is not None:
orgIdNamePoint[flag] = list(orgIdNamePoint[flag])
orgIdNamePoint[flag][2] = expand_list(i[2])
else:
continue
flag += 1
return orgIdNamePoint
# 获取数据入中间表
def in_station_mid_table(stationLoLa, orgIdNamePoint):
for station_name, station_lo, station_la in stationLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(station_lo, station_la, org_point)
if judge_result:
sql_insert_b_station_grid_mid = "insert into b_station_grid_mid (org_name,grid_id,b_station_name) " \
"values ('%s','%s','%s')" % (org_name, ord_id, station_name)
Oracle_Exec(sql_insert_b_station_grid_mid)
break
# 对照中间表修改正式表中的所有数据
def updata_station_all():
sqlSecStationNameFromMid = "select b_station_name from B_STATION_GRID_MID"
stationNameList = Oracle_Query(sqlSecStationNameFromMid)
for stationNameTup in stationNameList:
gridId = judge_station_name(stationNameTup[0])
if gridId:
print(stationNameTup[0])
print(gridId)
update_station_grid_id(gridId[0][0], stationNameTup[0])
else:
continue
# 获取小区的名称以及经纬度
def get_cell_lo_la(cityId, dayID):
"""
:param cityId: 小区所在的城市ID
:return:
"""
sqlGetCellIdLoLa = "SELECT A.CELL_ID,A.LONGITUDE,A.LATITUDE " \
"FROM B_SUBDISTRICT_INFO A " \
"WHERE CITY_ID='%s' " \
"AND A.LONGITUDE IS NOT NULL " \
"AND A.LATITUDE IS NOT NULL " \
"AND A.DAY_ID='%s'" % (str(cityId), str(dayID))
listCellLoLa = Oracle_Query(sqlGetCellIdLoLa)
return listCellLoLa
# 判断小区的结果并录入中间表
def in_cell_mid_table(cellLoLa, orgIdNamePoint, orgLevel, dayId, cityId):
"""
:param cellLoLa: 小区的坐标信息
:param orgIdNamePoint: 网格的坐标范围信息
:param orgLevel: 网格等级
:return: 无返回值
"""
for cellId, cellLo, cellLa in cellLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list) | judge_result = is_pt_in_poly(cellLo, cellLa, org_point)
if judge_result:
sql_insert_b_cell_mid = "insert into b_cell_mid (day_id,org_name,grid_id,city_id,org_level,cell_id) " \
"values ('%s','%s','%s','%s','%s','%s')" % (
str(dayId), org_name, ord_id, str(cityId), str(orgLevel), cellId)
Oracle_Exec(sql_insert_b_cell_mid)
break
# 判断小区的结果并录入 | random_line_split | |
getlola.py |
except:
conn.rollback()
print("Exec sql failed: %s" % SqlStr)
return False
finally:
cursor.close()
# conn.close()
# 判断坐标是否再坐标圈内
def is_pt_in_poly(aLon, aLat, pointList):
'''''
:param aLon: double 经度
:param aLat: double 纬度
:param pointList: list [(lon, lat)...] 多边形点的顺序需根据顺时针或逆时针，不能乱
'''
iSum = 0
iCount = len(pointList)
if (iCount < 3):
return False
# print("iCount = " + str(iCount))
for i in range(iCount):
pLon1 = pointList[i][0]
pLat1 = pointList[i][1]
if (i == iCount - 1):
pLon2 = pointList[0][0]
pLat2 = pointList[0][1]
else:
# print(i+1)
try:
pLon2 = pointList[i + 1][0]
pLat2 = pointList[i + 1][1]
except IndexError:
| loat(pLat2)
aLat = float(aLat)
aLon = float(aLon)
if ((aLat >= pLat1) and (aLat < pLat2)) or ((aLat >= pLat2) and (aLat < pLat1)):
if (abs(pLat1 - pLat2) > 0):
pLon = pLon1 - ((pLon1 - pLon2) * (pLat1 - aLat)) / (pLat1 - pLat2)
if (pLon < aLon):
iSum += 1
if (iSum % 2 != 0):
return True
else:
return False
# 格式化从excel中得到的内容
# def get_file_row(row,file_name):
# wb_1 = openpyxl.load_workbook('%s' % file_name)
# ws_1 = wb_1.active
# colC = ws_1['%s' % row]
# list_1 = [x for x in colC]
# list_2 = []
# for i in list_1:
# list_2.append(i.value)
# return list_2
# 查询获得基站的名称、经度、纬度
def get_station_lo_la():
sql_sec_name_lo_la = "SELECT A.B_STATION_NAME,A.LONGITUDE,A.LATITUDE FROM B_BASE_STATION_INFO A"
list_station_lo_la = Oracle_Query(sql_sec_name_lo_la)
return list_station_lo_la
# 查询获得网格的id、名称、网格坐标圈 指定市
def get_point_2(org_id, orgLevel):
sql_sec_orgid_orgname_point = "select r.org_code,r.org_name,r.point " \
"from (" \
"select a.org_code,a.org_name,a.p_org_id,a.org_level,b.point " \
"from s_orgnization a,p_map_draw b " \
"where a.org_id=b.org_id " \
"and b.state='00A' " \
"and a.state='00A' " \
"and a.org_id in ( " \
"select org_id from s_orgnization start with org_id='%s' " \
"connect by prior org_id=p_org_id)) r,s_orgnization o " \
"where r.p_org_id=o.org_id " \
"and r.org_level='%s'" % (str(org_id), str(orgLevel))
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 查询获得网格的id、名称、网格坐标圈
def get_point():
sql_sec_orgid_orgname_point = "select a.org_id,a.org_name,b.point from s_orgnization a " \
"left join p_map_draw b on b.org_id = a.org_id" \
" where a.org_level='5'"
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 格式化cblob字段
def expand_list(tList):
mList = tList.read().split(";")
flag = 0
for i in mList:
mList[flag] = mList[flag].split(',')
flag += 1
return mList
# 修改基站grid_id bak表
def update_station_grid_id(gridId, bStationName):
sqlUpdateGridId = "update b_base_station_info_bak a " \
"set a.grid_id='%s' " \
"where a.b_station_name='%s'" % (str(gridId), bStationName)
updateResult = Oracle_Exec(sqlUpdateGridId)
return updateResult
# 对比两个b_station_name的grid_id是否相同
def judge_station_name(stationName):
sqlGridIdFromInfo = " select grid_id from b_base_station_info_bak where b_station_name = '%s'" % stationName
sqlGridIdFromMid = "select grid_id from B_STATION_GRID_MID where b_station_name = '%s'" % stationName
gridIdFromInfo = Oracle_Query(sqlGridIdFromInfo)
gridIdFromMid = Oracle_Query(sqlGridIdFromMid)
if gridIdFromInfo == gridIdFromMid:
return False
else:
return gridIdFromMid
# 格式化orgIdNamePoint
def expand_orgidnamepoint(orgIdNamePoint):
flag = 0
for i in orgIdNamePoint:
if i[2] is not None:
orgIdNamePoint[flag] = list(orgIdNamePoint[flag])
orgIdNamePoint[flag][2] = expand_list(i[2])
else:
continue
flag += 1
return orgIdNamePoint
# 获取数据入中间表
def in_station_mid_table(stationLoLa, orgIdNamePoint):
for station_name, station_lo, station_la in stationLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(station_lo, station_la, org_point)
if judge_result:
sql_insert_b_station_grid_mid = "insert into b_station_grid_mid (org_name,grid_id,b_station_name) " \
"values ('%s','%s','%s')" % (org_name, ord_id, station_name)
Oracle_Exec(sql_insert_b_station_grid_mid)
break
# 对照中间表修改正式表中的所有数据
def updata_station_all():
sqlSecStationNameFromMid = "select b_station_name from B_STATION_GRID_MID"
stationNameList = Oracle_Query(sqlSecStationNameFromMid)
for stationNameTup in stationNameList:
gridId = judge_station_name(stationNameTup[0])
if gridId:
print(stationNameTup[0])
print(gridId)
update_station_grid_id(gridId[0][0], stationNameTup[0])
else:
continue
# 获取小区的名称以及经纬度
def get_cell_lo_la(cityId, dayID):
"""
:param cityId: 小区所在的城市ID
:return:
"""
sqlGetCellIdLoLa = "SELECT A.CELL_ID,A.LONGITUDE,A.LATITUDE " \
"FROM B_SUBDISTRICT_INFO A " \
"WHERE CITY_ID='%s' " \
"AND A.LONGITUDE IS NOT NULL " \
"AND A.LATITUDE IS NOT NULL " \
"AND A.DAY_ID='%s'" % (str(cityId), str(dayID))
listCellLoLa = Oracle_Query(sqlGetCellIdLoLa)
return listCellLoLa
# 判断小区的结果并录入中间表
def in_cell_mid_table(cellLoLa, orgIdNamePoint, orgLevel, dayId, cityId):
"""
:param cellLoLa: 小区的坐标信息
:param orgIdNamePoint: 网格的坐标范围信息
:param orgLevel: 网格等级
:return: 无返回值
"""
for cellId, cellLo, cellLa in cellLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(cellLo, cellLa, org_point)
if judge_result:
sql_insert_b_cell_mid = "insert into b_cell_mid (day_id,org_name,grid_id,city_id,org_level,cell_id) " \
"values ('%s','%s','%s','%s','%s','%s')" % (
str(dayId), org_name, ord_id, str(cityId), str(orgLevel), cellId)
Oracle_Exec(sql_insert_b_cell_mid)
break
# 判断小区的结果并录入 | break
###转换数值类型
pLon1 = float(pLon1)
pLat1 = float(pLat1)
pLon2 = float(pLon2)
pLat2 = f | conditional_block |
getlola.py | " \
"and b.state='00A' " \
"and a.state='00A' " \
"and a.org_id in ( " \
"select org_id from s_orgnization start with org_id='%s' " \
"connect by prior org_id=p_org_id)) r,s_orgnization o " \
"where r.p_org_id=o.org_id " \
"and r.org_level='%s'" % (str(org_id), str(orgLevel))
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 查询获得网格的id、名称、网格坐标圈
def get_point():
sql_sec_orgid_orgname_point = "select a.org_id,a.org_name,b.point from s_orgnization a " \
"left join p_map_draw b on b.org_id = a.org_id" \
" where a.org_level='5'"
list_orgid_orgname_point = Oracle_Query(sql_sec_orgid_orgname_point)
return list_orgid_orgname_point
# 格式化cblob字段
def expand_list(tList):
mList = tList.read().split(";")
flag = 0
for i in mList:
mList[flag] = mList[flag].split(',')
flag += 1
return mList
# 修改基站grid_id bak表
def update_station_grid_id(gridId, bStationName):
sqlUpdateGridId = "update b_base_station_info_bak a " \
"set a.grid_id='%s' " \
"where a.b_station_name='%s'" % (str(gridId), bStationName)
updateResult = Oracle_Exec(sqlUpdateGridId)
return updateResult
# 对比两个b_station_name的grid_id是否相同
def judge_station_name(stationName):
sqlGridIdFromInfo = " select grid_id from b_base_station_info_bak where b_station_name = '%s'" % stationName
sqlGridIdFromMid = "select grid_id from B_STATION_GRID_MID where b_station_name = '%s'" % stationName
gridIdFromInfo = Oracle_Query(sqlGridIdFromInfo)
gridIdFromMid = Oracle_Query(sqlGridIdFromMid)
if gridIdFromInfo == gridIdFromMid:
return False
else:
return gridIdFromMid
# 格式化orgIdNamePoint
def expand_orgidnamepoint(orgIdNamePoint):
flag = 0
for i in orgIdNamePoint:
if i[2] is not None:
orgIdNamePoint[flag] = list(orgIdNamePoint[flag])
orgIdNamePoint[flag][2] = expand_list(i[2])
else:
continue
flag += 1
return orgIdNamePoint
# 获取数据入中间表
def in_station_mid_table(stationLoLa, orgIdNamePoint):
for station_name, station_lo, station_la in stationLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(station_lo, station_la, org_point)
if judge_result:
sql_insert_b_station_grid_mid = "insert into b_station_grid_mid (org_name,grid_id,b_station_name) " \
"values ('%s','%s','%s')" % (org_name, ord_id, station_name)
Oracle_Exec(sql_insert_b_station_grid_mid)
break
# 对照中间表修改正式表中的所有数据
def updata_station_all():
sqlSecStationNameFromMid = "select b_station_name from B_STATION_GRID_MID"
stationNameList = Oracle_Query(sqlSecStationNameFromMid)
for stationNameTup in stationNameList:
gridId = judge_station_name(stationNameTup[0])
if gridId:
print(stationNameTup[0])
print(gridId)
update_station_grid_id(gridId[0][0], stationNameTup[0])
else:
continue
# 获取小区的名称以及经纬度
def get_cell_lo_la(cityId, dayID):
"""
:param cityId: 小区所在的城市ID
:return:
"""
sqlGetCellIdLoLa = "SELECT A.CELL_ID,A.LONGITUDE,A.LATITUDE " \
"FROM B_SUBDISTRICT_INFO A " \
"WHERE CITY_ID='%s' " \
"AND A.LONGITUDE IS NOT NULL " \
"AND A.LATITUDE IS NOT NULL " \
"AND A.DAY_ID='%s'" % (str(cityId), str(dayID))
listCellLoLa = Oracle_Query(sqlGetCellIdLoLa)
return listCellLoLa
# 判断小区的结果并录入中间表
def in_cell_mid_table(cellLoLa, orgIdNamePoint, orgLevel, dayId, cityId):
"""
:param cellLoLa: 小区的坐标信息
:param orgIdNamePoint: 网格的坐标范围信息
:param orgLevel: 网格等级
:return: 无返回值
"""
for cellId, cellLo, cellLa in cellLoLa: # 获取基站的经纬度
for ord_id, org_name, org_point in orgIdNamePoint: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(cellLo, cellLa, org_point)
if judge_result:
sql_insert_b_cell_mid = "insert into b_cell_mid (day_id,org_name,grid_id,city_id,org_level,cell_id) " \
"values ('%s','%s','%s','%s','%s','%s')" % (
str(dayId), org_name, ord_id, str(cityId), str(orgLevel), cellId)
Oracle_Exec(sql_insert_b_cell_mid)
break
# 判断小区的结果并录入中间表
def in_cell_mid_table_grid_id(cellLoLa, orgIdNamePoint_5, orgIdNamePoint_4, orgLevel_5, orgLevel_4,dayId, cityId):
"""
:param cellLoLa: 小区的坐标信息
:param orgIdNamePoint: 网格的坐标范围信息
:param orgLevel: 网格等级
:return: 无返回值
"""
for cellId, cellLo, cellLa in cellLoLa: # 获取基站的经纬度
flag = 0
for ord_id, org_name, org_point in orgIdNamePoint_5: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(cellLo, cellLa, org_point)
if judge_result:
sql_insert_b_cell_mid = "insert into b_cell_mid (day_id,org_name,grid_id,city_id,org_level,cell_id) " \
"values ('%s','%s','%s','%s','%s','%s')" % (
str(dayId), org_name, ord_id, str(cityId), str(orgLevel_5), cellId)
Oracle_Exec(sql_insert_b_cell_mid)
flag = 1
break
if flag == 0:
for ord_id, org_name, org_point in orgIdNamePoint_4: # 获取网格的相关内容 (id、name、point list)
judge_result = is_pt_in_poly(cellLo, cellLa, org_point)
if judge_result:
sql_insert_b_cell_mid = "insert into b_cell_mid (day_id,org_name,grid_id,city_id,org_level,cell_id) " \
"values ('%s','%s','%s','%s','%s','%s')" % (
str(dayId), org_name, ord_id, str(cityId), str(orgLevel_4), cellId)
Oracle_Exec(sql_insert_b_cell_mid)
break
# 对比两个cell_id的region_id是否相同
def judge_cell_id_region(cellId):
sqlGridIdFromInfo = " select region from B_SUBDISTRICT_INFO where cell_id = '%s'" % cellId
sqlGridIdFromMid = "select grid_id from B_CELL_MID where cell_id = '%s'" % cellId
gridIdFromInfo = Oracle_Query(sqlGridIdFromInfo)
gridIdFromMid = Oracle_Query(sqlGridIdFromMid)
if gridIdFromInfo == gridIdFromMid:
return False
else:
return gridIdFromMid
# 修改基站grid_id bak表
def update_cell_region(gridId, cellId):
sqlUpdateGridId = "update B_SUBDISTRICT_INFO a " \
"set a.region='%s' " \
"where a.cell_id='%s'" % (str(gridId), cellId)
updateResult = Oracle_Exec(sqlUpdateGridId)
return updateResult
# | 对照中间表修改正式表中的所有数据 update小区region_id
def updata_cell_region_all():
sqlSecCellIdFromMid = "select cell_id from B_CELL_MID"
cellIdList = Oracle_Query(sqlSecCellIdFromMid)
for cellIdTup in cellIdList:
gridId = judge_cell_id_region(cellIdTup[0])
if gridId:
print(cellIdTup[0])
print(gridId)
update_cell_region(gridId[0][0 | identifier_body | |
report_internal_faculty_cv.py | .context_processors import csrf
from django.http import HttpResponse
from django.shortcuts import render_to_response
from django import forms
from django.template import RequestContext
from django.contrib.auth.decorators import login_required
import copy
# =============================================================================================
@login_required
def report_internal_faculty_cv(request):
class InternalFacultyCVForm(forms.Form):
if request.user.is_superuser:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.all())
else:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.filter(owner=request.user)) | c = RequestContext(request)
c.update(csrf(request))
# if 'course_name' in request.GET and request.GET['course_name']:
if request.method == 'POST':
# form submitted
form = InternalFacultyCVForm(request.POST)
form.is_valid()
instructor = form.cleaned_data['instructor']
instructor = instructor[0]
inner_response = report_internal_faculty_cv_pdf(request, instructor)
http_response = HttpResponse(inner_response, c)
escaped_name = str(instructor.name).replace(' ', '_')
this_year = datetime.datetime.now().strftime("%Y")
filename = "faculty_cv_" + escaped_name + "-" + this_year + ".pdf"
http_response['Content-Disposition'] = 'attachment;filename="' + filename + '"'
return http_response
else:
# form not yet submitted ... display it
form = InternalFacultyCVForm()
return render_to_response('internal_faculty_cv.html' , {
'form': form
}, c)
# ============= PDF GEN
def report_internal_faculty_cv_pdf(request, instructor):
def make_table(data, widths, style=[]):
table = LongTable(data, colWidths=widths)
table.setStyle(TableStyle(style))
return table
response = HttpResponse(mimetype='application/pdf')
buffer = BytesIO()
org = Internal()
styleN, styleB, styleH, styleSmaller = org.getTextStyles()
styleBC = copy.copy(styleB)
styleBC.alignment = TA_CENTER
width, height = A4
doc = FooterDocTemplate(buffer, pagesize=(height, width))
frame = org.getFrame(doc)
template = PageTemplate(id='test', frames=frame, onPage=org.get_header_footer(doccode="NCEAC.DOC.008", pagesize=(width, height)))
doc.addPageTemplates([template])
# Our main content holder
elements = []
i = instructor
ip = i.instructorprofile
percent_time_teaching = ip.percent_time_teaching
# title page
data = [[Paragraph('Name', styleB), i.name],
[Paragraph('Academic Rank', styleB), ip.designation],
[Paragraph('Administrative Responsibility', styleB), ip.admin_responsibility],
[Paragraph('Date of Original Appointment', styleB), ip.joining_date],
]
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
]
elements.append(make_table(data, widths=[6 * cm, 20 * cm], style=ts))
# elements.append(PageBreak())
# Education
ieds = i.instructoreducation_set.all().order_by('-year')
data = [[Paragraph('Degrees', styleB),
Paragraph('Degree', styleB),
Paragraph('Field', styleB),
Paragraph('Institution', styleB),
Paragraph('Date', styleB),
]]
for ied in ieds:
data.append(['',
Paragraph(ied.degree, styleN),
Paragraph(ied.field, styleN),
Paragraph(ied.university, styleN),
Paragraph(ied.year, styleN),
])
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 4.5 * cm, 4.5 * cm, 7 * cm, 4 * cm], style=ts))
# events
ievs = i.instructoreventparticpation_set.all().order_by('-start_date')
counter = 1
cat_header = Paragraph('Conferences, workshops, and professional development programs participated during the past five years', styleB)
data = []
for iev in ievs:
iev_string = str(counter) + '. ' + iev.title + '. Role: ' + iev.role + ' (' + str(iev.duration) + ' at ' + str(iev.venue) + ')'
data.append([cat_header,
Paragraph(iev_string, styleN),
Paragraph(str(iev.start_date.year), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Consultancies
icons = i.instructorconsultancy_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Consulting activities during the last five years', styleB)
data = []
for icon in icons:
icon_string = str(counter) + '. <b>' + icon.organization + '</b>. ' + icon.description
data.append([cat_header,
Paragraph(icon_string, styleN),
Paragraph(str(icon.date.year), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Publications
ipbs = i.instructorpublication_set.all().order_by('-id')
counter = 1
cat_header = Paragraph('Principal publications during the last five years (give in standard bibliogrpahic format)', styleB)
data = []
for ipb in ipbs:
pub_string = str(counter) + '. ' + str(ipb)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph('date', styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Other activities
ioas = i.instructorotheractivity_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Other scholarly activities during the last five years (grants, sabbaticals, software development, etc.)', styleB)
data = []
for ioa in ioas:
pub_string = str(counter) + '. ' + str(ioa.title) + '. ' + str(ioa.description)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph(str(ioa.date), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# courses during last two years
ics = i.course_set.all().order_by('-year')
| random_line_split | |
report_internal_faculty_cv.py | .context_processors import csrf
from django.http import HttpResponse
from django.shortcuts import render_to_response
from django import forms
from django.template import RequestContext
from django.contrib.auth.decorators import login_required
import copy
# =============================================================================================
@login_required
def report_internal_faculty_cv(request):
class InternalFacultyCVForm(forms.Form):
if request.user.is_superuser:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.all())
else:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.filter(owner=request.user))
c = RequestContext(request)
c.update(csrf(request))
# if 'course_name' in request.GET and request.GET['course_name']:
if request.method == 'POST':
# form submitted
form = InternalFacultyCVForm(request.POST)
form.is_valid()
instructor = form.cleaned_data['instructor']
instructor = instructor[0]
inner_response = report_internal_faculty_cv_pdf(request, instructor)
http_response = HttpResponse(inner_response, c)
escaped_name = str(instructor.name).replace(' ', '_')
this_year = datetime.datetime.now().strftime("%Y")
filename = "faculty_cv_" + escaped_name + "-" + this_year + ".pdf"
http_response['Content-Disposition'] = 'attachment;filename="' + filename + '"'
return http_response
else:
# form not yet submitted ... display it
form = InternalFacultyCVForm()
return render_to_response('internal_faculty_cv.html' , {
'form': form
}, c)
# ============= PDF GEN
def report_internal_faculty_cv_pdf(request, instructor):
def make_table(data, widths, style=[]):
table = LongTable(data, colWidths=widths)
table.setStyle(TableStyle(style))
return table
response = HttpResponse(mimetype='application/pdf')
buffer = BytesIO()
org = Internal()
styleN, styleB, styleH, styleSmaller = org.getTextStyles()
styleBC = copy.copy(styleB)
styleBC.alignment = TA_CENTER
width, height = A4
doc = FooterDocTemplate(buffer, pagesize=(height, width))
frame = org.getFrame(doc)
template = PageTemplate(id='test', frames=frame, onPage=org.get_header_footer(doccode="NCEAC.DOC.008", pagesize=(width, height)))
doc.addPageTemplates([template])
# Our main content holder
elements = []
i = instructor
ip = i.instructorprofile
percent_time_teaching = ip.percent_time_teaching
# title page
data = [[Paragraph('Name', styleB), i.name],
[Paragraph('Academic Rank', styleB), ip.designation],
[Paragraph('Administrative Responsibility', styleB), ip.admin_responsibility],
[Paragraph('Date of Original Appointment', styleB), ip.joining_date],
]
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
]
elements.append(make_table(data, widths=[6 * cm, 20 * cm], style=ts))
# elements.append(PageBreak())
# Education
ieds = i.instructoreducation_set.all().order_by('-year')
data = [[Paragraph('Degrees', styleB),
Paragraph('Degree', styleB),
Paragraph('Field', styleB),
Paragraph('Institution', styleB),
Paragraph('Date', styleB),
]]
for ied in ieds:
data.append(['',
Paragraph(ied.degree, styleN),
Paragraph(ied.field, styleN),
Paragraph(ied.university, styleN),
Paragraph(ied.year, styleN),
])
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 4.5 * cm, 4.5 * cm, 7 * cm, 4 * cm], style=ts))
# events
ievs = i.instructoreventparticpation_set.all().order_by('-start_date')
counter = 1
cat_header = Paragraph('Conferences, workshops, and professional development programs participated during the past five years', styleB)
data = []
for iev in ievs:
iev_string = str(counter) + '. ' + iev.title + '. Role: ' + iev.role + ' (' + str(iev.duration) + ' at ' + str(iev.venue) + ')'
data.append([cat_header,
Paragraph(iev_string, styleN),
Paragraph(str(iev.start_date.year), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Consultancies
icons = i.instructorconsultancy_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Consulting activities during the last five years', styleB)
data = []
for icon in icons:
|
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Publications
ipbs = i.instructorpublication_set.all().order_by('-id')
counter = 1
cat_header = Paragraph('Principal publications during the last five years (give in standard bibliogrpahic format)', styleB)
data = []
for ipb in ipbs:
pub_string = str(counter) + '. ' + str(ipb)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph('date', styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Other activities
ioas = i.instructorotheractivity_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Other scholarly activities during the last five years (grants, sabbaticals, software development, etc.)', styleB)
data = []
for ioa in ioas:
pub_string = str(counter) + '. ' + str(ioa.title) + '. ' + str(ioa.description)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph(str(ioa.date), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# courses during last two years
ics = i.course_set.all().order_by('-year')
data | icon_string = str(counter) + '. <b>' + icon.organization + '</b>. ' + icon.description
data.append([cat_header,
Paragraph(icon_string, styleN),
Paragraph(str(icon.date.year), styleN),
])
cat_header = ''
counter += 1 | conditional_block |
report_internal_faculty_cv.py | .context_processors import csrf
from django.http import HttpResponse
from django.shortcuts import render_to_response
from django import forms
from django.template import RequestContext
from django.contrib.auth.decorators import login_required
import copy
# =============================================================================================
@login_required
def report_internal_faculty_cv(request):
class InternalFacultyCVForm(forms.Form):
|
c = RequestContext(request)
c.update(csrf(request))
# if 'course_name' in request.GET and request.GET['course_name']:
if request.method == 'POST':
# form submitted
form = InternalFacultyCVForm(request.POST)
form.is_valid()
instructor = form.cleaned_data['instructor']
instructor = instructor[0]
inner_response = report_internal_faculty_cv_pdf(request, instructor)
http_response = HttpResponse(inner_response, c)
escaped_name = str(instructor.name).replace(' ', '_')
this_year = datetime.datetime.now().strftime("%Y")
filename = "faculty_cv_" + escaped_name + "-" + this_year + ".pdf"
http_response['Content-Disposition'] = 'attachment;filename="' + filename + '"'
return http_response
else:
# form not yet submitted ... display it
form = InternalFacultyCVForm()
return render_to_response('internal_faculty_cv.html' , {
'form': form
}, c)
# ============= PDF GEN
def report_internal_faculty_cv_pdf(request, instructor):
def make_table(data, widths, style=[]):
table = LongTable(data, colWidths=widths)
table.setStyle(TableStyle(style))
return table
response = HttpResponse(mimetype='application/pdf')
buffer = BytesIO()
org = Internal()
styleN, styleB, styleH, styleSmaller = org.getTextStyles()
styleBC = copy.copy(styleB)
styleBC.alignment = TA_CENTER
width, height = A4
doc = FooterDocTemplate(buffer, pagesize=(height, width))
frame = org.getFrame(doc)
template = PageTemplate(id='test', frames=frame, onPage=org.get_header_footer(doccode="NCEAC.DOC.008", pagesize=(width, height)))
doc.addPageTemplates([template])
# Our main content holder
elements = []
i = instructor
ip = i.instructorprofile
percent_time_teaching = ip.percent_time_teaching
# title page
data = [[Paragraph('Name', styleB), i.name],
[Paragraph('Academic Rank', styleB), ip.designation],
[Paragraph('Administrative Responsibility', styleB), ip.admin_responsibility],
[Paragraph('Date of Original Appointment', styleB), ip.joining_date],
]
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
]
elements.append(make_table(data, widths=[6 * cm, 20 * cm], style=ts))
# elements.append(PageBreak())
# Education
ieds = i.instructoreducation_set.all().order_by('-year')
data = [[Paragraph('Degrees', styleB),
Paragraph('Degree', styleB),
Paragraph('Field', styleB),
Paragraph('Institution', styleB),
Paragraph('Date', styleB),
]]
for ied in ieds:
data.append(['',
Paragraph(ied.degree, styleN),
Paragraph(ied.field, styleN),
Paragraph(ied.university, styleN),
Paragraph(ied.year, styleN),
])
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 4.5 * cm, 4.5 * cm, 7 * cm, 4 * cm], style=ts))
# events
ievs = i.instructoreventparticpation_set.all().order_by('-start_date')
counter = 1
cat_header = Paragraph('Conferences, workshops, and professional development programs participated during the past five years', styleB)
data = []
for iev in ievs:
iev_string = str(counter) + '. ' + iev.title + '. Role: ' + iev.role + ' (' + str(iev.duration) + ' at ' + str(iev.venue) + ')'
data.append([cat_header,
Paragraph(iev_string, styleN),
Paragraph(str(iev.start_date.year), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Consultancies
icons = i.instructorconsultancy_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Consulting activities during the last five years', styleB)
data = []
for icon in icons:
icon_string = str(counter) + '. <b>' + icon.organization + '</b>. ' + icon.description
data.append([cat_header,
Paragraph(icon_string, styleN),
Paragraph(str(icon.date.year), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Publications
ipbs = i.instructorpublication_set.all().order_by('-id')
counter = 1
cat_header = Paragraph('Principal publications during the last five years (give in standard bibliogrpahic format)', styleB)
data = []
for ipb in ipbs:
pub_string = str(counter) + '. ' + str(ipb)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph('date', styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Other activities
ioas = i.instructorotheractivity_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Other scholarly activities during the last five years (grants, sabbaticals, software development, etc.)', styleB)
data = []
for ioa in ioas:
pub_string = str(counter) + '. ' + str(ioa.title) + '. ' + str(ioa.description)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph(str(ioa.date), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# courses during last two years
ics = i.course_set.all().order_by('-year')
| if request.user.is_superuser:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.all())
else:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.filter(owner=request.user)) | identifier_body |
report_internal_faculty_cv.py | .context_processors import csrf
from django.http import HttpResponse
from django.shortcuts import render_to_response
from django import forms
from django.template import RequestContext
from django.contrib.auth.decorators import login_required
import copy
# =============================================================================================
@login_required
def report_internal_faculty_cv(request):
class | (forms.Form):
if request.user.is_superuser:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.all())
else:
instructor = forms.ModelMultipleChoiceField(queryset=Instructor.objects.filter(owner=request.user))
c = RequestContext(request)
c.update(csrf(request))
# if 'course_name' in request.GET and request.GET['course_name']:
if request.method == 'POST':
# form submitted
form = InternalFacultyCVForm(request.POST)
form.is_valid()
instructor = form.cleaned_data['instructor']
instructor = instructor[0]
inner_response = report_internal_faculty_cv_pdf(request, instructor)
http_response = HttpResponse(inner_response, c)
escaped_name = str(instructor.name).replace(' ', '_')
this_year = datetime.datetime.now().strftime("%Y")
filename = "faculty_cv_" + escaped_name + "-" + this_year + ".pdf"
http_response['Content-Disposition'] = 'attachment;filename="' + filename + '"'
return http_response
else:
# form not yet submitted ... display it
form = InternalFacultyCVForm()
return render_to_response('internal_faculty_cv.html' , {
'form': form
}, c)
# ============= PDF GEN
def report_internal_faculty_cv_pdf(request, instructor):
def make_table(data, widths, style=[]):
table = LongTable(data, colWidths=widths)
table.setStyle(TableStyle(style))
return table
response = HttpResponse(mimetype='application/pdf')
buffer = BytesIO()
org = Internal()
styleN, styleB, styleH, styleSmaller = org.getTextStyles()
styleBC = copy.copy(styleB)
styleBC.alignment = TA_CENTER
width, height = A4
doc = FooterDocTemplate(buffer, pagesize=(height, width))
frame = org.getFrame(doc)
template = PageTemplate(id='test', frames=frame, onPage=org.get_header_footer(doccode="NCEAC.DOC.008", pagesize=(width, height)))
doc.addPageTemplates([template])
# Our main content holder
elements = []
i = instructor
ip = i.instructorprofile
percent_time_teaching = ip.percent_time_teaching
# title page
data = [[Paragraph('Name', styleB), i.name],
[Paragraph('Academic Rank', styleB), ip.designation],
[Paragraph('Administrative Responsibility', styleB), ip.admin_responsibility],
[Paragraph('Date of Original Appointment', styleB), ip.joining_date],
]
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
]
elements.append(make_table(data, widths=[6 * cm, 20 * cm], style=ts))
# elements.append(PageBreak())
# Education
ieds = i.instructoreducation_set.all().order_by('-year')
data = [[Paragraph('Degrees', styleB),
Paragraph('Degree', styleB),
Paragraph('Field', styleB),
Paragraph('Institution', styleB),
Paragraph('Date', styleB),
]]
for ied in ieds:
data.append(['',
Paragraph(ied.degree, styleN),
Paragraph(ied.field, styleN),
Paragraph(ied.university, styleN),
Paragraph(ied.year, styleN),
])
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 4.5 * cm, 4.5 * cm, 7 * cm, 4 * cm], style=ts))
# events
ievs = i.instructoreventparticpation_set.all().order_by('-start_date')
counter = 1
cat_header = Paragraph('Conferences, workshops, and professional development programs participated during the past five years', styleB)
data = []
for iev in ievs:
iev_string = str(counter) + '. ' + iev.title + '. Role: ' + iev.role + ' (' + str(iev.duration) + ' at ' + str(iev.venue) + ')'
data.append([cat_header,
Paragraph(iev_string, styleN),
Paragraph(str(iev.start_date.year), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Consultancies
icons = i.instructorconsultancy_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Consulting activities during the last five years', styleB)
data = []
for icon in icons:
icon_string = str(counter) + '. <b>' + icon.organization + '</b>. ' + icon.description
data.append([cat_header,
Paragraph(icon_string, styleN),
Paragraph(str(icon.date.year), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Publications
ipbs = i.instructorpublication_set.all().order_by('-id')
counter = 1
cat_header = Paragraph('Principal publications during the last five years (give in standard bibliogrpahic format)', styleB)
data = []
for ipb in ipbs:
pub_string = str(counter) + '. ' + str(ipb)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph('date', styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# Other activities
ioas = i.instructorotheractivity_set.all().order_by('-date')
counter = 1
cat_header = Paragraph('Other scholarly activities during the last five years (grants, sabbaticals, software development, etc.)', styleB)
data = []
for ioa in ioas:
pub_string = str(counter) + '. ' + str(ioa.title) + '. ' + str(ioa.description)
data.append([cat_header,
Paragraph(pub_string, styleN),
Paragraph(str(ioa.date), styleN),
])
cat_header = ''
counter += 1
ts = [ ('INNERGRID', (0, 0), (-1, -1), 0.15, colors.black),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('SPAN', (0, 0), (0, -1))
]
elements.append(make_table(data, widths=[6 * cm, 16 * cm, 4 * cm], style=ts))
# courses during last two years
ics = i.course_set.all().order_by('-year')
| InternalFacultyCVForm | identifier_name |
common_voices_eval.py | label,
featureSize, labelSize).view(1, -1)
if torch.isinf(loss).sum() > 0 or torch.isnan(loss).sum() > 0:
loss = 0
return loss
class IDModule(torch.nn.Module):
def __init__(self):
super(IDModule, self).__init__()
def forward(self, feature, *args):
B, C, S = feature.size()
return feature.permute(0, 2, 1), None, None
def cut_data(seq, sizeSeq):
maxSeq = sizeSeq.max()
return seq[:, :maxSeq]
def prepare_data(data):
seq, sizeSeq, phone, sizePhone = data
seq = seq.cuda(non_blocking=True)
phone = phone.cuda(non_blocking=True)
sizeSeq = sizeSeq.cuda(non_blocking=True).view(-1)
sizePhone = sizePhone.cuda(non_blocking=True).view(-1)
seq = cut_data(seq.permute(0, 2, 1), sizeSeq).permute(0, 2, 1)
return seq, sizeSeq, phone, sizePhone
def train_step(train_loader,
model,
criterion,
optimizer,
downsampling_factor):
if model.optimize:
model.train()
criterion.train()
avg_loss = 0
nItems = 0
for data in train_loader:
optimizer.zero_grad()
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
if not model.optimize:
c_feature = c_feature.detach()
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
loss.mean().backward()
avg_loss += loss.mean().item()
nItems += 1
optimizer.step()
return avg_loss / nItems
def val_step(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avg_loss = 0
nItems = 0
for data in val_loader:
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
avg_loss += loss.mean().item()
nItems += 1
return avg_loss / nItems
def get_per(data):
pred, size_pred, gt, size_gt, blank_label = data
l_ = min(size_pred // 4, pred.size(0))
p_ = pred[:l_].view(l_, -1).numpy()
gt_seq = gt[:size_gt].view(-1).tolist()
predSeq = beam_search(p_, 20, blank_label)[0][1]
out = get_seq_PER(gt_seq, predSeq)
return out
def perStep(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avgPER = 0
varPER = 0
nItems = 0
print("Starting the PER computation through beam search")
bar = progressbar.ProgressBar(maxval=len(val_loader))
bar.start()
for index, data in enumerate(val_loader):
bar.update(index)
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
predictions = torch.nn.functional.softmax(
criterion.module.getPrediction(c_feature, sizeSeq), dim=2).cpu()
phone = phone.cpu()
sizeSeq = sizeSeq.cpu()
sizePhone = sizePhone.cpu()
bs = c_feature.size(0)
data_per = [(predictions[b], sizeSeq[b], phone[b], sizePhone[b],
criterion.module.BLANK_LABEL) for b in range(bs)]
with Pool(bs) as p:
poolData = p.map(get_per, data_per)
avgPER += sum([x for x in poolData])
varPER += sum([x*x for x in poolData])
nItems += len(poolData)
bar.finish()
avgPER /= nItems
varPER /= nItems
varPER -= avgPER**2
print(f"Average PER {avgPER}")
print(f"Standard deviation PER {math.sqrt(varPER)}")
def run(train_loader,
val_loader,
model,
criterion,
optimizer,
downsampling_factor,
nEpochs,
pathCheckpoint):
print(f"Starting the training for {nEpochs} epochs")
bestLoss = float('inf')
for epoch in range(nEpochs):
lossTrain = train_step(train_loader, model, criterion,
optimizer, downsampling_factor)
print(f"Epoch {epoch} loss train : {lossTrain}")
lossVal = val_step(val_loader, model, criterion, downsampling_factor)
print(f"Epoch {epoch} loss val : {lossVal}")
if lossVal < bestLoss:
bestLoss = lossVal
state_dict = {'classifier': criterion.state_dict(),
'model': model.state_dict(),
'bestLoss': bestLoss}
torch.save(state_dict, pathCheckpoint)
def get_PER_args(args):
path_args_training = os.path.join(args.output, "args_training.json")
with open(path_args_training, 'rb') as file:
data = json.load(file)
if args.pathDB is None:
args.pathDB = data["pathDB"]
args.file_extension = data["file_extension"]
if args.pathVal is None and args.pathPhone is None:
args.pathPhone = data["pathPhone"]
args.pathVal = data["pathVal"]
args.pathCheckpoint = data["pathCheckpoint"]
args.no_pretraining = data["no_pretraining"]
args.LSTM = data.get("LSTM", False)
args.seqNorm = data.get("seqNorm", False)
args.dropout = data.get("dropout", False)
args.in_dim = data.get("in_dim", 1)
args.loss_reduction = data.get("loss_reduction", "mean")
return args
if __name__ == "__main__":
torch.multiprocessing.set_start_method('spawn')
parser = argparse.ArgumentParser(description='Simple phone recognition pipeline '
'for the common voices datasets')
subparsers = parser.add_subparsers(dest='command')
parser_train = subparsers.add_parser('train')
parser_train.add_argument('pathDB', type=str,
help='Path to the directory containing the '
'audio data / pre-computed features.')
parser_train.add_argument('pathPhone', type=str,
help='Path to the .txt file containing the '
'phone transcription.')
parser_train.add_argument('pathCheckpoint', type=str,
help='Path to the CPC checkpoint to load. '
'Set to ID to work with pre-cimputed features.')
parser_train.add_argument('--freeze', action='store_true',
help="Freeze the CPC features layers")
parser_train.add_argument('--pathTrain', default=None, type=str,
help='Path to the .txt files containing the '
'list of the training sequences.')
parser_train.add_argument('--pathVal', default=None, type=str,
help='Path to the .txt files containing the '
'list of the validation sequences.')
parser_train.add_argument('--file_extension', type=str, default=".mp3",
help='Extension of the files in the '
'dataset')
parser_train.add_argument('--batchSize', type=int, default=8)
parser_train.add_argument('--nEpochs', type=int, default=30)
parser_train.add_argument('--beta1', type=float, default=0.9,
help='Value of beta1 for the Adam optimizer.')
parser_train.add_argument('--beta2', type=float, default=0.999,
help='Value of beta2 for the Adam optimizer.')
parser_train.add_argument('--epsilon', type=float, default=1e-08,
help='Value of epsilon for the Adam optimizer.')
parser_train.add_argument('--lr', type=float, default=2e-04,
help='Learning rate.')
parser_train.add_argument('-o', '--output', type=str, default='out',
help="Output directory")
parser_train.add_argument('--debug', action='store_true',
help='If activated, will only load a few '
'sequences from the dataset.')
parser_train.add_argument('--no_pretraining', action='store_true',
help='Activate use a randmly initialized '
'network')
parser_train.add_argument('--LSTM', action='store_true',
help='Activate to add a LSTM to the phone '
'classifier')
parser_train.add_argument('--seqNorm', action='store_true',
help='Activate if you want to normalize each '
'batch of features through time before the '
'phone classification.')
parser_train.add_argument('--kernelSize', type=int, default=8,
help='Number of features to concatenate before '
'feeding them to the phone classifier.')
parser_train.add_argument('--dropout', action='store_true')
parser_train.add_argument('--in_dim', type=int, default=1,
help='Dimension of the input data: useful when '
'working with pre-computed features or ' | 'stereo audio.')
parser_train.add_argument('--loss_reduction', type=str, default='mean',
choices=['mean', 'sum']) | random_line_split | |
common_voices_eval.py | offsetEnd = self.seqOffset[idx+1]
offsetPhoneStart = self.phoneOffsets[idx]
offsetPhoneEnd = self.phoneOffsets[idx + 1]
sizeSeq = int(offsetEnd - offsetStart)
sizePhone = int(offsetPhoneEnd - offsetPhoneStart)
outSeq = torch.zeros((self.inDim, self.maxSize))
outPhone = torch.zeros((self.maxSizePhone))
outSeq[:, :sizeSeq] = self.data[:, offsetStart:offsetEnd]
outPhone[:sizePhone] = self.phoneLabels[offsetPhoneStart:offsetPhoneEnd]
return outSeq, torch.tensor([sizeSeq], dtype=torch.long), outPhone.long(), torch.tensor([sizePhone], dtype=torch.long)
def __len__(self):
return len(self.seqOffset) - 1
class CTCphone_criterion(torch.nn.Module):
def __init__(self, dimEncoder, nPhones, LSTM=False, sizeKernel=8,
seqNorm=False, dropout=False, reduction='sum'):
super(CTCphone_criterion, self).__init__()
self.seqNorm = seqNorm
self.epsilon = 1e-8
self.dropout = torch.nn.Dropout2d(
p=0.5, inplace=False) if dropout else None
self.conv1 = torch.nn.LSTM(dimEncoder, dimEncoder,
num_layers=1, batch_first=True)
self.PhoneCriterionClassifier = torch.nn.Conv1d(
dimEncoder, nPhones + 1, sizeKernel, stride=sizeKernel // 2)
self.lossCriterion = torch.nn.CTCLoss(blank=nPhones,
reduction=reduction,
zero_infinity=True)
self.relu = torch.nn.ReLU()
self.BLANK_LABEL = nPhones
self.useLSTM = LSTM
def getPrediction(self, cFeature, featureSize):
B, S, H = cFeature.size()
if self.seqNorm:
for b in range(B):
size = featureSize[b]
m = cFeature[b, :size].mean(dim=0, keepdim=True)
v = cFeature[b, :size].var(dim=0, keepdim=True)
cFeature[b] = (cFeature[b] - m) / torch.sqrt(v + self.epsilon)
if self.useLSTM:
cFeature = self.conv1(cFeature)[0]
cFeature = cFeature.permute(0, 2, 1)
if self.dropout is not None:
cFeature = self.dropout(cFeature)
cFeature = self.PhoneCriterionClassifier(cFeature)
return cFeature.permute(0, 2, 1)
def forward(self, cFeature, featureSize, label, labelSize):
# cFeature.size() : batchSize x seq Size x hidden size
B, S, H = cFeature.size()
predictions = self.getPrediction(cFeature, featureSize)
featureSize /= 4
predictions = cut_data(predictions, featureSize)
featureSize = torch.clamp(featureSize, max=predictions.size(1))
label = cut_data(label, labelSize)
if labelSize.min() <= 0:
print(label, labelSize)
predictions = torch.nn.functional.log_softmax(predictions, dim=2)
predictions = predictions.permute(1, 0, 2)
loss = self.lossCriterion(predictions, label,
featureSize, labelSize).view(1, -1)
if torch.isinf(loss).sum() > 0 or torch.isnan(loss).sum() > 0:
loss = 0
return loss
class IDModule(torch.nn.Module):
def __init__(self):
super(IDModule, self).__init__()
def forward(self, feature, *args):
B, C, S = feature.size()
return feature.permute(0, 2, 1), None, None
def cut_data(seq, sizeSeq):
maxSeq = sizeSeq.max()
return seq[:, :maxSeq]
def prepare_data(data):
seq, sizeSeq, phone, sizePhone = data
seq = seq.cuda(non_blocking=True)
phone = phone.cuda(non_blocking=True)
sizeSeq = sizeSeq.cuda(non_blocking=True).view(-1)
sizePhone = sizePhone.cuda(non_blocking=True).view(-1)
seq = cut_data(seq.permute(0, 2, 1), sizeSeq).permute(0, 2, 1)
return seq, sizeSeq, phone, sizePhone
def train_step(train_loader,
model,
criterion,
optimizer,
downsampling_factor):
if model.optimize:
model.train()
criterion.train()
avg_loss = 0
nItems = 0
for data in train_loader:
optimizer.zero_grad()
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
if not model.optimize:
c_feature = c_feature.detach()
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
loss.mean().backward()
avg_loss += loss.mean().item()
nItems += 1
optimizer.step()
return avg_loss / nItems
def val_step(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avg_loss = 0
nItems = 0
for data in val_loader:
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
avg_loss += loss.mean().item()
nItems += 1
return avg_loss / nItems
def get_per(data):
pred, size_pred, gt, size_gt, blank_label = data
l_ = min(size_pred // 4, pred.size(0))
p_ = pred[:l_].view(l_, -1).numpy()
gt_seq = gt[:size_gt].view(-1).tolist()
predSeq = beam_search(p_, 20, blank_label)[0][1]
out = get_seq_PER(gt_seq, predSeq)
return out
def perStep(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avgPER = 0
varPER = 0
nItems = 0
print("Starting the PER computation through beam search")
bar = progressbar.ProgressBar(maxval=len(val_loader))
bar.start()
for index, data in enumerate(val_loader):
bar.update(index)
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
predictions = torch.nn.functional.softmax(
criterion.module.getPrediction(c_feature, sizeSeq), dim=2).cpu()
phone = phone.cpu()
sizeSeq = sizeSeq.cpu()
sizePhone = sizePhone.cpu()
bs = c_feature.size(0)
data_per = [(predictions[b], sizeSeq[b], phone[b], sizePhone[b],
criterion.module.BLANK_LABEL) for b in range(bs)]
with Pool(bs) as p:
poolData = p.map(get_per, data_per)
avgPER += sum([x for x in poolData])
varPER += sum([x*x for x in poolData])
nItems += len(poolData)
bar.finish()
avgPER /= nItems
varPER /= nItems
varPER -= avgPER**2
print(f"Average PER {avgPER}")
print(f"Standard deviation PER {math.sqrt(varPER)}")
def run(train_loader,
val_loader,
model,
criterion,
optimizer,
downsampling_factor,
nEpochs,
pathCheckpoint):
print(f"Starting the training for {nEpochs} epochs")
bestLoss = float('inf')
for epoch in range(nEpochs):
lossTrain = train_step(train_loader, model, criterion,
optimizer, downsampling_factor)
print(f"Epoch {epoch} loss train : {lossTrain}")
lossVal = val_step(val_loader, model, criterion, downsampling_factor)
print(f"Epoch {epoch} loss val : {lossVal}")
if lossVal < bestLoss:
bestLoss = lossVal
state_dict = {'classifier': criterion.state_dict(),
'model': model.state_dict(),
'bestLoss': bestLoss}
torch.save(state_dict, pathCheckpoint)
def get_PER_args(args):
path_args_training = os.path.join(args.output, "args_training.json")
with open(path_args_training, 'rb') as file:
data = json.load(file)
if args.pathDB is None:
args.pathDB = data["pathDB"]
args.file_extension = data["file_extension"]
if args.pathVal is None and args.pathPhone is None:
|
args.pathCheckpoint = data["pathCheckpoint"]
args.no_pretraining = data["no_pretraining"]
args.LSTM = data.get("LSTM", False)
args.seqNorm = data.get("seqNorm", False)
args.dropout = data.get("dropout", False)
args.in_dim = data.get("in_dim", 1)
args.loss_reduction = data.get("loss_reduction | args.pathPhone = data["pathPhone"]
args.pathVal = data["pathVal"] | conditional_block |
common_voices_eval.py | ]
offsetEnd = self.seqOffset[idx+1]
offsetPhoneStart = self.phoneOffsets[idx]
offsetPhoneEnd = self.phoneOffsets[idx + 1]
sizeSeq = int(offsetEnd - offsetStart)
sizePhone = int(offsetPhoneEnd - offsetPhoneStart)
outSeq = torch.zeros((self.inDim, self.maxSize))
outPhone = torch.zeros((self.maxSizePhone))
outSeq[:, :sizeSeq] = self.data[:, offsetStart:offsetEnd]
outPhone[:sizePhone] = self.phoneLabels[offsetPhoneStart:offsetPhoneEnd]
return outSeq, torch.tensor([sizeSeq], dtype=torch.long), outPhone.long(), torch.tensor([sizePhone], dtype=torch.long)
def __len__(self):
return len(self.seqOffset) - 1
class CTCphone_criterion(torch.nn.Module):
def __init__(self, dimEncoder, nPhones, LSTM=False, sizeKernel=8,
seqNorm=False, dropout=False, reduction='sum'):
|
def getPrediction(self, cFeature, featureSize):
B, S, H = cFeature.size()
if self.seqNorm:
for b in range(B):
size = featureSize[b]
m = cFeature[b, :size].mean(dim=0, keepdim=True)
v = cFeature[b, :size].var(dim=0, keepdim=True)
cFeature[b] = (cFeature[b] - m) / torch.sqrt(v + self.epsilon)
if self.useLSTM:
cFeature = self.conv1(cFeature)[0]
cFeature = cFeature.permute(0, 2, 1)
if self.dropout is not None:
cFeature = self.dropout(cFeature)
cFeature = self.PhoneCriterionClassifier(cFeature)
return cFeature.permute(0, 2, 1)
def forward(self, cFeature, featureSize, label, labelSize):
# cFeature.size() : batchSize x seq Size x hidden size
B, S, H = cFeature.size()
predictions = self.getPrediction(cFeature, featureSize)
featureSize /= 4
predictions = cut_data(predictions, featureSize)
featureSize = torch.clamp(featureSize, max=predictions.size(1))
label = cut_data(label, labelSize)
if labelSize.min() <= 0:
print(label, labelSize)
predictions = torch.nn.functional.log_softmax(predictions, dim=2)
predictions = predictions.permute(1, 0, 2)
loss = self.lossCriterion(predictions, label,
featureSize, labelSize).view(1, -1)
if torch.isinf(loss).sum() > 0 or torch.isnan(loss).sum() > 0:
loss = 0
return loss
class IDModule(torch.nn.Module):
def __init__(self):
super(IDModule, self).__init__()
def forward(self, feature, *args):
B, C, S = feature.size()
return feature.permute(0, 2, 1), None, None
def cut_data(seq, sizeSeq):
maxSeq = sizeSeq.max()
return seq[:, :maxSeq]
def prepare_data(data):
seq, sizeSeq, phone, sizePhone = data
seq = seq.cuda(non_blocking=True)
phone = phone.cuda(non_blocking=True)
sizeSeq = sizeSeq.cuda(non_blocking=True).view(-1)
sizePhone = sizePhone.cuda(non_blocking=True).view(-1)
seq = cut_data(seq.permute(0, 2, 1), sizeSeq).permute(0, 2, 1)
return seq, sizeSeq, phone, sizePhone
def train_step(train_loader,
model,
criterion,
optimizer,
downsampling_factor):
if model.optimize:
model.train()
criterion.train()
avg_loss = 0
nItems = 0
for data in train_loader:
optimizer.zero_grad()
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
if not model.optimize:
c_feature = c_feature.detach()
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
loss.mean().backward()
avg_loss += loss.mean().item()
nItems += 1
optimizer.step()
return avg_loss / nItems
def val_step(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avg_loss = 0
nItems = 0
for data in val_loader:
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
avg_loss += loss.mean().item()
nItems += 1
return avg_loss / nItems
def get_per(data):
pred, size_pred, gt, size_gt, blank_label = data
l_ = min(size_pred // 4, pred.size(0))
p_ = pred[:l_].view(l_, -1).numpy()
gt_seq = gt[:size_gt].view(-1).tolist()
predSeq = beam_search(p_, 20, blank_label)[0][1]
out = get_seq_PER(gt_seq, predSeq)
return out
def perStep(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avgPER = 0
varPER = 0
nItems = 0
print("Starting the PER computation through beam search")
bar = progressbar.ProgressBar(maxval=len(val_loader))
bar.start()
for index, data in enumerate(val_loader):
bar.update(index)
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
predictions = torch.nn.functional.softmax(
criterion.module.getPrediction(c_feature, sizeSeq), dim=2).cpu()
phone = phone.cpu()
sizeSeq = sizeSeq.cpu()
sizePhone = sizePhone.cpu()
bs = c_feature.size(0)
data_per = [(predictions[b], sizeSeq[b], phone[b], sizePhone[b],
criterion.module.BLANK_LABEL) for b in range(bs)]
with Pool(bs) as p:
poolData = p.map(get_per, data_per)
avgPER += sum([x for x in poolData])
varPER += sum([x*x for x in poolData])
nItems += len(poolData)
bar.finish()
avgPER /= nItems
varPER /= nItems
varPER -= avgPER**2
print(f"Average PER {avgPER}")
print(f"Standard deviation PER {math.sqrt(varPER)}")
def run(train_loader,
val_loader,
model,
criterion,
optimizer,
downsampling_factor,
nEpochs,
pathCheckpoint):
print(f"Starting the training for {nEpochs} epochs")
bestLoss = float('inf')
for epoch in range(nEpochs):
lossTrain = train_step(train_loader, model, criterion,
optimizer, downsampling_factor)
print(f"Epoch {epoch} loss train : {lossTrain}")
lossVal = val_step(val_loader, model, criterion, downsampling_factor)
print(f"Epoch {epoch} loss val : {lossVal}")
if lossVal < bestLoss:
bestLoss = lossVal
state_dict = {'classifier': criterion.state_dict(),
'model': model.state_dict(),
'bestLoss': bestLoss}
torch.save(state_dict, pathCheckpoint)
def get_PER_args(args):
path_args_training = os.path.join(args.output, "args_training.json")
with open(path_args_training, 'rb') as file:
data = json.load(file)
if args.pathDB is None:
args.pathDB = data["pathDB"]
args.file_extension = data["file_extension"]
if args.pathVal is None and args.pathPhone is None:
args.pathPhone = data["pathPhone"]
args.pathVal = data["pathVal"]
args.pathCheckpoint = data["pathCheckpoint"]
args.no_pretraining = data["no_pretraining"]
args.LSTM = data.get("LSTM", False)
args.seqNorm = data.get("seqNorm", False)
args.dropout = data.get("dropout", False)
args.in_dim = data.get("in_dim", 1)
args.loss_reduction = data.get("loss_reduction | super(CTCphone_criterion, self).__init__()
self.seqNorm = seqNorm
self.epsilon = 1e-8
self.dropout = torch.nn.Dropout2d(
p=0.5, inplace=False) if dropout else None
self.conv1 = torch.nn.LSTM(dimEncoder, dimEncoder,
num_layers=1, batch_first=True)
self.PhoneCriterionClassifier = torch.nn.Conv1d(
dimEncoder, nPhones + 1, sizeKernel, stride=sizeKernel // 2)
self.lossCriterion = torch.nn.CTCLoss(blank=nPhones,
reduction=reduction,
zero_infinity=True)
self.relu = torch.nn.ReLU()
self.BLANK_LABEL = nPhones
self.useLSTM = LSTM | identifier_body |
common_voices_eval.py | offsetEnd = self.seqOffset[idx+1]
offsetPhoneStart = self.phoneOffsets[idx]
offsetPhoneEnd = self.phoneOffsets[idx + 1]
sizeSeq = int(offsetEnd - offsetStart)
sizePhone = int(offsetPhoneEnd - offsetPhoneStart)
outSeq = torch.zeros((self.inDim, self.maxSize))
outPhone = torch.zeros((self.maxSizePhone))
outSeq[:, :sizeSeq] = self.data[:, offsetStart:offsetEnd]
outPhone[:sizePhone] = self.phoneLabels[offsetPhoneStart:offsetPhoneEnd]
return outSeq, torch.tensor([sizeSeq], dtype=torch.long), outPhone.long(), torch.tensor([sizePhone], dtype=torch.long)
def __len__(self):
return len(self.seqOffset) - 1
class CTCphone_criterion(torch.nn.Module):
def __init__(self, dimEncoder, nPhones, LSTM=False, sizeKernel=8,
seqNorm=False, dropout=False, reduction='sum'):
super(CTCphone_criterion, self).__init__()
self.seqNorm = seqNorm
self.epsilon = 1e-8
self.dropout = torch.nn.Dropout2d(
p=0.5, inplace=False) if dropout else None
self.conv1 = torch.nn.LSTM(dimEncoder, dimEncoder,
num_layers=1, batch_first=True)
self.PhoneCriterionClassifier = torch.nn.Conv1d(
dimEncoder, nPhones + 1, sizeKernel, stride=sizeKernel // 2)
self.lossCriterion = torch.nn.CTCLoss(blank=nPhones,
reduction=reduction,
zero_infinity=True)
self.relu = torch.nn.ReLU()
self.BLANK_LABEL = nPhones
self.useLSTM = LSTM
def getPrediction(self, cFeature, featureSize):
B, S, H = cFeature.size()
if self.seqNorm:
for b in range(B):
size = featureSize[b]
m = cFeature[b, :size].mean(dim=0, keepdim=True)
v = cFeature[b, :size].var(dim=0, keepdim=True)
cFeature[b] = (cFeature[b] - m) / torch.sqrt(v + self.epsilon)
if self.useLSTM:
cFeature = self.conv1(cFeature)[0]
cFeature = cFeature.permute(0, 2, 1)
if self.dropout is not None:
cFeature = self.dropout(cFeature)
cFeature = self.PhoneCriterionClassifier(cFeature)
return cFeature.permute(0, 2, 1)
def forward(self, cFeature, featureSize, label, labelSize):
# cFeature.size() : batchSize x seq Size x hidden size
B, S, H = cFeature.size()
predictions = self.getPrediction(cFeature, featureSize)
featureSize /= 4
predictions = cut_data(predictions, featureSize)
featureSize = torch.clamp(featureSize, max=predictions.size(1))
label = cut_data(label, labelSize)
if labelSize.min() <= 0:
print(label, labelSize)
predictions = torch.nn.functional.log_softmax(predictions, dim=2)
predictions = predictions.permute(1, 0, 2)
loss = self.lossCriterion(predictions, label,
featureSize, labelSize).view(1, -1)
if torch.isinf(loss).sum() > 0 or torch.isnan(loss).sum() > 0:
loss = 0
return loss
class IDModule(torch.nn.Module):
def __init__(self):
super(IDModule, self).__init__()
def | (self, feature, *args):
B, C, S = feature.size()
return feature.permute(0, 2, 1), None, None
def cut_data(seq, sizeSeq):
maxSeq = sizeSeq.max()
return seq[:, :maxSeq]
def prepare_data(data):
seq, sizeSeq, phone, sizePhone = data
seq = seq.cuda(non_blocking=True)
phone = phone.cuda(non_blocking=True)
sizeSeq = sizeSeq.cuda(non_blocking=True).view(-1)
sizePhone = sizePhone.cuda(non_blocking=True).view(-1)
seq = cut_data(seq.permute(0, 2, 1), sizeSeq).permute(0, 2, 1)
return seq, sizeSeq, phone, sizePhone
def train_step(train_loader,
model,
criterion,
optimizer,
downsampling_factor):
if model.optimize:
model.train()
criterion.train()
avg_loss = 0
nItems = 0
for data in train_loader:
optimizer.zero_grad()
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
if not model.optimize:
c_feature = c_feature.detach()
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
loss.mean().backward()
avg_loss += loss.mean().item()
nItems += 1
optimizer.step()
return avg_loss / nItems
def val_step(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avg_loss = 0
nItems = 0
for data in val_loader:
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
loss = criterion(c_feature, sizeSeq, phone, sizePhone)
avg_loss += loss.mean().item()
nItems += 1
return avg_loss / nItems
def get_per(data):
pred, size_pred, gt, size_gt, blank_label = data
l_ = min(size_pred // 4, pred.size(0))
p_ = pred[:l_].view(l_, -1).numpy()
gt_seq = gt[:size_gt].view(-1).tolist()
predSeq = beam_search(p_, 20, blank_label)[0][1]
out = get_seq_PER(gt_seq, predSeq)
return out
def perStep(val_loader,
model,
criterion,
downsampling_factor):
model.eval()
criterion.eval()
avgPER = 0
varPER = 0
nItems = 0
print("Starting the PER computation through beam search")
bar = progressbar.ProgressBar(maxval=len(val_loader))
bar.start()
for index, data in enumerate(val_loader):
bar.update(index)
with torch.no_grad():
seq, sizeSeq, phone, sizePhone = prepare_data(data)
c_feature, _, _ = model(seq, None)
sizeSeq = sizeSeq / downsampling_factor
predictions = torch.nn.functional.softmax(
criterion.module.getPrediction(c_feature, sizeSeq), dim=2).cpu()
phone = phone.cpu()
sizeSeq = sizeSeq.cpu()
sizePhone = sizePhone.cpu()
bs = c_feature.size(0)
data_per = [(predictions[b], sizeSeq[b], phone[b], sizePhone[b],
criterion.module.BLANK_LABEL) for b in range(bs)]
with Pool(bs) as p:
poolData = p.map(get_per, data_per)
avgPER += sum([x for x in poolData])
varPER += sum([x*x for x in poolData])
nItems += len(poolData)
bar.finish()
avgPER /= nItems
varPER /= nItems
varPER -= avgPER**2
print(f"Average PER {avgPER}")
print(f"Standard deviation PER {math.sqrt(varPER)}")
def run(train_loader,
val_loader,
model,
criterion,
optimizer,
downsampling_factor,
nEpochs,
pathCheckpoint):
print(f"Starting the training for {nEpochs} epochs")
bestLoss = float('inf')
for epoch in range(nEpochs):
lossTrain = train_step(train_loader, model, criterion,
optimizer, downsampling_factor)
print(f"Epoch {epoch} loss train : {lossTrain}")
lossVal = val_step(val_loader, model, criterion, downsampling_factor)
print(f"Epoch {epoch} loss val : {lossVal}")
if lossVal < bestLoss:
bestLoss = lossVal
state_dict = {'classifier': criterion.state_dict(),
'model': model.state_dict(),
'bestLoss': bestLoss}
torch.save(state_dict, pathCheckpoint)
def get_PER_args(args):
path_args_training = os.path.join(args.output, "args_training.json")
with open(path_args_training, 'rb') as file:
data = json.load(file)
if args.pathDB is None:
args.pathDB = data["pathDB"]
args.file_extension = data["file_extension"]
if args.pathVal is None and args.pathPhone is None:
args.pathPhone = data["pathPhone"]
args.pathVal = data["pathVal"]
args.pathCheckpoint = data["pathCheckpoint"]
args.no_pretraining = data["no_pretraining"]
args.LSTM = data.get("LSTM", False)
args.seqNorm = data.get("seqNorm", False)
args.dropout = data.get("dropout", False)
args.in_dim = data.get("in_dim", 1)
args.loss_reduction = data.get("loss_reduction | forward | identifier_name |
operational_test.go | }
return &testDb{
db: db,
blocks: blocks,
dbName: dbname,
dbNameVer: dbnamever,
cleanUpFunc: cleanUp,
}, nil
}
func TestOperational(t *testing.T) {
testOperationalMode(t)
}
// testAddrIndexOperations ensures that all normal operations concerning
// the optional address index function correctly.
func testAddrIndexOperations(t *testing.T, db database.Db, newestBlock *dcrutil.Block, newestSha *chainhash.Hash, newestBlockIdx int64) {
// Metadata about the current addr index state should be unset.
sha, height, err := db.FetchAddrIndexTip()
if err != database.ErrAddrIndexDoesNotExist {
t.Fatalf("Address index metadata shouldn't be in db, hasn't been built up yet.")
}
var zeroHash chainhash.Hash
if !sha.IsEqual(&zeroHash) {
t.Fatalf("AddrIndexTip wrong hash got: %s, want %s", sha, &zeroHash)
}
if height != -1 {
t.Fatalf("Addrindex not built up, yet a block index tip has been set to: %d.", height)
}
// Test enforcement of constraints for "limit" and "skip"
var fakeAddr dcrutil.Address
_, _, err = db.FetchTxsForAddr(fakeAddr, -1, 0, false)
if err == nil {
t.Fatalf("Negative value for skip passed, should return an error")
}
_, _, err = db.FetchTxsForAddr(fakeAddr, 0, -1, false)
if err == nil {
t.Fatalf("Negative value for limit passed, should return an error")
}
// Simple test to index outputs(s) of the first tx.
testIndex := make(database.BlockAddrIndex, database.AddrIndexKeySize)
testTx, err := newestBlock.Tx(0)
if err != nil {
t.Fatalf("Block has no transactions, unable to test addr "+
"indexing, err %v", err)
}
// Extract the dest addr from the tx.
_, testAddrs, _, err := txscript.ExtractPkScriptAddrs(testTx.MsgTx().TxOut[0].Version, testTx.MsgTx().TxOut[0].PkScript, &chaincfg.MainNetParams)
if err != nil {
t.Fatalf("Unable to decode tx output, err %v", err)
}
// Extract the hash160 from the output script.
var hash160Bytes [ripemd160.Size]byte
testHash160 := testAddrs[0].(*dcrutil.AddressScriptHash).Hash160()
copy(hash160Bytes[:], testHash160[:])
// Create a fake index.
blktxLoc, _, _ := newestBlock.TxLoc()
testIndex = []*database.TxAddrIndex{
&database.TxAddrIndex{
Hash160: hash160Bytes,
Height: uint32(newestBlockIdx),
TxOffset: uint32(blktxLoc[0].TxStart),
TxLen: uint32(blktxLoc[0].TxLen),
},
}
// Insert our test addr index into the DB.
err = db.UpdateAddrIndexForBlock(newestSha, newestBlockIdx, testIndex)
if err != nil {
t.Fatalf("UpdateAddrIndexForBlock: failed to index"+
" addrs for block #%d (%s) "+
"err %v", newestBlockIdx, newestSha, err)
}
// Chain Tip of address should've been updated.
assertAddrIndexTipIsUpdated(db, t, newestSha, newestBlockIdx)
// Check index retrieval.
txReplies, _, err := db.FetchTxsForAddr(testAddrs[0], 0, 1000, false)
if err != nil {
t.Fatalf("FetchTxsForAddr failed to correctly fetch txs for an "+
"address, err %v", err)
}
// Should have one reply.
if len(txReplies) != 1 {
t.Fatalf("Failed to properly index tx by address.")
}
// Our test tx and indexed tx should have the same sha.
indexedTx := txReplies[0]
if !bytes.Equal(indexedTx.Sha.Bytes(), testTx.Sha().Bytes()) {
t.Fatalf("Failed to fetch proper indexed tx. Expected sha %v, "+
"fetched %v", testTx.Sha(), indexedTx.Sha)
}
// Shut down DB.
db.Sync()
db.Close()
// Re-Open, tip still should be updated to current height and sha.
db, err = database.OpenDB("leveldb", "tstdbopmode")
if err != nil {
t.Fatalf("Unable to re-open created db, err %v", err)
}
assertAddrIndexTipIsUpdated(db, t, newestSha, newestBlockIdx)
// Delete the entire index.
err = db.PurgeAddrIndex()
if err != nil {
t.Fatalf("Couldn't delete address index, err %v", err)
}
// Former index should no longer exist.
txReplies, _, err = db.FetchTxsForAddr(testAddrs[0], 0, 1000, false)
if err != nil {
t.Fatalf("Unable to fetch transactions for address: %v", err)
}
if len(txReplies) != 0 {
t.Fatalf("Address index was not successfully deleted. "+
"Should have 0 tx's indexed, %v were returned.",
len(txReplies))
}
// Tip should be blanked out.
if _, _, err := db.FetchAddrIndexTip(); err != database.ErrAddrIndexDoesNotExist {
t.Fatalf("Address index was not fully deleted.")
}
}
func assertAddrIndexTipIsUpdated(db database.Db, t *testing.T, newestSha *chainhash.Hash, newestBlockIdx int64) {
// Safe to ignore error, since height will be < 0 in "error" case.
sha, height, _ := db.FetchAddrIndexTip()
if newestBlockIdx != height {
t.Fatalf("Height of address index tip failed to update, "+
"expected %v, got %v", newestBlockIdx, height)
}
if !bytes.Equal(newestSha.Bytes(), sha.Bytes()) {
t.Fatalf("Sha of address index tip failed to update, "+
"expected %v, got %v", newestSha, sha)
}
}
func testOperationalMode(t *testing.T) {
// simplified basic operation is:
// 1) fetch block from remote server
// 2) look up all txin (except coinbase in db)
// 3) insert block
// 4) exercise the optional addridex
testDb, err := setUpTestDb(t, "tstdbopmode")
if err != nil {
t.Errorf("Failed to open test database %v", err)
return
}
defer testDb.cleanUpFunc()
err = nil
out:
for height := int64(0); height < int64(len(testDb.blocks)); height++ {
block := testDb.blocks[height]
if height != 0 {
// except for NoVerify which does not allow lookups check inputs
mblock := block.MsgBlock()
//t.Errorf("%v", blockchain.DebugBlockString(block))
parentBlock := testDb.blocks[height-1]
mParentBlock := parentBlock.MsgBlock()
var txneededList []*chainhash.Hash
opSpentInBlock := make(map[wire.OutPoint]struct{})
if dcrutil.IsFlagSet16(dcrutil.BlockValid, mParentBlock.Header.VoteBits) {
for _, tx := range mParentBlock.Transactions {
for _, txin := range tx.TxIn {
if txin.PreviousOutPoint.Index == uint32(4294967295) {
continue
}
if existsInOwnBlockRegTree(mParentBlock, txin.PreviousOutPoint.Hash) {
_, used := opSpentInBlock[txin.PreviousOutPoint]
if !used {
// Origin tx is in the block and so hasn't been
// added yet, continue
opSpentInBlock[txin.PreviousOutPoint] = struct{}{}
continue
} else {
t.Errorf("output ref %v attempted double spend of previously spend output", txin.PreviousOutPoint)
}
}
origintxsha := &txin.PreviousOutPoint.Hash
txneededList = append(txneededList, origintxsha)
exists, err := testDb.db.Exists | {
// Ignore db remove errors since it means we didn't have an old one.
dbnamever := dbname + ".ver"
_ = os.RemoveAll(dbname)
_ = os.RemoveAll(dbnamever)
db, err := database.CreateDB("leveldb", dbname)
if err != nil {
return nil, err
}
testdatafile := filepath.Join("..", "/../blockchain/testdata", "blocks0to168.bz2")
blocks, err := loadBlocks(t, testdatafile)
if err != nil {
return nil, err
}
cleanUp := func() {
db.Close()
os.RemoveAll(dbname)
os.RemoveAll(dbnamever) | identifier_body | |
operational_test.go | ktxLoc[0].TxStart),
TxLen: uint32(blktxLoc[0].TxLen),
},
}
// Insert our test addr index into the DB.
err = db.UpdateAddrIndexForBlock(newestSha, newestBlockIdx, testIndex)
if err != nil {
t.Fatalf("UpdateAddrIndexForBlock: failed to index"+
" addrs for block #%d (%s) "+
"err %v", newestBlockIdx, newestSha, err)
}
// Chain Tip of address should've been updated.
assertAddrIndexTipIsUpdated(db, t, newestSha, newestBlockIdx)
// Check index retrieval.
txReplies, _, err := db.FetchTxsForAddr(testAddrs[0], 0, 1000, false)
if err != nil {
t.Fatalf("FetchTxsForAddr failed to correctly fetch txs for an "+
"address, err %v", err)
}
// Should have one reply.
if len(txReplies) != 1 {
t.Fatalf("Failed to properly index tx by address.")
}
// Our test tx and indexed tx should have the same sha.
indexedTx := txReplies[0]
if !bytes.Equal(indexedTx.Sha.Bytes(), testTx.Sha().Bytes()) {
t.Fatalf("Failed to fetch proper indexed tx. Expected sha %v, "+
"fetched %v", testTx.Sha(), indexedTx.Sha)
}
// Shut down DB.
db.Sync()
db.Close()
// Re-Open, tip still should be updated to current height and sha.
db, err = database.OpenDB("leveldb", "tstdbopmode")
if err != nil {
t.Fatalf("Unable to re-open created db, err %v", err)
}
assertAddrIndexTipIsUpdated(db, t, newestSha, newestBlockIdx)
// Delete the entire index.
err = db.PurgeAddrIndex()
if err != nil {
t.Fatalf("Couldn't delete address index, err %v", err)
}
// Former index should no longer exist.
txReplies, _, err = db.FetchTxsForAddr(testAddrs[0], 0, 1000, false)
if err != nil {
t.Fatalf("Unable to fetch transactions for address: %v", err)
}
if len(txReplies) != 0 {
t.Fatalf("Address index was not successfully deleted. "+
"Should have 0 tx's indexed, %v were returned.",
len(txReplies))
}
// Tip should be blanked out.
if _, _, err := db.FetchAddrIndexTip(); err != database.ErrAddrIndexDoesNotExist {
t.Fatalf("Address index was not fully deleted.")
}
}
func assertAddrIndexTipIsUpdated(db database.Db, t *testing.T, newestSha *chainhash.Hash, newestBlockIdx int64) {
// Safe to ignore error, since height will be < 0 in "error" case.
sha, height, _ := db.FetchAddrIndexTip()
if newestBlockIdx != height {
t.Fatalf("Height of address index tip failed to update, "+
"expected %v, got %v", newestBlockIdx, height)
}
if !bytes.Equal(newestSha.Bytes(), sha.Bytes()) {
t.Fatalf("Sha of address index tip failed to update, "+
"expected %v, got %v", newestSha, sha)
}
}
func testOperationalMode(t *testing.T) {
// simplified basic operation is:
// 1) fetch block from remote server
// 2) look up all txin (except coinbase in db)
// 3) insert block
// 4) exercise the optional addridex
testDb, err := setUpTestDb(t, "tstdbopmode")
if err != nil {
t.Errorf("Failed to open test database %v", err)
return
}
defer testDb.cleanUpFunc()
err = nil
out:
for height := int64(0); height < int64(len(testDb.blocks)); height++ {
block := testDb.blocks[height]
if height != 0 {
// except for NoVerify which does not allow lookups check inputs
mblock := block.MsgBlock()
//t.Errorf("%v", blockchain.DebugBlockString(block))
parentBlock := testDb.blocks[height-1]
mParentBlock := parentBlock.MsgBlock()
var txneededList []*chainhash.Hash
opSpentInBlock := make(map[wire.OutPoint]struct{})
if dcrutil.IsFlagSet16(dcrutil.BlockValid, mParentBlock.Header.VoteBits) {
for _, tx := range mParentBlock.Transactions {
for _, txin := range tx.TxIn {
if txin.PreviousOutPoint.Index == uint32(4294967295) {
continue
}
if existsInOwnBlockRegTree(mParentBlock, txin.PreviousOutPoint.Hash) {
_, used := opSpentInBlock[txin.PreviousOutPoint]
if !used {
// Origin tx is in the block and so hasn't been
// added yet, continue
opSpentInBlock[txin.PreviousOutPoint] = struct{}{}
continue
} else {
t.Errorf("output ref %v attempted double spend of previously spend output", txin.PreviousOutPoint)
}
}
origintxsha := &txin.PreviousOutPoint.Hash
txneededList = append(txneededList, origintxsha)
exists, err := testDb.db.ExistsTxSha(origintxsha)
if err != nil {
t.Errorf("ExistsTxSha: unexpected error %v ", err)
}
if !exists {
t.Errorf("referenced tx not found %v (height %v)", origintxsha, height)
}
_, err = testDb.db.FetchTxBySha(origintxsha)
if err != nil {
t.Errorf("referenced tx not found %v err %v ", origintxsha, err)
}
}
}
}
for _, stx := range mblock.STransactions {
for _, txin := range stx.TxIn {
if txin.PreviousOutPoint.Index == uint32(4294967295) {
continue
}
if existsInOwnBlockRegTree(mParentBlock, txin.PreviousOutPoint.Hash) {
_, used := opSpentInBlock[txin.PreviousOutPoint]
if !used {
// Origin tx is in the block and so hasn't been
// added yet, continue
opSpentInBlock[txin.PreviousOutPoint] = struct{}{}
continue
} else {
t.Errorf("output ref %v attempted double spend of previously spend output", txin.PreviousOutPoint)
}
}
origintxsha := &txin.PreviousOutPoint.Hash
txneededList = append(txneededList, origintxsha)
exists, err := testDb.db.ExistsTxSha(origintxsha)
if err != nil {
t.Errorf("ExistsTxSha: unexpected error %v ", err)
}
if !exists {
t.Errorf("referenced tx not found %v", origintxsha)
}
_, err = testDb.db.FetchTxBySha(origintxsha)
if err != nil {
t.Errorf("referenced tx not found %v err %v ", origintxsha, err)
}
}
}
txlist := testDb.db.FetchUnSpentTxByShaList(txneededList)
for _, txe := range txlist {
if txe.Err != nil {
t.Errorf("tx list fetch failed %v err %v ", txe.Sha, txe.Err)
break out
}
}
}
newheight, err := testDb.db.InsertBlock(block)
if err != nil {
t.Errorf("failed to insert block %v err %v", height, err)
break out
}
if newheight != height {
t.Errorf("height mismatch expect %v returned %v", height, newheight)
break out
}
newSha, blkid, err := testDb.db.NewestSha()
if err != nil |
if blkid != height {
t.Errorf("height does not match latest block height %v %v %v", blkid, height, err)
}
blkSha := block.Sha()
if *newSha != *blkSha {
t.Errorf("Newest block sha does not match freshly inserted one %v %v %v ", newSha, blkSha, err)
}
}
// now that the db is populated, do some additional tests
testFetchHeightRange(t, testDb.db, testDb.blocks)
// Ensure all operations dealing with the optional address index behave
// correctly.
newSha, blkid, err := testDb.db.NewestSha()
testAddrIndexOperations(t, testDb.db, testDb.blocks[len(testDb.blocks)-1 | {
t.Errorf("failed to obtain latest sha %v %v", height, err)
} | conditional_block |
operational_test.go | ktxLoc[0].TxStart),
TxLen: uint32(blktxLoc[0].TxLen),
},
}
// Insert our test addr index into the DB.
err = db.UpdateAddrIndexForBlock(newestSha, newestBlockIdx, testIndex)
if err != nil {
t.Fatalf("UpdateAddrIndexForBlock: failed to index"+
" addrs for block #%d (%s) "+
"err %v", newestBlockIdx, newestSha, err)
}
// Chain Tip of address should've been updated.
assertAddrIndexTipIsUpdated(db, t, newestSha, newestBlockIdx)
// Check index retrieval.
txReplies, _, err := db.FetchTxsForAddr(testAddrs[0], 0, 1000, false)
if err != nil {
t.Fatalf("FetchTxsForAddr failed to correctly fetch txs for an "+
"address, err %v", err)
}
// Should have one reply.
if len(txReplies) != 1 {
t.Fatalf("Failed to properly index tx by address.")
}
// Our test tx and indexed tx should have the same sha.
indexedTx := txReplies[0]
if !bytes.Equal(indexedTx.Sha.Bytes(), testTx.Sha().Bytes()) {
t.Fatalf("Failed to fetch proper indexed tx. Expected sha %v, "+
"fetched %v", testTx.Sha(), indexedTx.Sha)
}
// Shut down DB.
db.Sync()
db.Close()
// Re-Open, tip still should be updated to current height and sha.
db, err = database.OpenDB("leveldb", "tstdbopmode")
if err != nil {
t.Fatalf("Unable to re-open created db, err %v", err)
}
assertAddrIndexTipIsUpdated(db, t, newestSha, newestBlockIdx)
// Delete the entire index.
err = db.PurgeAddrIndex()
if err != nil {
t.Fatalf("Couldn't delete address index, err %v", err)
}
// Former index should no longer exist.
txReplies, _, err = db.FetchTxsForAddr(testAddrs[0], 0, 1000, false)
if err != nil {
t.Fatalf("Unable to fetch transactions for address: %v", err)
}
if len(txReplies) != 0 {
t.Fatalf("Address index was not successfully deleted. "+
"Should have 0 tx's indexed, %v were returned.",
len(txReplies))
}
// Tip should be blanked out.
if _, _, err := db.FetchAddrIndexTip(); err != database.ErrAddrIndexDoesNotExist {
t.Fatalf("Address index was not fully deleted.")
}
}
func | (db database.Db, t *testing.T, newestSha *chainhash.Hash, newestBlockIdx int64) {
// Safe to ignore error, since height will be < 0 in "error" case.
sha, height, _ := db.FetchAddrIndexTip()
if newestBlockIdx != height {
t.Fatalf("Height of address index tip failed to update, "+
"expected %v, got %v", newestBlockIdx, height)
}
if !bytes.Equal(newestSha.Bytes(), sha.Bytes()) {
t.Fatalf("Sha of address index tip failed to update, "+
"expected %v, got %v", newestSha, sha)
}
}
func testOperationalMode(t *testing.T) {
// simplified basic operation is:
// 1) fetch block from remote server
// 2) look up all txin (except coinbase in db)
// 3) insert block
// 4) exercise the optional addridex
testDb, err := setUpTestDb(t, "tstdbopmode")
if err != nil {
t.Errorf("Failed to open test database %v", err)
return
}
defer testDb.cleanUpFunc()
err = nil
out:
for height := int64(0); height < int64(len(testDb.blocks)); height++ {
block := testDb.blocks[height]
if height != 0 {
// except for NoVerify which does not allow lookups check inputs
mblock := block.MsgBlock()
//t.Errorf("%v", blockchain.DebugBlockString(block))
parentBlock := testDb.blocks[height-1]
mParentBlock := parentBlock.MsgBlock()
var txneededList []*chainhash.Hash
opSpentInBlock := make(map[wire.OutPoint]struct{})
if dcrutil.IsFlagSet16(dcrutil.BlockValid, mParentBlock.Header.VoteBits) {
for _, tx := range mParentBlock.Transactions {
for _, txin := range tx.TxIn {
if txin.PreviousOutPoint.Index == uint32(4294967295) {
continue
}
if existsInOwnBlockRegTree(mParentBlock, txin.PreviousOutPoint.Hash) {
_, used := opSpentInBlock[txin.PreviousOutPoint]
if !used {
// Origin tx is in the block and so hasn't been
// added yet, continue
opSpentInBlock[txin.PreviousOutPoint] = struct{}{}
continue
} else {
t.Errorf("output ref %v attempted double spend of previously spend output", txin.PreviousOutPoint)
}
}
origintxsha := &txin.PreviousOutPoint.Hash
txneededList = append(txneededList, origintxsha)
exists, err := testDb.db.ExistsTxSha(origintxsha)
if err != nil {
t.Errorf("ExistsTxSha: unexpected error %v ", err)
}
if !exists {
t.Errorf("referenced tx not found %v (height %v)", origintxsha, height)
}
_, err = testDb.db.FetchTxBySha(origintxsha)
if err != nil {
t.Errorf("referenced tx not found %v err %v ", origintxsha, err)
}
}
}
}
for _, stx := range mblock.STransactions {
for _, txin := range stx.TxIn {
if txin.PreviousOutPoint.Index == uint32(4294967295) {
continue
}
if existsInOwnBlockRegTree(mParentBlock, txin.PreviousOutPoint.Hash) {
_, used := opSpentInBlock[txin.PreviousOutPoint]
if !used {
// Origin tx is in the block and so hasn't been
// added yet, continue
opSpentInBlock[txin.PreviousOutPoint] = struct{}{}
continue
} else {
t.Errorf("output ref %v attempted double spend of previously spend output", txin.PreviousOutPoint)
}
}
origintxsha := &txin.PreviousOutPoint.Hash
txneededList = append(txneededList, origintxsha)
exists, err := testDb.db.ExistsTxSha(origintxsha)
if err != nil {
t.Errorf("ExistsTxSha: unexpected error %v ", err)
}
if !exists {
t.Errorf("referenced tx not found %v", origintxsha)
}
_, err = testDb.db.FetchTxBySha(origintxsha)
if err != nil {
t.Errorf("referenced tx not found %v err %v ", origintxsha, err)
}
}
}
txlist := testDb.db.FetchUnSpentTxByShaList(txneededList)
for _, txe := range txlist {
if txe.Err != nil {
t.Errorf("tx list fetch failed %v err %v ", txe.Sha, txe.Err)
break out
}
}
}
newheight, err := testDb.db.InsertBlock(block)
if err != nil {
t.Errorf("failed to insert block %v err %v", height, err)
break out
}
if newheight != height {
t.Errorf("height mismatch expect %v returned %v", height, newheight)
break out
}
newSha, blkid, err := testDb.db.NewestSha()
if err != nil {
t.Errorf("failed to obtain latest sha %v %v", height, err)
}
if blkid != height {
t.Errorf("height does not match latest block height %v %v %v", blkid, height, err)
}
blkSha := block.Sha()
if *newSha != *blkSha {
t.Errorf("Newest block sha does not match freshly inserted one %v %v %v ", newSha, blkSha, err)
}
}
// now that the db is populated, do some additional tests
testFetchHeightRange(t, testDb.db, testDb.blocks)
// Ensure all operations dealing with the optional address index behave
// correctly.
newSha, blkid, err := testDb.db.NewestSha()
testAddrIndexOperations(t, testDb.db, testDb.blocks[len(testDb.blocks)-1], | assertAddrIndexTipIsUpdated | identifier_name |
operational_test.go | ExistsSha: unexpected error: %v", err)
}
_, err = testDb.db.FetchBlockBySha(sha)
if err != nil {
t.Errorf("failed to load block 99 from db %v", err)
return
}
sha = testDb.blocks[119].Sha()
if _, err := testDb.db.ExistsSha(sha); err != nil {
t.Errorf("ExistsSha: unexpected error: %v", err)
}
_, err = testDb.db.FetchBlockBySha(sha)
if err != nil {
t.Errorf("loaded block 119 from db")
return
}
// pick block 118 since tx for block 119 wont be inserted until block 120 is seen to be valid
block := testDb.blocks[118]
mblock := block.MsgBlock()
txsha := mblock.Transactions[0].TxSha()
exists, err := testDb.db.ExistsTxSha(&txsha)
if err != nil {
t.Errorf("ExistsTxSha: unexpected error %v ", err)
}
if !exists {
t.Errorf("tx %v not located db\n", txsha)
}
_, err = testDb.db.FetchTxBySha(&txsha)
if err != nil {
t.Errorf("tx %v not located db\n", txsha)
return
}
}
func loadBlocks(t *testing.T, file string) (blocks []*dcrutil.Block, err error) {
fi, err := os.Open(file)
if err != nil {
t.Errorf("failed to open file %v, err %v", file, err)
return nil, err
}
bcStream := bzip2.NewReader(fi)
defer fi.Close()
// Create a buffer of the read file
bcBuf := new(bytes.Buffer)
bcBuf.ReadFrom(bcStream)
// Create decoder from the buffer and a map to store the data
bcDecoder := gob.NewDecoder(bcBuf)
blockchain := make(map[int64][]byte)
// Decode the blockchain into the map
if err := bcDecoder.Decode(&blockchain); err != nil {
t.Errorf("error decoding test blockchain")
}
blocks = make([]*dcrutil.Block, 0, len(blockchain))
for height := int64(1); height < int64(len(blockchain)); height++ {
block, err := dcrutil.NewBlockFromBytes(blockchain[height])
if err != nil {
t.Errorf("failed to parse block %v", height)
return nil, err
}
block.SetHeight(height - 1)
blocks = append(blocks, block)
}
return
}
func testFetchHeightRange(t *testing.T, db database.Db, blocks []*dcrutil.Block) {
var testincrement int64 = 50
var testcnt int64 = 100
shanames := make([]*chainhash.Hash, len(blocks))
nBlocks := int64(len(blocks))
for i := range blocks {
shanames[i] = blocks[i].Sha()
}
for startheight := int64(0); startheight < nBlocks; startheight += testincrement {
endheight := startheight + testcnt
if endheight > nBlocks {
endheight = database.AllShas
}
shalist, err := db.FetchHeightRange(startheight, endheight)
if err != nil {
t.Errorf("FetchHeightRange: unexpected failure looking up shas %v", err)
}
if endheight == database.AllShas {
if int64(len(shalist)) != nBlocks-startheight {
t.Errorf("FetchHeightRange: expected A %v shas, got %v", nBlocks-startheight, len(shalist))
}
} else {
if int64(len(shalist)) != testcnt {
t.Errorf("FetchHeightRange: expected %v shas, got %v", testcnt, len(shalist))
}
}
for i := range shalist {
sha0 := *shanames[int64(i)+startheight]
sha1 := shalist[i]
if sha0 != sha1 {
t.Errorf("FetchHeightRange: mismatch sha at %v requested range %v %v: %v %v ", int64(i)+startheight, startheight, endheight, sha0, sha1)
}
}
}
}
func TestLimitAndSkipFetchTxsForAddr(t *testing.T) {
testDb, err := setUpTestDb(t, "tstdbtxaddr")
if err != nil {
t.Errorf("Failed to open test database %v", err)
return
}
defer testDb.cleanUpFunc()
_, err = testDb.db.InsertBlock(testDb.blocks[0])
if err != nil {
t.Fatalf("failed to insert initial block")
}
// Insert a block with some fake test transactions. The block will have
// 10 copies of a fake transaction involving same address.
addrString := "DsZEAobx6qJ7K2qaHZBA2vBn66Nor8KYAKk"
targetAddr, err := dcrutil.DecodeAddress(addrString, &chaincfg.MainNetParams)
if err != nil {
t.Fatalf("Unable to decode test address: %v", err)
}
outputScript, err := txscript.PayToAddrScript(targetAddr)
if err != nil {
t.Fatalf("Unable make test pkScript %v", err)
}
fakeTxOut := wire.NewTxOut(10, outputScript)
var emptyHash chainhash.Hash
fakeHeader := wire.NewBlockHeader(0, &emptyHash, &emptyHash, &emptyHash, 1, [6]byte{}, 1, 1, 1, 1, 1, 1, 1, 1, 1, [36]byte{})
msgBlock := wire.NewMsgBlock(fakeHeader)
for i := 0; i < 10; i++ {
mtx := wire.NewMsgTx()
mtx.AddTxOut(fakeTxOut)
msgBlock.AddTransaction(mtx)
}
lastBlock := testDb.blocks[0]
msgBlock.Header.PrevBlock = *lastBlock.Sha()
// Insert the test block into the DB.
testBlock := dcrutil.NewBlock(msgBlock)
newheight, err := testDb.db.InsertBlock(testBlock)
if err != nil {
t.Fatalf("Unable to insert block into db: %v", err)
}
// Create and insert an address index for out test addr.
txLoc, _, _ := testBlock.TxLoc()
index := make(database.BlockAddrIndex, len(txLoc))
for i := range testBlock.Transactions() {
var hash160 [ripemd160.Size]byte
scriptAddr := targetAddr.ScriptAddress()
copy(hash160[:], scriptAddr[:])
txAddrIndex := &database.TxAddrIndex{
Hash160: hash160,
Height: uint32(newheight),
TxOffset: uint32(txLoc[i].TxStart),
TxLen: uint32(txLoc[i].TxLen),
}
index[i] = txAddrIndex
}
blkSha := testBlock.Sha()
err = testDb.db.UpdateAddrIndexForBlock(blkSha, newheight, index)
if err != nil {
t.Fatalf("UpdateAddrIndexForBlock: failed to index"+
" addrs for block #%d (%s) "+
"err %v", newheight, blkSha, err)
return
}
// Try skipping the first 4 results, should get 6 in return.
txReply, txSkipped, err := testDb.db.FetchTxsForAddr(targetAddr, 4, 100000, false)
if err != nil {
t.Fatalf("Unable to fetch transactions for address: %v", err)
}
if txSkipped != 4 {
t.Fatalf("Did not correctly return skipped amount"+
" got %v txs, expected %v", txSkipped, 4)
}
if len(txReply) != 6 {
t.Fatalf("Did not correctly skip forward in txs for address reply"+
" got %v txs, expected %v", len(txReply), 6)
}
// Limit the number of results to 3.
txReply, txSkipped, err = testDb.db.FetchTxsForAddr(targetAddr, 0, 3, false)
if err != nil {
t.Fatalf("Unable to fetch transactions for address: %v", err)
}
if txSkipped != 0 {
t.Fatalf("Did not correctly return skipped amount"+
" got %v txs, expected %v", txSkipped, 0)
}
if len(txReply) != 3 {
t.Fatalf("Did not correctly limit in txs for address reply"+
" got %v txs, expected %v", len(txReply), 3)
}
// Skip 1, limit 5.
txReply, txSkipped, err = testDb.db.FetchTxsForAddr(targetAddr, 1, 5, false)
if err != nil {
t.Fatalf("Unable to fetch transactions for address: %v", err) | }
if txSkipped != 1 { | random_line_split | |
kc_pattern_scanner.py | ((df["high"] - df["close"])/(.001 + df["high"] - df["low"]) > 0.6) & \
((df["high"] - df["open"])/(.001 + df["high"] - df["low"]) > 0.6)) & \
(abs(df["close"] - df["open"]) > 0.1* (df["high"] - df["low"]))
return df
def levels(ohlc_day):
"""returns pivot point and support/resistance levels"""
high = round(ohlc_day["high"][-1],2)
low = round(ohlc_day["low"][-1],2)
close = round(ohlc_day["close"][-1],2)
pivot = round((high + low + close)/3,2)
r1 = round((2*pivot - low),2)
r2 = round((pivot + (high - low)),2)
r3 = round((high + 2*(pivot - low)),2)
s1 = round((2*pivot - high),2)
s2 = round((pivot - (high - low)),2)
s3 = round((low - 2*(high - pivot)),2)
return (pivot,r1,r2,r3,s1,s2,s3)
def trend(ohlc_df,n):
"function to assess the trend by analyzing each candle"
df = ohlc_df.copy()
df["up"] = np.where(df["low"]>=df["low"].shift(1),1,0)
df["dn"] = np.where(df["high"]<=df["high"].shift(1),1,0)
if df["close"][-1] > df["open"][-1]:
if df["up"][-1*n:].sum() >= 0.7*n:
return "uptrend"
elif df["open"][-1] > df["close"][-1]:
if df["dn"][-1*n:].sum() >= 0.7*n:
return "downtrend"
else:
return None
def res_sup(ohlc_df,ohlc_day):
"""calculates closest resistance and support levels for a given candle"""
level = ((ohlc_df["close"][-1] + ohlc_df["open"][-1])/2 + (ohlc_df["high"][-1] + ohlc_df["low"][-1])/2)/2
p,r1,r2,r3,s1,s2,s3 = levels(ohlc_day)
l_r1=level-r1
l_r2=level-r2
l_r3=level-r3
l_p=level-p
l_s1=level-s1
l_s2=level-s2
l_s3=level-s3
lev_ser = pd.Series([l_p,l_r1,l_r2,l_r3,l_s1,l_s2,l_s3],index=["p","r1","r2","r3","s1","s2","s3"])
sup = lev_ser[lev_ser>0].idxmin()
res = lev_ser[lev_ser<0].idxmax()
return (eval('{}'.format(res)), eval('{}'.format(sup)))
def candle_type(ohlc_df):
"""returns the candle type of the last candle of an OHLC DF"""
candle = None
if doji(ohlc_df)["doji"][-1] == True:
candle = "doji"
if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_green":
candle = "maru_bozu_green"
if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_red":
candle = "maru_bozu_red"
if shooting_star(ohlc_df)["sstar"][-1] == True:
candle = "shooting_star"
if hammer(ohlc_df)["hammer"][-1] == True:
candle = "hammer"
return candle
def candle_pattern(ohlc_df,ohlc_day):
"""returns the candle pattern identified"""
pattern = None
signi = "low"
avg_candle_size = abs(ohlc_df["close"] - ohlc_df["open"]).median()
sup, res = res_sup(ohlc_df,ohlc_day)
if (sup - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (sup + 1.5*avg_candle_size):
signi = "HIGH"
if (res - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (res + 1.5*avg_candle_size):
signi = "HIGH"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] > ohlc_df["close"][-2] \
and ohlc_df["close"][-1] > ohlc_df["open"][-1]:
pattern = "doji_bullish"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] < ohlc_df["close"][-2] \
and ohlc_df["close"][-1] < ohlc_df["open"][-1]:
pattern = "doji_bearish"
if candle_type(ohlc_df) == "maru_bozu_green":
pattern = "maru_bozu_bullish"
if candle_type(ohlc_df) == "maru_bozu_red":
pattern = "maru_bozu_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "hammer":
pattern = "hanging_man_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" and candle_type(ohlc_df) == "hammer":
pattern = "hammer_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "shooting_star":
pattern = "shooting_star_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["close"][-2] \
and ohlc_df["low"][-1] > ohlc_df["open"][-2]:
pattern = "harami_cross_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["open"][-2] \
and ohlc_df["low"][-1] > ohlc_df["close"][-2]:
pattern = "harami_cross_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["open"][-1] > ohlc_df["high"][-2] \
and ohlc_df["close"][-1] < ohlc_df["low"][-2]:
pattern = "engulfing_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["close"][-1] > ohlc_df["high"][-2] \
and ohlc_df["open"][-1] < ohlc_df["low"][-2]:
|
return "Significance - {}, Pattern - {}".format(signi,pattern)
##############################################################################################
tickers = ["BHEL",
"CONCOR",
"ASTRAL",
"INDHOTEL",
"DALBHARAT",
"COFORGE",
"ITI",
"IPCALAB",
"SUMICHEM",
"DHANI",
"DIXON",
"SUNTV",
"FEDERALBNK",
"OFSS",
"COROMANDEL",
"RECLTD",
"VOLTAS",
"ISEC",
"AUBANK",
"BALKRISIND",
"GSPL",
"HAL",
"POLYCAB",
"TATACHEM",
"SUPREMEIND",
"LTTS",
"BHARATFORG",
"HATSUN",
"TVSMOTOR",
"GMRINFRA",
"TRENT",
"MOTILALOFS",
"L&TFH",
"ATUL",
"AIAENG",
"GLAXO",
"JSWENERGY",
"SKFINDIA",
"IDBI",
"PRESTIGE",
"NHPC",
"ATGL",
"TIINDIA",
"SJVN",
"MINDAIND",
"CANBK",
"VINATIORGA",
"BANKINDIA",
"OIL",
"BBTC",
"PFC",
"GODREJAGRO",
"AAVAS",
"EXIDEIND",
"WHIRLPOOL | pattern = "engulfing_bullish" | conditional_block |
kc_pattern_scanner.py | 3=level-s3
lev_ser = pd.Series([l_p,l_r1,l_r2,l_r3,l_s1,l_s2,l_s3],index=["p","r1","r2","r3","s1","s2","s3"])
sup = lev_ser[lev_ser>0].idxmin()
res = lev_ser[lev_ser<0].idxmax()
return (eval('{}'.format(res)), eval('{}'.format(sup)))
def candle_type(ohlc_df):
"""returns the candle type of the last candle of an OHLC DF"""
candle = None
if doji(ohlc_df)["doji"][-1] == True:
candle = "doji"
if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_green":
candle = "maru_bozu_green"
if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_red":
candle = "maru_bozu_red"
if shooting_star(ohlc_df)["sstar"][-1] == True:
candle = "shooting_star"
if hammer(ohlc_df)["hammer"][-1] == True:
candle = "hammer"
return candle
def candle_pattern(ohlc_df,ohlc_day):
"""returns the candle pattern identified"""
pattern = None
signi = "low"
avg_candle_size = abs(ohlc_df["close"] - ohlc_df["open"]).median()
sup, res = res_sup(ohlc_df,ohlc_day)
if (sup - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (sup + 1.5*avg_candle_size):
signi = "HIGH"
if (res - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (res + 1.5*avg_candle_size):
signi = "HIGH"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] > ohlc_df["close"][-2] \
and ohlc_df["close"][-1] > ohlc_df["open"][-1]:
pattern = "doji_bullish"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] < ohlc_df["close"][-2] \
and ohlc_df["close"][-1] < ohlc_df["open"][-1]:
pattern = "doji_bearish"
if candle_type(ohlc_df) == "maru_bozu_green":
pattern = "maru_bozu_bullish"
if candle_type(ohlc_df) == "maru_bozu_red":
pattern = "maru_bozu_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "hammer":
pattern = "hanging_man_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" and candle_type(ohlc_df) == "hammer":
pattern = "hammer_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "shooting_star":
pattern = "shooting_star_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["close"][-2] \
and ohlc_df["low"][-1] > ohlc_df["open"][-2]:
pattern = "harami_cross_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["open"][-2] \
and ohlc_df["low"][-1] > ohlc_df["close"][-2]:
pattern = "harami_cross_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["open"][-1] > ohlc_df["high"][-2] \
and ohlc_df["close"][-1] < ohlc_df["low"][-2]:
pattern = "engulfing_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["close"][-1] > ohlc_df["high"][-2] \
and ohlc_df["open"][-1] < ohlc_df["low"][-2]:
pattern = "engulfing_bullish"
return "Significance - {}, Pattern - {}".format(signi,pattern)
##############################################################################################
tickers = ["BHEL",
"CONCOR",
"ASTRAL",
"INDHOTEL",
"DALBHARAT",
"COFORGE",
"ITI",
"IPCALAB",
"SUMICHEM",
"DHANI",
"DIXON",
"SUNTV",
"FEDERALBNK",
"OFSS",
"COROMANDEL",
"RECLTD",
"VOLTAS",
"ISEC",
"AUBANK",
"BALKRISIND",
"GSPL",
"HAL",
"POLYCAB",
"TATACHEM",
"SUPREMEIND",
"LTTS",
"BHARATFORG",
"HATSUN",
"TVSMOTOR",
"GMRINFRA",
"TRENT",
"MOTILALOFS",
"L&TFH",
"ATUL",
"AIAENG",
"GLAXO",
"JSWENERGY",
"SKFINDIA",
"IDBI",
"PRESTIGE",
"NHPC",
"ATGL",
"TIINDIA",
"SJVN",
"MINDAIND",
"CANBK",
"VINATIORGA",
"BANKINDIA",
"OIL",
"BBTC",
"PFC",
"GODREJAGRO",
"AAVAS",
"EXIDEIND",
"WHIRLPOOL",
"MAXHEALTH",
"GODREJPROP",
"VBL",
"3MINDIA",
"METROPOLIS",
"ASTRAZEN",
"MGL",
"SRF",
"APOLLOTYRE",
"MFSL",
"BATAINDIA",
"UNIONBANK",
"VGUARD",
"ZYDUSWELL",
"PFIZER",
"BAYERCROP",
"IRCTC",
"CASTROLIND",
"SANOFI",
"ABFRL",
"FORTIS",
"CESC",
"PERSISTENT",
"GODREJIND",
"MPHASIS",
"PHOENIXLTD",
"CHOLAHLDNG",
"DEEPAKNTR",
"HONAUT",
"TATACOMM",
"JMFINANCIL",
"LICHSGFIN",
"CUMMINSIND",
"GICRE",
"THERMAX",
"SOLARINDS",
"SRTRANSFIN",
"LAURUSLABS",
"IDFCFIRSTB",
"CUB",
"NIACL",
"NAVINFLUOR",
"OBEROIRLTY",
"TATAELXSI",
"RELAXO",
"MANAPPURAM",
"CRISIL",
"AMARAJABAT",
"GUJGASLTD",
"BANKBARODA",
"AARTIIND",
"M&MFIN",
"ASHOKLEY",
"PGHL",
"PIIND",
"GILLETTE",
"ABCAPITAL",
"APLLTD",
"CROMPTON",
"NAM-INDIA",
"ABB",
"TTKPRESTIG",
"SUVENPHAR",
"IDEA",
"BEL",
"SCHAEFFLER",
"ZEEL",
"RBLBANK",
"RAMCOCEM",
"GLENMARK",
"RAJESHEXPO",
"SUNDRMFAST",
"EMAMILTD",
"ENDURANCE",
"SYNGENE",
"AKZOINDIA",
"LALPATHLAB",
"HINDZINC",
"TATAPOWER",
"JKCEMENT",
"ESCORTS",
"SUNDARMFIN",
"IIFLWAM",
"IBULHSGFIN",
"CREDITACC",
"KANSAINER",
"MINDTREE",
"PAGEIND",
"CHOLAFIN",
"AJANTPHARM",
"NATCOPHARM",
"JINDALSTEL",
"TORNTPOWER",
"SAIL",
"INDIAMART",
"GAIL",
"HINDPETRO",
"JUBLFOOD",
"ADANITRANS",
"BOSCHLTD",
"IGL",
"SIEMENS",
"PETRONET",
"ICICIPRULI",
"ACC",
"MARICO",
"AMBUJACEM",
"BERGEPAINT",
"PIDILITIND",
"INDUSTOWER",
"ABBOTINDIA",
"BIOCON",
"MCDOWELL-N",
"PGHH",
"DMART",
"MRF",
| "DLF",
| random_line_split | |
kc_pattern_scanner.py | if (res - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (res + 1.5*avg_candle_size):
signi = "HIGH"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] > ohlc_df["close"][-2] \
and ohlc_df["close"][-1] > ohlc_df["open"][-1]:
pattern = "doji_bullish"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] < ohlc_df["close"][-2] \
and ohlc_df["close"][-1] < ohlc_df["open"][-1]:
pattern = "doji_bearish"
if candle_type(ohlc_df) == "maru_bozu_green":
pattern = "maru_bozu_bullish"
if candle_type(ohlc_df) == "maru_bozu_red":
pattern = "maru_bozu_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "hammer":
pattern = "hanging_man_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" and candle_type(ohlc_df) == "hammer":
pattern = "hammer_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "shooting_star":
pattern = "shooting_star_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["close"][-2] \
and ohlc_df["low"][-1] > ohlc_df["open"][-2]:
pattern = "harami_cross_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["open"][-2] \
and ohlc_df["low"][-1] > ohlc_df["close"][-2]:
pattern = "harami_cross_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["open"][-1] > ohlc_df["high"][-2] \
and ohlc_df["close"][-1] < ohlc_df["low"][-2]:
pattern = "engulfing_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["close"][-1] > ohlc_df["high"][-2] \
and ohlc_df["open"][-1] < ohlc_df["low"][-2]:
pattern = "engulfing_bullish"
return "Significance - {}, Pattern - {}".format(signi,pattern)
##############################################################################################
tickers = ["BHEL",
"CONCOR",
"ASTRAL",
"INDHOTEL",
"DALBHARAT",
"COFORGE",
"ITI",
"IPCALAB",
"SUMICHEM",
"DHANI",
"DIXON",
"SUNTV",
"FEDERALBNK",
"OFSS",
"COROMANDEL",
"RECLTD",
"VOLTAS",
"ISEC",
"AUBANK",
"BALKRISIND",
"GSPL",
"HAL",
"POLYCAB",
"TATACHEM",
"SUPREMEIND",
"LTTS",
"BHARATFORG",
"HATSUN",
"TVSMOTOR",
"GMRINFRA",
"TRENT",
"MOTILALOFS",
"L&TFH",
"ATUL",
"AIAENG",
"GLAXO",
"JSWENERGY",
"SKFINDIA",
"IDBI",
"PRESTIGE",
"NHPC",
"ATGL",
"TIINDIA",
"SJVN",
"MINDAIND",
"CANBK",
"VINATIORGA",
"BANKINDIA",
"OIL",
"BBTC",
"PFC",
"GODREJAGRO",
"AAVAS",
"EXIDEIND",
"WHIRLPOOL",
"MAXHEALTH",
"GODREJPROP",
"VBL",
"3MINDIA",
"METROPOLIS",
"ASTRAZEN",
"MGL",
"SRF",
"APOLLOTYRE",
"MFSL",
"BATAINDIA",
"UNIONBANK",
"VGUARD",
"ZYDUSWELL",
"PFIZER",
"BAYERCROP",
"IRCTC",
"CASTROLIND",
"SANOFI",
"ABFRL",
"FORTIS",
"CESC",
"PERSISTENT",
"GODREJIND",
"MPHASIS",
"PHOENIXLTD",
"CHOLAHLDNG",
"DEEPAKNTR",
"HONAUT",
"TATACOMM",
"JMFINANCIL",
"LICHSGFIN",
"CUMMINSIND",
"GICRE",
"THERMAX",
"SOLARINDS",
"SRTRANSFIN",
"LAURUSLABS",
"IDFCFIRSTB",
"CUB",
"NIACL",
"NAVINFLUOR",
"OBEROIRLTY",
"TATAELXSI",
"RELAXO",
"MANAPPURAM",
"CRISIL",
"AMARAJABAT",
"GUJGASLTD",
"BANKBARODA",
"AARTIIND",
"M&MFIN",
"ASHOKLEY",
"PGHL",
"PIIND",
"GILLETTE",
"ABCAPITAL",
"APLLTD",
"CROMPTON",
"NAM-INDIA",
"ABB",
"TTKPRESTIG",
"SUVENPHAR",
"IDEA",
"BEL",
"SCHAEFFLER",
"ZEEL",
"RBLBANK",
"RAMCOCEM",
"GLENMARK",
"RAJESHEXPO",
"SUNDRMFAST",
"EMAMILTD",
"ENDURANCE",
"SYNGENE",
"AKZOINDIA",
"LALPATHLAB",
"HINDZINC",
"TATAPOWER",
"JKCEMENT",
"ESCORTS",
"SUNDARMFIN",
"IIFLWAM",
"IBULHSGFIN",
"CREDITACC",
"KANSAINER",
"MINDTREE",
"PAGEIND",
"CHOLAFIN",
"AJANTPHARM",
"NATCOPHARM",
"JINDALSTEL",
"TORNTPOWER",
"SAIL",
"INDIAMART",
"GAIL",
"HINDPETRO",
"JUBLFOOD",
"ADANITRANS",
"BOSCHLTD",
"IGL",
"SIEMENS",
"PETRONET",
"ICICIPRULI",
"ACC",
"MARICO",
"AMBUJACEM",
"BERGEPAINT",
"PIDILITIND",
"INDUSTOWER",
"ABBOTINDIA",
"BIOCON",
"MCDOWELL-N",
"PGHH",
"DMART",
"MRF",
"DLF",
"GODREJCP",
"COLPAL",
"HDFCAMC",
"YESBANK",
"VEDL",
"BAJAJHLDNG",
"DABUR",
"INDIGO",
"ALKEM",
"CADILAHC",
"MOTHERSUMI",
"HAVELLS",
"ADANIENT",
"UBL",
"SBICARD",
"PEL",
"BANDHANBNK",
"MUTHOOTFIN",
"TORNTPHARM",
"ICICIGI",
"LUPIN",
"LTI",
"APOLLOHOSP",
"ADANIGREEN",
"NAUKRI",
"NMDC",
"PNB",
"AUROPHARMA",
"COALINDIA",
"IOC",
"NTPC",
"ULTRACEMCO",
"BPCL",
"TATASTEEL",
"TATACONSUM",
"SUNPHARMA",
"TATAMOTORS",
"GRASIM",
"SHREECEM",
"SBIN",
"EICHERMOT",
"RELIANCE",
"BAJAJ-AUTO",
"INDUSINDBK",
"BRITANNIA",
"SBILIFE",
"UPL",
"ONGC",
"ADANIPORTS",
"POWERGRID",
"NESTLEIND",
"BHARTIARTL",
"TITAN",
"HEROMOTOCO",
"ASIANPAINT",
"MARUTI",
"ITC",
"ICICIBANK",
"HCLTECH",
"M&M",
"LT",
"INFY",
"BAJAJFINSV",
"DRREDDY",
"HDFCBANK",
"CIPLA",
"HDFCLIFE",
"TCS",
"AXISBANK",
"HINDUNILVR",
"JSWSTEEL",
"TECHM",
"BAJFINANCE",
"WIPRO",
"DIVISLAB",
"KOTAKBANK",
"HINDALCO",
"HDFC"]
#####################################################################################################
def | main | identifier_name | |
kc_pattern_scanner.py | ((df["high"] - df["close"])/(.001 + df["high"] - df["low"]) > 0.6) & \
((df["high"] - df["open"])/(.001 + df["high"] - df["low"]) > 0.6)) & \
(abs(df["close"] - df["open"]) > 0.1* (df["high"] - df["low"]))
return df
def levels(ohlc_day):
"""returns pivot point and support/resistance levels"""
high = round(ohlc_day["high"][-1],2)
low = round(ohlc_day["low"][-1],2)
close = round(ohlc_day["close"][-1],2)
pivot = round((high + low + close)/3,2)
r1 = round((2*pivot - low),2)
r2 = round((pivot + (high - low)),2)
r3 = round((high + 2*(pivot - low)),2)
s1 = round((2*pivot - high),2)
s2 = round((pivot - (high - low)),2)
s3 = round((low - 2*(high - pivot)),2)
return (pivot,r1,r2,r3,s1,s2,s3)
def trend(ohlc_df,n):
|
def res_sup(ohlc_df,ohlc_day):
"""calculates closest resistance and support levels for a given candle"""
level = ((ohlc_df["close"][-1] + ohlc_df["open"][-1])/2 + (ohlc_df["high"][-1] + ohlc_df["low"][-1])/2)/2
p,r1,r2,r3,s1,s2,s3 = levels(ohlc_day)
l_r1=level-r1
l_r2=level-r2
l_r3=level-r3
l_p=level-p
l_s1=level-s1
l_s2=level-s2
l_s3=level-s3
lev_ser = pd.Series([l_p,l_r1,l_r2,l_r3,l_s1,l_s2,l_s3],index=["p","r1","r2","r3","s1","s2","s3"])
sup = lev_ser[lev_ser>0].idxmin()
res = lev_ser[lev_ser<0].idxmax()
return (eval('{}'.format(res)), eval('{}'.format(sup)))
def candle_type(ohlc_df):
"""returns the candle type of the last candle of an OHLC DF"""
candle = None
if doji(ohlc_df)["doji"][-1] == True:
candle = "doji"
if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_green":
candle = "maru_bozu_green"
if maru_bozu(ohlc_df)["maru_bozu"][-1] == "maru_bozu_red":
candle = "maru_bozu_red"
if shooting_star(ohlc_df)["sstar"][-1] == True:
candle = "shooting_star"
if hammer(ohlc_df)["hammer"][-1] == True:
candle = "hammer"
return candle
def candle_pattern(ohlc_df,ohlc_day):
"""returns the candle pattern identified"""
pattern = None
signi = "low"
avg_candle_size = abs(ohlc_df["close"] - ohlc_df["open"]).median()
sup, res = res_sup(ohlc_df,ohlc_day)
if (sup - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (sup + 1.5*avg_candle_size):
signi = "HIGH"
if (res - 1.5*avg_candle_size) < ohlc_df["close"][-1] < (res + 1.5*avg_candle_size):
signi = "HIGH"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] > ohlc_df["close"][-2] \
and ohlc_df["close"][-1] > ohlc_df["open"][-1]:
pattern = "doji_bullish"
if candle_type(ohlc_df) == 'doji' \
and ohlc_df["close"][-1] < ohlc_df["close"][-2] \
and ohlc_df["close"][-1] < ohlc_df["open"][-1]:
pattern = "doji_bearish"
if candle_type(ohlc_df) == "maru_bozu_green":
pattern = "maru_bozu_bullish"
if candle_type(ohlc_df) == "maru_bozu_red":
pattern = "maru_bozu_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "hammer":
pattern = "hanging_man_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" and candle_type(ohlc_df) == "hammer":
pattern = "hammer_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" and candle_type(ohlc_df) == "shooting_star":
pattern = "shooting_star_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["close"][-2] \
and ohlc_df["low"][-1] > ohlc_df["open"][-2]:
pattern = "harami_cross_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) == "doji" \
and ohlc_df["high"][-1] < ohlc_df["open"][-2] \
and ohlc_df["low"][-1] > ohlc_df["close"][-2]:
pattern = "harami_cross_bullish"
if trend(ohlc_df.iloc[:-1,:],7) == "uptrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["open"][-1] > ohlc_df["high"][-2] \
and ohlc_df["close"][-1] < ohlc_df["low"][-2]:
pattern = "engulfing_bearish"
if trend(ohlc_df.iloc[:-1,:],7) == "downtrend" \
and candle_type(ohlc_df) != "doji" \
and ohlc_df["close"][-1] > ohlc_df["high"][-2] \
and ohlc_df["open"][-1] < ohlc_df["low"][-2]:
pattern = "engulfing_bullish"
return "Significance - {}, Pattern - {}".format(signi,pattern)
##############################################################################################
tickers = ["BHEL",
"CONCOR",
"ASTRAL",
"INDHOTEL",
"DALBHARAT",
"COFORGE",
"ITI",
"IPCALAB",
"SUMICHEM",
"DHANI",
"DIXON",
"SUNTV",
"FEDERALBNK",
"OFSS",
"COROMANDEL",
"RECLTD",
"VOLTAS",
"ISEC",
"AUBANK",
"BALKRISIND",
"GSPL",
"HAL",
"POLYCAB",
"TATACHEM",
"SUPREMEIND",
"LTTS",
"BHARATFORG",
"HATSUN",
"TVSMOTOR",
"GMRINFRA",
"TRENT",
"MOTILALOFS",
"L&TFH",
"ATUL",
"AIAENG",
"GLAXO",
"JSWENERGY",
"SKFINDIA",
"IDBI",
"PRESTIGE",
"NHPC",
"ATGL",
"TIINDIA",
"SJVN",
"MINDAIND",
"CANBK",
"VINATIORGA",
"BANKINDIA",
"OIL",
"BBTC",
"PFC",
"GODREJAGRO",
"AAVAS",
"EXIDEIND",
"WHIRLPOOL",
| "function to assess the trend by analyzing each candle"
df = ohlc_df.copy()
df["up"] = np.where(df["low"]>=df["low"].shift(1),1,0)
df["dn"] = np.where(df["high"]<=df["high"].shift(1),1,0)
if df["close"][-1] > df["open"][-1]:
if df["up"][-1*n:].sum() >= 0.7*n:
return "uptrend"
elif df["open"][-1] > df["close"][-1]:
if df["dn"][-1*n:].sum() >= 0.7*n:
return "downtrend"
else:
return None | identifier_body |
tex_mobject.py | objectFromSVGPathstring.pointwise_become_partial(
self, mobject, 0, b
)
self.set_stroke(width=added_width + mobject.get_stroke_width())
self.set_fill(opacity=opacity)
class SingleStringTexMobject(SVGMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEX_FILE,
"stroke_width": 0,
"fill_opacity": 1.0,
"should_center": True,
"height": None,
"organize_left_to_right": False,
"propagate_style_to_family": True,
"alignment": "",
}
def __init__(self, tex_string, **kwargs):
digest_config(self, kwargs)
assert(isinstance(tex_string, str))
self.tex_string = tex_string
file_name = tex_to_svg_file(
self.get_modified_expression(tex_string),
self.template_tex_file
)
SVGMobject.__init__(self, file_name=file_name, **kwargs)
if self.height is None:
self.scale(TEX_MOB_SCALE_FACTOR)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def get_modified_expression(self, tex_string):
result = self.alignment + " " + tex_string
result = result.strip()
result = self.modify_special_strings(result)
return result
def modify_special_strings(self, tex):
tex = self.remove_stray_braces(tex)
if tex in ["\\over", "\\overline"]:
# fraction line needs something to be over
tex += "\\,"
if tex == "\\sqrt":
tex += "{\\quad}"
if tex == "\\substack":
tex = ""
for t1, t2 in ("\\left", "\\right"), ("\\right", "\\left"):
should_replace = reduce(op.and_, [
t1 in tex,
t2 not in tex,
len(tex) > len(t1) and tex[len(t1)] in "()[]<>|.\\"
])
if should_replace:
tex = tex.replace(t1, "\\big")
if tex == "":
tex = "\\quad"
return tex
def remove_stray_braces(self, tex):
"""
Makes TexMobject resiliant to unmatched { at start
"""
num_lefts, num_rights = [
tex.count(char)
for char in "{}"
]
if num_rights > num_lefts:
backwards = tex[::-1].replace("}", "", num_rights - num_lefts)
tex = backwards[::-1]
elif num_lefts > num_rights:
tex = tex.replace("{", "", num_lefts - num_rights)
return tex
def get_tex_string(self):
return self.tex_string
def path_string_to_mobject(self, path_string):
# Overwrite superclass default to use
# specialized path_string mobject
return TexSymbol(path_string)
def organize_submobjects_left_to_right(self):
self.sort_submobjects(lambda p: p[0])
return self
class TexMobject(SingleStringTexMobject):
CONFIG = {
"arg_separator": " ",
"substrings_to_isolate": [],
"tex_to_color_map": {},
}
def __init__(self, *tex_strings, **kwargs):
digest_config(self, kwargs)
tex_strings = self.break_up_tex_strings(tex_strings)
self.tex_strings = tex_strings
SingleStringTexMobject.__init__(
self, self.arg_separator.join(tex_strings), **kwargs
)
self.break_up_by_substrings()
self.set_color_by_tex_to_color_map(self.tex_to_color_map)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def break_up_tex_strings(self, tex_strings):
substrings_to_isolate = op.add(
self.substrings_to_isolate,
self.tex_to_color_map.keys()
)
split_list = split_string_list_to_isolate_substring(
tex_strings, *substrings_to_isolate
)
split_list = map(str.strip, split_list)
split_list = filter(lambda s: s != '', split_list)
return split_list
def break_up_by_substrings(self):
"""
Reorganize existing submojects one layer
deeper based on the structure of tex_strings (as a list
of tex_strings)
"""
new_submobjects = []
curr_index = 0
for tex_string in self.tex_strings:
sub_tex_mob = SingleStringTexMobject(tex_string, **self.CONFIG)
num_submobs = len(sub_tex_mob.submobjects)
new_index = curr_index + num_submobs
if num_submobs == 0:
# For cases like empty tex_strings, we want the corresponing
# part of the whole TexMobject to be a VectorizedPoint
# positioned in the right part of the TexMobject
sub_tex_mob.submobjects = [VectorizedPoint()]
last_submob_index = min(curr_index, len(self.submobjects) - 1)
sub_tex_mob.move_to(self.submobjects[last_submob_index], RIGHT)
else:
sub_tex_mob.submobjects = self.submobjects[curr_index:new_index]
new_submobjects.append(sub_tex_mob)
curr_index = new_index
self.submobjects = new_submobjects
return self
def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):
def test(tex1, tex2):
if not case_sensitive:
tex1 = tex1.lower()
tex2 = tex2.lower()
if substring:
return tex1 in tex2
else:
return tex1 == tex2
return VGroup(*filter(
lambda m: test(tex, m.get_tex_string()),
self.submobjects
))
def get_part_by_tex(self, tex, **kwargs):
all_parts = self.get_parts_by_tex(tex, **kwargs)
return all_parts[0] if all_parts else None
def set_color_by_tex(self, tex, color, **kwargs):
parts_to_color = self.get_parts_by_tex(tex, **kwargs)
for part in parts_to_color:
part.set_color(color)
return self
def set_color_by_tex_to_color_map(self, texs_to_color_map, **kwargs):
for texs, color in texs_to_color_map.items():
try:
# If the given key behaves like tex_strings
texs + ''
self.set_color_by_tex(texs, color, **kwargs)
except TypeError:
# If the given key is a tuple
for tex in texs:
self.set_color_by_tex(tex, color, **kwargs)
return self
def index_of_part(self, part):
split_self = self.split()
if part not in split_self:
raise Exception("Trying to get index of part not in TexMobject")
return split_self.index(part)
def index_of_part_by_tex(self, tex, **kwargs):
part = self.get_part_by_tex(tex, **kwargs)
return self.index_of_part(part)
def split(self):
# Many old scenes assume that when you pass in a single string
# to TexMobject, it indexes across the characters.
if len(self.submobjects) == 1:
return self.submobjects[0].split()
else:
return super(TexMobject, self).split()
class TextMobject(TexMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "\\centering",
}
class BulletedList(TextMobject):
CONFIG = {
"buff": MED_LARGE_BUFF,
"dot_scale_factor": 2,
# Have to include because of handle_multiple_args implementation
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "",
}
def __init__(self, *items, **kwargs):
line_separated_items = [s + "\\\\" for s in items]
TextMobject.__init__(self, *line_separated_items, **kwargs)
for part in self:
dot = TexMobject("\\cdot").scale(self.dot_scale_factor)
dot.next_to(part[0], LEFT, SMALL_BUFF)
part.add_to_back(dot)
self.arrange_submobjects(
DOWN,
aligned_edge=LEFT,
buff=self.buff
)
def fade_all_but(self, index_or_string, opacity=0.5):
arg = index_or_string
if isinstance(arg, str):
part = self.get_part_by_tex(arg)
elif isinstance(arg, int):
part = self.submobjects[arg]
else:
raise Exception("Expected int or string, got {0}".format(arg))
for other_part in self.submobjects:
if other_part is part:
other_part.set_fill(opacity=1)
else:
other_part.set_fill(opacity=opacity)
class TexMobjectFromPresetString(TexMobject):
def __init__(self, **kwargs):
digest_config(self, kwargs)
TexMobject.__init__(self, self.tex, **kwargs)
self.set_color(self.color)
##########
def tex_hash(expression, template_tex_file):
return str(hash(expression + template_tex_file))
def | (expression, template_tex_file):
image_dir = os.path.join(
TEX_IMAGE_DIR,
tex_hash(expression, template_tex_file)
)
if os.path.exists(image_dir):
return get | tex_to_svg_file | identifier_name |
tex_mobject.py | objectFromSVGPathstring.pointwise_become_partial(
self, mobject, 0, b
)
self.set_stroke(width=added_width + mobject.get_stroke_width())
self.set_fill(opacity=opacity)
class SingleStringTexMobject(SVGMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEX_FILE,
"stroke_width": 0,
"fill_opacity": 1.0,
"should_center": True,
"height": None,
"organize_left_to_right": False,
"propagate_style_to_family": True,
"alignment": "",
}
def __init__(self, tex_string, **kwargs):
digest_config(self, kwargs)
assert(isinstance(tex_string, str))
self.tex_string = tex_string
file_name = tex_to_svg_file(
self.get_modified_expression(tex_string),
self.template_tex_file
)
SVGMobject.__init__(self, file_name=file_name, **kwargs)
if self.height is None:
self.scale(TEX_MOB_SCALE_FACTOR)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def get_modified_expression(self, tex_string):
result = self.alignment + " " + tex_string
result = result.strip()
result = self.modify_special_strings(result)
return result
def modify_special_strings(self, tex):
tex = self.remove_stray_braces(tex)
if tex in ["\\over", "\\overline"]:
# fraction line needs something to be over
tex += "\\,"
if tex == "\\sqrt":
tex += "{\\quad}"
if tex == "\\substack":
|
for t1, t2 in ("\\left", "\\right"), ("\\right", "\\left"):
should_replace = reduce(op.and_, [
t1 in tex,
t2 not in tex,
len(tex) > len(t1) and tex[len(t1)] in "()[]<>|.\\"
])
if should_replace:
tex = tex.replace(t1, "\\big")
if tex == "":
tex = "\\quad"
return tex
def remove_stray_braces(self, tex):
"""
Makes TexMobject resiliant to unmatched { at start
"""
num_lefts, num_rights = [
tex.count(char)
for char in "{}"
]
if num_rights > num_lefts:
backwards = tex[::-1].replace("}", "", num_rights - num_lefts)
tex = backwards[::-1]
elif num_lefts > num_rights:
tex = tex.replace("{", "", num_lefts - num_rights)
return tex
def get_tex_string(self):
return self.tex_string
def path_string_to_mobject(self, path_string):
# Overwrite superclass default to use
# specialized path_string mobject
return TexSymbol(path_string)
def organize_submobjects_left_to_right(self):
self.sort_submobjects(lambda p: p[0])
return self
class TexMobject(SingleStringTexMobject):
CONFIG = {
"arg_separator": " ",
"substrings_to_isolate": [],
"tex_to_color_map": {},
}
def __init__(self, *tex_strings, **kwargs):
digest_config(self, kwargs)
tex_strings = self.break_up_tex_strings(tex_strings)
self.tex_strings = tex_strings
SingleStringTexMobject.__init__(
self, self.arg_separator.join(tex_strings), **kwargs
)
self.break_up_by_substrings()
self.set_color_by_tex_to_color_map(self.tex_to_color_map)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def break_up_tex_strings(self, tex_strings):
substrings_to_isolate = op.add(
self.substrings_to_isolate,
self.tex_to_color_map.keys()
)
split_list = split_string_list_to_isolate_substring(
tex_strings, *substrings_to_isolate
)
split_list = map(str.strip, split_list)
split_list = filter(lambda s: s != '', split_list)
return split_list
def break_up_by_substrings(self):
"""
Reorganize existing submojects one layer
deeper based on the structure of tex_strings (as a list
of tex_strings)
"""
new_submobjects = []
curr_index = 0
for tex_string in self.tex_strings:
sub_tex_mob = SingleStringTexMobject(tex_string, **self.CONFIG)
num_submobs = len(sub_tex_mob.submobjects)
new_index = curr_index + num_submobs
if num_submobs == 0:
# For cases like empty tex_strings, we want the corresponing
# part of the whole TexMobject to be a VectorizedPoint
# positioned in the right part of the TexMobject
sub_tex_mob.submobjects = [VectorizedPoint()]
last_submob_index = min(curr_index, len(self.submobjects) - 1)
sub_tex_mob.move_to(self.submobjects[last_submob_index], RIGHT)
else:
sub_tex_mob.submobjects = self.submobjects[curr_index:new_index]
new_submobjects.append(sub_tex_mob)
curr_index = new_index
self.submobjects = new_submobjects
return self
def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):
def test(tex1, tex2):
if not case_sensitive:
tex1 = tex1.lower()
tex2 = tex2.lower()
if substring:
return tex1 in tex2
else:
return tex1 == tex2
return VGroup(*filter(
lambda m: test(tex, m.get_tex_string()),
self.submobjects
))
def get_part_by_tex(self, tex, **kwargs):
all_parts = self.get_parts_by_tex(tex, **kwargs)
return all_parts[0] if all_parts else None
def set_color_by_tex(self, tex, color, **kwargs):
parts_to_color = self.get_parts_by_tex(tex, **kwargs)
for part in parts_to_color:
part.set_color(color)
return self
def set_color_by_tex_to_color_map(self, texs_to_color_map, **kwargs):
for texs, color in texs_to_color_map.items():
try:
# If the given key behaves like tex_strings
texs + ''
self.set_color_by_tex(texs, color, **kwargs)
except TypeError:
# If the given key is a tuple
for tex in texs:
self.set_color_by_tex(tex, color, **kwargs)
return self
def index_of_part(self, part):
split_self = self.split()
if part not in split_self:
raise Exception("Trying to get index of part not in TexMobject")
return split_self.index(part)
def index_of_part_by_tex(self, tex, **kwargs):
part = self.get_part_by_tex(tex, **kwargs)
return self.index_of_part(part)
def split(self):
# Many old scenes assume that when you pass in a single string
# to TexMobject, it indexes across the characters.
if len(self.submobjects) == 1:
return self.submobjects[0].split()
else:
return super(TexMobject, self).split()
class TextMobject(TexMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "\\centering",
}
class BulletedList(TextMobject):
CONFIG = {
"buff": MED_LARGE_BUFF,
"dot_scale_factor": 2,
# Have to include because of handle_multiple_args implementation
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "",
}
def __init__(self, *items, **kwargs):
line_separated_items = [s + "\\\\" for s in items]
TextMobject.__init__(self, *line_separated_items, **kwargs)
for part in self:
dot = TexMobject("\\cdot").scale(self.dot_scale_factor)
dot.next_to(part[0], LEFT, SMALL_BUFF)
part.add_to_back(dot)
self.arrange_submobjects(
DOWN,
aligned_edge=LEFT,
buff=self.buff
)
def fade_all_but(self, index_or_string, opacity=0.5):
arg = index_or_string
if isinstance(arg, str):
part = self.get_part_by_tex(arg)
elif isinstance(arg, int):
part = self.submobjects[arg]
else:
raise Exception("Expected int or string, got {0}".format(arg))
for other_part in self.submobjects:
if other_part is part:
other_part.set_fill(opacity=1)
else:
other_part.set_fill(opacity=opacity)
class TexMobjectFromPresetString(TexMobject):
def __init__(self, **kwargs):
digest_config(self, kwargs)
TexMobject.__init__(self, self.tex, **kwargs)
self.set_color(self.color)
##########
def tex_hash(expression, template_tex_file):
return str(hash(expression + template_tex_file))
def tex_to_svg_file(expression, template_tex_file):
image_dir = os.path.join(
TEX_IMAGE_DIR,
tex_hash(expression, template_tex_file)
)
if os.path.exists(image_dir):
return get | tex = "" | conditional_block |
tex_mobject.py | VMobjectFromSVGPathstring.pointwise_become_partial(
self, mobject, 0, b
)
self.set_stroke(width=added_width + mobject.get_stroke_width())
self.set_fill(opacity=opacity)
class SingleStringTexMobject(SVGMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEX_FILE,
"stroke_width": 0,
"fill_opacity": 1.0,
"should_center": True,
"height": None,
"organize_left_to_right": False,
"propagate_style_to_family": True,
"alignment": "",
}
def __init__(self, tex_string, **kwargs):
digest_config(self, kwargs)
assert(isinstance(tex_string, str))
self.tex_string = tex_string
file_name = tex_to_svg_file(
self.get_modified_expression(tex_string),
self.template_tex_file
)
SVGMobject.__init__(self, file_name=file_name, **kwargs)
if self.height is None:
self.scale(TEX_MOB_SCALE_FACTOR)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def get_modified_expression(self, tex_string):
result = self.alignment + " " + tex_string
result = result.strip()
result = self.modify_special_strings(result)
return result
def modify_special_strings(self, tex):
tex = self.remove_stray_braces(tex)
if tex in ["\\over", "\\overline"]:
# fraction line needs something to be over
tex += "\\,"
if tex == "\\sqrt":
tex += "{\\quad}"
if tex == "\\substack":
tex = ""
for t1, t2 in ("\\left", "\\right"), ("\\right", "\\left"):
should_replace = reduce(op.and_, [
t1 in tex,
t2 not in tex,
len(tex) > len(t1) and tex[len(t1)] in "()[]<>|.\\"
])
if should_replace:
tex = tex.replace(t1, "\\big")
if tex == "":
tex = "\\quad"
return tex
def remove_stray_braces(self, tex):
"""
Makes TexMobject resiliant to unmatched { at start
"""
num_lefts, num_rights = [
tex.count(char)
for char in "{}"
]
if num_rights > num_lefts:
backwards = tex[::-1].replace("}", "", num_rights - num_lefts)
tex = backwards[::-1]
elif num_lefts > num_rights:
tex = tex.replace("{", "", num_lefts - num_rights)
return tex
def get_tex_string(self):
return self.tex_string
def path_string_to_mobject(self, path_string):
# Overwrite superclass default to use
# specialized path_string mobject
return TexSymbol(path_string)
def organize_submobjects_left_to_right(self):
self.sort_submobjects(lambda p: p[0])
return self
class TexMobject(SingleStringTexMobject):
CONFIG = {
"arg_separator": " ",
"substrings_to_isolate": [],
"tex_to_color_map": {},
}
def __init__(self, *tex_strings, **kwargs):
digest_config(self, kwargs)
tex_strings = self.break_up_tex_strings(tex_strings)
self.tex_strings = tex_strings
SingleStringTexMobject.__init__(
self, self.arg_separator.join(tex_strings), **kwargs
)
self.break_up_by_substrings()
self.set_color_by_tex_to_color_map(self.tex_to_color_map)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def break_up_tex_strings(self, tex_strings):
substrings_to_isolate = op.add(
self.substrings_to_isolate,
self.tex_to_color_map.keys()
)
split_list = split_string_list_to_isolate_substring(
tex_strings, *substrings_to_isolate
)
split_list = map(str.strip, split_list)
split_list = filter(lambda s: s != '', split_list)
return split_list
def break_up_by_substrings(self):
"""
Reorganize existing submojects one layer
deeper based on the structure of tex_strings (as a list | """
new_submobjects = []
curr_index = 0
for tex_string in self.tex_strings:
sub_tex_mob = SingleStringTexMobject(tex_string, **self.CONFIG)
num_submobs = len(sub_tex_mob.submobjects)
new_index = curr_index + num_submobs
if num_submobs == 0:
# For cases like empty tex_strings, we want the corresponing
# part of the whole TexMobject to be a VectorizedPoint
# positioned in the right part of the TexMobject
sub_tex_mob.submobjects = [VectorizedPoint()]
last_submob_index = min(curr_index, len(self.submobjects) - 1)
sub_tex_mob.move_to(self.submobjects[last_submob_index], RIGHT)
else:
sub_tex_mob.submobjects = self.submobjects[curr_index:new_index]
new_submobjects.append(sub_tex_mob)
curr_index = new_index
self.submobjects = new_submobjects
return self
def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):
def test(tex1, tex2):
if not case_sensitive:
tex1 = tex1.lower()
tex2 = tex2.lower()
if substring:
return tex1 in tex2
else:
return tex1 == tex2
return VGroup(*filter(
lambda m: test(tex, m.get_tex_string()),
self.submobjects
))
def get_part_by_tex(self, tex, **kwargs):
all_parts = self.get_parts_by_tex(tex, **kwargs)
return all_parts[0] if all_parts else None
def set_color_by_tex(self, tex, color, **kwargs):
parts_to_color = self.get_parts_by_tex(tex, **kwargs)
for part in parts_to_color:
part.set_color(color)
return self
def set_color_by_tex_to_color_map(self, texs_to_color_map, **kwargs):
for texs, color in texs_to_color_map.items():
try:
# If the given key behaves like tex_strings
texs + ''
self.set_color_by_tex(texs, color, **kwargs)
except TypeError:
# If the given key is a tuple
for tex in texs:
self.set_color_by_tex(tex, color, **kwargs)
return self
def index_of_part(self, part):
split_self = self.split()
if part not in split_self:
raise Exception("Trying to get index of part not in TexMobject")
return split_self.index(part)
def index_of_part_by_tex(self, tex, **kwargs):
part = self.get_part_by_tex(tex, **kwargs)
return self.index_of_part(part)
def split(self):
# Many old scenes assume that when you pass in a single string
# to TexMobject, it indexes across the characters.
if len(self.submobjects) == 1:
return self.submobjects[0].split()
else:
return super(TexMobject, self).split()
class TextMobject(TexMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "\\centering",
}
class BulletedList(TextMobject):
CONFIG = {
"buff": MED_LARGE_BUFF,
"dot_scale_factor": 2,
# Have to include because of handle_multiple_args implementation
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "",
}
def __init__(self, *items, **kwargs):
line_separated_items = [s + "\\\\" for s in items]
TextMobject.__init__(self, *line_separated_items, **kwargs)
for part in self:
dot = TexMobject("\\cdot").scale(self.dot_scale_factor)
dot.next_to(part[0], LEFT, SMALL_BUFF)
part.add_to_back(dot)
self.arrange_submobjects(
DOWN,
aligned_edge=LEFT,
buff=self.buff
)
def fade_all_but(self, index_or_string, opacity=0.5):
arg = index_or_string
if isinstance(arg, str):
part = self.get_part_by_tex(arg)
elif isinstance(arg, int):
part = self.submobjects[arg]
else:
raise Exception("Expected int or string, got {0}".format(arg))
for other_part in self.submobjects:
if other_part is part:
other_part.set_fill(opacity=1)
else:
other_part.set_fill(opacity=opacity)
class TexMobjectFromPresetString(TexMobject):
def __init__(self, **kwargs):
digest_config(self, kwargs)
TexMobject.__init__(self, self.tex, **kwargs)
self.set_color(self.color)
##########
def tex_hash(expression, template_tex_file):
return str(hash(expression + template_tex_file))
def tex_to_svg_file(expression, template_tex_file):
image_dir = os.path.join(
TEX_IMAGE_DIR,
tex_hash(expression, template_tex_file)
)
if os.path.exists(image_dir):
return get_sorted | of tex_strings) | random_line_split |
tex_mobject.py | objectFromSVGPathstring.pointwise_become_partial(
self, mobject, 0, b
)
self.set_stroke(width=added_width + mobject.get_stroke_width())
self.set_fill(opacity=opacity)
class SingleStringTexMobject(SVGMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEX_FILE,
"stroke_width": 0,
"fill_opacity": 1.0,
"should_center": True,
"height": None,
"organize_left_to_right": False,
"propagate_style_to_family": True,
"alignment": "",
}
def __init__(self, tex_string, **kwargs):
digest_config(self, kwargs)
assert(isinstance(tex_string, str))
self.tex_string = tex_string
file_name = tex_to_svg_file(
self.get_modified_expression(tex_string),
self.template_tex_file
)
SVGMobject.__init__(self, file_name=file_name, **kwargs)
if self.height is None:
self.scale(TEX_MOB_SCALE_FACTOR)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def get_modified_expression(self, tex_string):
result = self.alignment + " " + tex_string
result = result.strip()
result = self.modify_special_strings(result)
return result
def modify_special_strings(self, tex):
tex = self.remove_stray_braces(tex)
if tex in ["\\over", "\\overline"]:
# fraction line needs something to be over
tex += "\\,"
if tex == "\\sqrt":
tex += "{\\quad}"
if tex == "\\substack":
tex = ""
for t1, t2 in ("\\left", "\\right"), ("\\right", "\\left"):
should_replace = reduce(op.and_, [
t1 in tex,
t2 not in tex,
len(tex) > len(t1) and tex[len(t1)] in "()[]<>|.\\"
])
if should_replace:
tex = tex.replace(t1, "\\big")
if tex == "":
tex = "\\quad"
return tex
def remove_stray_braces(self, tex):
"""
Makes TexMobject resiliant to unmatched { at start
"""
num_lefts, num_rights = [
tex.count(char)
for char in "{}"
]
if num_rights > num_lefts:
backwards = tex[::-1].replace("}", "", num_rights - num_lefts)
tex = backwards[::-1]
elif num_lefts > num_rights:
tex = tex.replace("{", "", num_lefts - num_rights)
return tex
def get_tex_string(self):
return self.tex_string
def path_string_to_mobject(self, path_string):
# Overwrite superclass default to use
# specialized path_string mobject
return TexSymbol(path_string)
def organize_submobjects_left_to_right(self):
self.sort_submobjects(lambda p: p[0])
return self
class TexMobject(SingleStringTexMobject):
CONFIG = {
"arg_separator": " ",
"substrings_to_isolate": [],
"tex_to_color_map": {},
}
def __init__(self, *tex_strings, **kwargs):
digest_config(self, kwargs)
tex_strings = self.break_up_tex_strings(tex_strings)
self.tex_strings = tex_strings
SingleStringTexMobject.__init__(
self, self.arg_separator.join(tex_strings), **kwargs
)
self.break_up_by_substrings()
self.set_color_by_tex_to_color_map(self.tex_to_color_map)
if self.organize_left_to_right:
self.organize_submobjects_left_to_right()
def break_up_tex_strings(self, tex_strings):
substrings_to_isolate = op.add(
self.substrings_to_isolate,
self.tex_to_color_map.keys()
)
split_list = split_string_list_to_isolate_substring(
tex_strings, *substrings_to_isolate
)
split_list = map(str.strip, split_list)
split_list = filter(lambda s: s != '', split_list)
return split_list
def break_up_by_substrings(self):
"""
Reorganize existing submojects one layer
deeper based on the structure of tex_strings (as a list
of tex_strings)
"""
new_submobjects = []
curr_index = 0
for tex_string in self.tex_strings:
sub_tex_mob = SingleStringTexMobject(tex_string, **self.CONFIG)
num_submobs = len(sub_tex_mob.submobjects)
new_index = curr_index + num_submobs
if num_submobs == 0:
# For cases like empty tex_strings, we want the corresponing
# part of the whole TexMobject to be a VectorizedPoint
# positioned in the right part of the TexMobject
sub_tex_mob.submobjects = [VectorizedPoint()]
last_submob_index = min(curr_index, len(self.submobjects) - 1)
sub_tex_mob.move_to(self.submobjects[last_submob_index], RIGHT)
else:
sub_tex_mob.submobjects = self.submobjects[curr_index:new_index]
new_submobjects.append(sub_tex_mob)
curr_index = new_index
self.submobjects = new_submobjects
return self
def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):
def test(tex1, tex2):
if not case_sensitive:
tex1 = tex1.lower()
tex2 = tex2.lower()
if substring:
return tex1 in tex2
else:
return tex1 == tex2
return VGroup(*filter(
lambda m: test(tex, m.get_tex_string()),
self.submobjects
))
def get_part_by_tex(self, tex, **kwargs):
all_parts = self.get_parts_by_tex(tex, **kwargs)
return all_parts[0] if all_parts else None
def set_color_by_tex(self, tex, color, **kwargs):
parts_to_color = self.get_parts_by_tex(tex, **kwargs)
for part in parts_to_color:
part.set_color(color)
return self
def set_color_by_tex_to_color_map(self, texs_to_color_map, **kwargs):
|
def index_of_part(self, part):
split_self = self.split()
if part not in split_self:
raise Exception("Trying to get index of part not in TexMobject")
return split_self.index(part)
def index_of_part_by_tex(self, tex, **kwargs):
part = self.get_part_by_tex(tex, **kwargs)
return self.index_of_part(part)
def split(self):
# Many old scenes assume that when you pass in a single string
# to TexMobject, it indexes across the characters.
if len(self.submobjects) == 1:
return self.submobjects[0].split()
else:
return super(TexMobject, self).split()
class TextMobject(TexMobject):
CONFIG = {
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "\\centering",
}
class BulletedList(TextMobject):
CONFIG = {
"buff": MED_LARGE_BUFF,
"dot_scale_factor": 2,
# Have to include because of handle_multiple_args implementation
"template_tex_file": TEMPLATE_TEXT_FILE,
"alignment": "",
}
def __init__(self, *items, **kwargs):
line_separated_items = [s + "\\\\" for s in items]
TextMobject.__init__(self, *line_separated_items, **kwargs)
for part in self:
dot = TexMobject("\\cdot").scale(self.dot_scale_factor)
dot.next_to(part[0], LEFT, SMALL_BUFF)
part.add_to_back(dot)
self.arrange_submobjects(
DOWN,
aligned_edge=LEFT,
buff=self.buff
)
def fade_all_but(self, index_or_string, opacity=0.5):
arg = index_or_string
if isinstance(arg, str):
part = self.get_part_by_tex(arg)
elif isinstance(arg, int):
part = self.submobjects[arg]
else:
raise Exception("Expected int or string, got {0}".format(arg))
for other_part in self.submobjects:
if other_part is part:
other_part.set_fill(opacity=1)
else:
other_part.set_fill(opacity=opacity)
class TexMobjectFromPresetString(TexMobject):
def __init__(self, **kwargs):
digest_config(self, kwargs)
TexMobject.__init__(self, self.tex, **kwargs)
self.set_color(self.color)
##########
def tex_hash(expression, template_tex_file):
return str(hash(expression + template_tex_file))
def tex_to_svg_file(expression, template_tex_file):
image_dir = os.path.join(
TEX_IMAGE_DIR,
tex_hash(expression, template_tex_file)
)
if os.path.exists(image_dir):
return get_sorted | for texs, color in texs_to_color_map.items():
try:
# If the given key behaves like tex_strings
texs + ''
self.set_color_by_tex(texs, color, **kwargs)
except TypeError:
# If the given key is a tuple
for tex in texs:
self.set_color_by_tex(tex, color, **kwargs)
return self | identifier_body |
index.js | /updateState', payload: {...obj} })
}
// mock columns
let columns = []
let overViewcolumns = [
{
dataIndex: "a",
key: "a",
title: "区域"
},
{
dataIndex: "b",
key: "b",
title: "事业部"
},
{
dataIndex: "c",
key: "c",
title: "水厂"
},
{
dataIndex: "d",
key: "d",
title: "运维模式"
}
]
// mock columns
let recordColumns = [
{
dataIndex: "a",
key: "a",
title: "日期"
},
{
dataIndex: "b",
key: "b",
title: "指标（为可选项）"
},
{
dataIndex: "c",
key: "c",
title: "起始时间"
},
{
dataIndex: "d",
key: "d",
title: "结束时间"
},
{
dataIndex: "e",
key: "e",
title: "情况说明"
},
{
dataIndex: "f",
key: "f",
title: "标液浓度（mg/L）"
},
{
dataIndex: "g",
key: "g",
title: "设备结果（mg/L）"
},
{
dataIndex: "h",
key: "h",
title: "人工监测结果（mg/L）"
},
{
dataIndex: "i",
key: "i",
title: "备注"
},
]
const optCol = [['操作', 'action', {
renderButtons: ()=>{
let btns = [];
if(buttonLimit['VIEW']) {
// 查看
btns.push({ name: <Icon type='view' title='查看'/>, onClick(rowData) {
updateState({
viewItem: {
...rowData
}
})
updateViewWindow()
} })
// 编辑
btns.push({ name: <Icon type='file-edit' title='编辑'/>, onClick(rowData) {
updateState({
editItem: {
...rowData
}
})
updateEditWindow();
}})
// 删除
btns.push({ name: <Icon type='delete' title='删除'/>, onClick(rowData) {
dispatch({
type: 'onlineOperation/deleteItems',
payload: ({
ids: [rowData.id],
onSuccess: (ids) => {
let page = currentPage !=1 && ids.length === (total - (currentPage -1) * pageSize) ? currentPage -1 : currentPage;
dispatch({ type: 'onlineOperation/getList', payload: { selectedRowKeys: [], currentPage: page } });
message.success('删除成功！')
},
onError: (msg) => { message.error(msg) }
})
})
}})
}
return btns
}, width: '150px'
}]]
columns = searchParams.dataFillType === 'produce' ? overViewcolumns : recordColumns
columns = columns.concat(handleColumns(optCol))
// 表格数据项配置
let vtxDatagridProps = {
columns,
dataSource,
indexColumn: true,
startIndex: (currentPage-1) * pageSize + 1,
autoFit: true,
loading,
pagination: {
showSizeChanger: true,
pageSizeOptions: ['10', '20', '30', '40', '50'],
showQuickJumper: true,
current: currentPage,
total,
pageSize,
showTotal: total => `合计 ${total} 条`
},
onChange(pagination, filters, sorter) {
dispatch({ type: 'onlineOperation', payload: {
currentPage: pagination.current,
pageSize: pagination.pageSize
}})
}
}
// 选择表格行
vtxDatagridProps = _.assign(vtxDatagridProps, {
rowSelection: {
type: 'checkbox',
selectedRowKeys,
onChange(selectedRowKeys, selectedRows) {
updateState({ selectedRowKeys })
}
}
})
// 获取表格数据
const getList = () => {
dispatch({ type: 'onlineOperation/updateQueryParams' });
dispatch({ type: 'onlineOperation/getList' });
}
// 查询
const vtxGridParams = {
nameProps: {
value: searchParams.name,
placeholder: '请输入名称',
allowClear: true,
style: {
width: '100%'
},
onChange(value) {
updateState({
searchParams: {
name: value
}
})
},
onPressEnter() {
getList()
},
},
query() {
getList()
},
clear() {
dispatch({ type: 'onlineOperation/initQueryParams'});
dispatch({ type: 'onlineOperation/getList' });
}
}
// mock下拉数据
const waterFactoryList = [ {
| d9a9e3750a34e91",
"value" : "测试水厂0001",
"name" : "测试水厂0001",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "c3e5d28d0da94357ad3625af1e58f342",
"value" : "水厂测试门户1",
"name" : "水厂测试门户1",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "757bc4e466b745b1adbfc39b887d4038",
"value" : "水厂5",
"name" : "水厂5",
"parentId" : "c95fe0e685a54030970e90e17864ace1"
}]
// 模态框名称
const modalTitle = searchParams.dataFillType==='produce' ? '在线概况' : '在线异常运维记录'
// 查看窗口
const updateViewWindow = (status = true) => {
updateState({
viewItem: {
visible: status
}
})
}
const viewItemProps = {
modalProps: {
title: `${modalTitle} > 查看`,
visible: viewItem.visible,
onCancel: () => updateViewWindow(false),
width: 1000
},
contentProps: {
...viewItem,
btnType: 'view'
}
}
// 编辑窗口
const updateEditWindow = (status = true) => {
updateState({
editItem: {
visible: status
}
})
}
const editItemProps = {
modalProps: {
title: `${modalTitle} > 编辑`,
visible: editItem.visible,
onCancel: () => updateEditWindow(false),
width: 1000
},
contentProps: {
...editItem,
btnType: 'edit'
}
}
// 新增窗口
const updateNewWindow = (status = true) => {
updateState({
newItem: {
visible: status
}
})
if(!status) {
dispatch({ type: 'onlineOperation/initNewItem' })
}
}
const newItemProps = {
modalProps: {
title: `${modalTitle} > 新增`,
visible: newItem.visible,
onCancel: () => updateNewWindow(false),
width: 1000
},
contentProps: {
...newItem,
btnType: 'add'
}
}
// 表格外功能-删除
const deleteItems = () => {
Modal.confirm({
content: `确定删除选中的${selectedRowKeys.length}条数据吗？`,
okText: '确定',
cancelText: '取消',
onOk() {
dispatch({
type: 'onlineOperation/deleteItems',
payload: {
ids: selectedRowKeys,
onSuccess: (ids) => {
let page = currentPage != 1 && ids.length === (total - (currentPage - 1) * pageSize) ? currentPage - 1 : currentPage;
dispatch({
type: 'onlineOperation/getList',
payload: {
selectedRowKeys: [],
currentPage: page
}
})
message.success('删除成功');
},
onError: (msg) => { message.error(msg); }
}
})
}
})
}
// 表格外功能-导出
let downloadURL = searchParams.dataFillType==='produce'?'/cloud/gzzhsw/api/cp/basic/pipelineNetPerformance/exportDataExcel':'/cloud/gzzhsw/api/cp/basic/sewageFactory/exportDataExcel'
const exportProps = {
downloadURL,
getExportParams(exportType) {
const param = {
tenant | "id" : "08ffc34f7b7444249 | identifier_body |
index.js | {
dataIndex: "c",
key: "c",
title: "起始时间"
},
{
dataIndex: "d",
key: "d",
title: "结束时间"
},
{
dataIndex: "e",
key: "e",
title: "情况说明"
},
{
dataIndex: "f",
key: "f",
title: "标液浓度（mg/L）"
},
{
dataIndex: "g",
key: "g",
title: "设备结果（mg/L）"
},
{
dataIndex: "h",
key: "h",
title: "人工监测结果（mg/L）"
},
{
dataIndex: "i",
key: "i",
title: "备注"
},
]
const optCol = [['操作', 'action', {
renderButtons: ()=>{
let btns = [];
if(buttonLimit['VIEW']) {
// 查看
btns.push({ name: <Icon type='view' title='查看'/>, onClick(rowData) {
updateState({
viewItem: {
...rowData
}
})
updateViewWindow()
} })
// 编辑
btns.push({ name: <Icon type='file-edit' title='编辑'/>, onClick(rowData) {
updateState({
editItem: {
...rowData
}
})
updateEditWindow();
}})
// 删除
btns.push({ name: <Icon type='delete' title='删除'/>, onClick(rowData) {
dispatch({
type: 'onlineOperation/deleteItems',
payload: ({
ids: [rowData.id],
onSuccess: (ids) => {
let page = currentPage !=1 && ids.length === (total - (currentPage -1) * pageSize) ? currentPage -1 : currentPage;
dispatch({ type: 'onlineOperation/getList', payload: { selectedRowKeys: [], currentPage: page } });
message.success('删除成功！')
},
onError: (msg) => { message.error(msg) }
})
})
}})
}
return btns
}, width: '150px'
}]]
columns = searchParams.dataFillType === 'produce' ? overViewcolumns : recordColumns
columns = columns.concat(handleColumns(optCol))
// 表格数据项配置
let vtxDatagridProps = {
columns,
dataSource,
indexColumn: true,
startIndex: (currentPage-1) * pageSize + 1,
autoFit: true,
loading,
pagination: {
showSizeChanger: true,
pageSizeOptions: ['10', '20', '30', '40', '50'],
showQuickJumper: true,
current: currentPage,
total,
pageSize,
showTotal: total => `合计 ${total} 条`
},
onChange(pagination, filters, sorter) {
dispatch({ type: 'onlineOperation', payload: {
currentPage: pagination.current,
pageSize: pagination.pageSize
}})
}
}
// 选择表格行
vtxDatagridProps = _.assign(vtxDatagridProps, {
rowSelection: {
type: 'checkbox',
selectedRowKeys,
onChange(selectedRowKeys, selectedRows) {
updateState({ selectedRowKeys })
}
}
})
// 获取表格数据
const getList = () => {
dispatch({ type: 'onlineOperation/updateQueryParams' });
dispatch({ type: 'onlineOperation/getList' });
}
// 查询
const vtxGridParams = {
nameProps: {
value: searchParams.name,
placeholder: '请输入名称',
allowClear: true,
style: {
width: '100%'
},
onChange(value) {
updateState({
searchParams: {
name: value
}
})
},
onPressEnter() {
getList()
},
},
query() {
getList()
},
clear() {
dispatch({ type: 'onlineOperation/initQueryParams'});
dispatch({ type: 'onlineOperation/getList' });
}
}
// mock下拉数据
const waterFactoryList = [ {
"id" : "08ffc34f7b7444249d9a9e3750a34e91",
"value" : "测试水厂0001",
"name" : "测试水厂0001",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "c3e5d28d0da94357ad3625af1e58f342",
"value" : "水厂测试门户1",
"name" : "水厂测试门户1",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "757bc4e466b745b1adbfc39b887d4038",
"value" : "水厂5",
"name" : "水厂5",
"parentId" : "c95fe0e685a54030970e90e17864ace1"
}]
// 模态框名称
const modalTitle = searchParams.dataFillType==='produce' ? '在线概况' : '在线异常运维记录'
// 查看窗口
const updateViewWindow = (status = true) => {
updateState({
viewItem: {
visible: status
}
})
}
const viewItemProps = {
modalProps: {
title: `${modalTitle} > 查看`,
visible: viewItem.visible,
onCancel: () => updateViewWindow(false),
width: 1000
},
contentProps: {
...viewItem,
btnType: 'view'
}
}
// 编辑窗口
const updateEditWindow = (status = true) => {
updateState({
editItem: {
visible: status
}
})
}
const editItemProps = {
modalProps: {
title: `${modalTitle} > 编辑`,
visible: editItem.visible,
onCancel: () => updateEditWindow(false),
width: 1000
},
contentProps: {
...editItem,
btnType: 'edit'
}
}
// 新增窗口
const updateNewWindow = (status = true) => {
updateState({
newItem: {
visible: status
}
})
if(!status) {
dispatch({ type: 'onlineOperation/initNewItem' })
}
}
const newItemProps = {
modalProps: {
title: `${modalTitle} > 新增`,
visible: newItem.visible,
onCancel: () => updateNewWindow(false),
width: 1000
},
contentProps: {
...newItem,
btnType: 'add'
}
}
// 表格外功能-删除
const deleteItems = () => {
Modal.confirm({
content: `确定删除选中的${selectedRowKeys.length}条数据吗？`,
okText: '确定',
cancelText: '取消',
onOk() {
dispatch({
type: 'onlineOperation/deleteItems',
payload: {
ids: selectedRowKeys,
onSuccess: (ids) => {
let page = currentPage != 1 && ids.length === (total - (currentPage - 1) * pageSize) ? currentPage - 1 : currentPage;
dispatch({
type: 'onlineOperation/getList',
payload: {
selectedRowKeys: [],
currentPage: page
}
})
message.success('删除成功');
},
onError: (msg) => { message.error(msg); }
}
})
}
})
}
// 表格外功能-导出
let downloadURL = searchParams.dataFillType==='produce'?'/cloud/gzzhsw/api/cp/basic/pipelineNetPerformance/exportDataExcel':'/cloud/gzzhsw/api/cp/basic/sewageFactory/exportDataExcel'
const exportProps = {
downloadURL,
getExportParams(exportType) {
const param = {
tenantId: VtxUtil.getUrlParam('tenantId'),
};
switch (exportType) {
case 'rows':
if (selectedRowKeys.length === 0) {
message.info('需要选择一项进行导出');
return;
}
param.isAll = false;
param.ids = selectedRowKeys.join();
break;
case 'page':
if (dataSource.length === 0) {
message.info('当前页没有数据');
return;
}
const ids = dataSource.map((item, index) => {
return item.id;
});
param.isAll = false;
param.ids = ids.join();
break;
case 'all':
if (total === 0) {
message.info('暂无数据可进 | 行导出');
return;
}
param.isAll = true;
}
| conditional_block | |
index.js | State', payload: {...obj} })
}
// mock columns
let columns = []
let overViewcolumns = [
{
dataIndex: "a",
key: "a",
title: "区域"
},
{
dataIndex: "b",
key: "b",
title: "事业部"
},
{
dataIndex: "c",
key: "c",
title: "水厂"
},
{
dataIndex: "d",
key: "d",
title: "运维模式"
}
]
// mock columns
let recordColumns = [
{
dataIndex: "a",
key: "a",
title: "日期"
},
{
dataIndex: "b",
key: "b",
title: "指标（为可选项）"
},
{
dataIndex: "c",
key: "c",
title: "起始时间"
},
{
dataIndex: "d",
key: "d",
title: "结束时间"
},
{
dataIndex: "e",
key: "e",
title: "情况说明"
},
{
dataIndex: "f",
key: "f",
title: "标液浓度（mg/L）"
},
{
dataIndex: "g",
key: "g",
title: "设备结果（mg/L）"
},
{
dataIndex: "h",
key: "h",
title: "人工监测结果（mg/L）"
},
{
dataIndex: "i",
key: "i",
title: "备注"
},
]
const optCol = [['操作', 'action', {
renderButtons: ()=>{
let btns = [];
if(buttonLimit['VIEW']) {
// 查看
btns.push({ name: <Icon type='view' title='查看'/>, onClick(rowData) {
updateState({
viewItem: {
...rowData
}
})
updateViewWindow()
} })
// 编辑
btns.push({ name: <Icon type='file-edit' title='编辑'/>, onClick(rowData) {
updateState({
editItem: {
...rowData
}
})
updateEditWindow();
}})
// 删除
btns.push({ name: <Icon type='delete' title='删除'/>, onClick(rowData) {
dispatch({
type: 'onlineOperation/deleteItems',
payload: ({
ids | ata.id],
onSuccess: (ids) => {
let page = currentPage !=1 && ids.length === (total - (currentPage -1) * pageSize) ? currentPage -1 : currentPage;
dispatch({ type: 'onlineOperation/getList', payload: { selectedRowKeys: [], currentPage: page } });
message.success('删除成功！')
},
onError: (msg) => { message.error(msg) }
})
})
}})
}
return btns
}, width: '150px'
}]]
columns = searchParams.dataFillType === 'produce' ? overViewcolumns : recordColumns
columns = columns.concat(handleColumns(optCol))
// 表格数据项配置
let vtxDatagridProps = {
columns,
dataSource,
indexColumn: true,
startIndex: (currentPage-1) * pageSize + 1,
autoFit: true,
loading,
pagination: {
showSizeChanger: true,
pageSizeOptions: ['10', '20', '30', '40', '50'],
showQuickJumper: true,
current: currentPage,
total,
pageSize,
showTotal: total => `合计 ${total} 条`
},
onChange(pagination, filters, sorter) {
dispatch({ type: 'onlineOperation', payload: {
currentPage: pagination.current,
pageSize: pagination.pageSize
}})
}
}
// 选择表格行
vtxDatagridProps = _.assign(vtxDatagridProps, {
rowSelection: {
type: 'checkbox',
selectedRowKeys,
onChange(selectedRowKeys, selectedRows) {
updateState({ selectedRowKeys })
}
}
})
// 获取表格数据
const getList = () => {
dispatch({ type: 'onlineOperation/updateQueryParams' });
dispatch({ type: 'onlineOperation/getList' });
}
// 查询
const vtxGridParams = {
nameProps: {
value: searchParams.name,
placeholder: '请输入名称',
allowClear: true,
style: {
width: '100%'
},
onChange(value) {
updateState({
searchParams: {
name: value
}
})
},
onPressEnter() {
getList()
},
},
query() {
getList()
},
clear() {
dispatch({ type: 'onlineOperation/initQueryParams'});
dispatch({ type: 'onlineOperation/getList' });
}
}
// mock下拉数据
const waterFactoryList = [ {
"id" : "08ffc34f7b7444249d9a9e3750a34e91",
"value" : "测试水厂0001",
"name" : "测试水厂0001",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "c3e5d28d0da94357ad3625af1e58f342",
"value" : "水厂测试门户1",
"name" : "水厂测试门户1",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "757bc4e466b745b1adbfc39b887d4038",
"value" : "水厂5",
"name" : "水厂5",
"parentId" : "c95fe0e685a54030970e90e17864ace1"
}]
// 模态框名称
const modalTitle = searchParams.dataFillType==='produce' ? '在线概况' : '在线异常运维记录'
// 查看窗口
const updateViewWindow = (status = true) => {
updateState({
viewItem: {
visible: status
}
})
}
const viewItemProps = {
modalProps: {
title: `${modalTitle} > 查看`,
visible: viewItem.visible,
onCancel: () => updateViewWindow(false),
width: 1000
},
contentProps: {
...viewItem,
btnType: 'view'
}
}
// 编辑窗口
const updateEditWindow = (status = true) => {
updateState({
editItem: {
visible: status
}
})
}
const editItemProps = {
modalProps: {
title: `${modalTitle} > 编辑`,
visible: editItem.visible,
onCancel: () => updateEditWindow(false),
width: 1000
},
contentProps: {
...editItem,
btnType: 'edit'
}
}
// 新增窗口
const updateNewWindow = (status = true) => {
updateState({
newItem: {
visible: status
}
})
if(!status) {
dispatch({ type: 'onlineOperation/initNewItem' })
}
}
const newItemProps = {
modalProps: {
title: `${modalTitle} > 新增`,
visible: newItem.visible,
onCancel: () => updateNewWindow(false),
width: 1000
},
contentProps: {
...newItem,
btnType: 'add'
}
}
// 表格外功能-删除
const deleteItems = () => {
Modal.confirm({
content: `确定删除选中的${selectedRowKeys.length}条数据吗？`,
okText: '确定',
cancelText: '取消',
onOk() {
dispatch({
type: 'onlineOperation/deleteItems',
payload: {
ids: selectedRowKeys,
onSuccess: (ids) => {
let page = currentPage != 1 && ids.length === (total - (currentPage - 1) * pageSize) ? currentPage - 1 : currentPage;
dispatch({
type: 'onlineOperation/getList',
payload: {
selectedRowKeys: [],
currentPage: page
}
})
message.success('删除成功');
},
onError: (msg) => { message.error(msg); }
}
})
}
})
}
// 表格外功能-导出
let downloadURL = searchParams.dataFillType==='produce'?'/cloud/gzzhsw/api/cp/basic/pipelineNetPerformance/exportDataExcel':'/cloud/gzzhsw/api/cp/basic/sewageFactory/exportDataExcel'
const exportProps = {
downloadURL,
getExportParams(exportType) {
const param = {
| : [rowD | identifier_name |
index.js | },
{
dataIndex: "h",
key: "h",
title: "人工监测结果（mg/L）"
},
{
dataIndex: "i",
key: "i",
title: "备注"
},
]
const optCol = [['操作', 'action', {
renderButtons: ()=>{
let btns = [];
if(buttonLimit['VIEW']) {
// 查看
btns.push({ name: <Icon type='view' title='查看'/>, onClick(rowData) {
updateState({
viewItem: {
...rowData
}
})
updateViewWindow()
} })
// 编辑
btns.push({ name: <Icon type='file-edit' title='编辑'/>, onClick(rowData) {
updateState({
editItem: {
...rowData
}
})
updateEditWindow();
}})
// 删除
btns.push({ name: <Icon type='delete' title='删除'/>, onClick(rowData) {
dispatch({
type: 'onlineOperation/deleteItems',
payload: ({
ids: [rowData.id],
onSuccess: (ids) => {
let page = currentPage !=1 && ids.length === (total - (currentPage -1) * pageSize) ? currentPage -1 : currentPage;
dispatch({ type: 'onlineOperation/getList', payload: { selectedRowKeys: [], currentPage: page } });
message.success('删除成功！')
},
onError: (msg) => { message.error(msg) }
})
})
}})
}
return btns
}, width: '150px'
}]]
columns = searchParams.dataFillType === 'produce' ? overViewcolumns : recordColumns
columns = columns.concat(handleColumns(optCol))
// 表格数据项配置
let vtxDatagridProps = {
columns,
dataSource,
indexColumn: true,
startIndex: (currentPage-1) * pageSize + 1,
autoFit: true,
loading,
pagination: {
showSizeChanger: true,
pageSizeOptions: ['10', '20', '30', '40', '50'],
showQuickJumper: true,
current: currentPage,
total,
pageSize,
showTotal: total => `合计 ${total} 条`
},
onChange(pagination, filters, sorter) {
dispatch({ type: 'onlineOperation', payload: {
currentPage: pagination.current,
pageSize: pagination.pageSize
}})
}
}
// 选择表格行
vtxDatagridProps = _.assign(vtxDatagridProps, {
rowSelection: {
type: 'checkbox',
selectedRowKeys,
onChange(selectedRowKeys, selectedRows) {
updateState({ selectedRowKeys })
}
}
})
// 获取表格数据
const getList = () => {
dispatch({ type: 'onlineOperation/updateQueryParams' });
dispatch({ type: 'onlineOperation/getList' });
}
// 查询
const vtxGridParams = {
nameProps: {
value: searchParams.name,
placeholder: '请输入名称',
allowClear: true,
style: {
width: '100%'
},
onChange(value) {
updateState({
searchParams: {
name: value
}
})
},
onPressEnter() {
getList()
},
},
query() {
getList()
},
clear() {
dispatch({ type: 'onlineOperation/initQueryParams'});
dispatch({ type: 'onlineOperation/getList' });
}
}
// mock下拉数据
const waterFactoryList = [ {
"id" : "08ffc34f7b7444249d9a9e3750a34e91",
"value" : "测试水厂0001",
"name" : "测试水厂0001",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "c3e5d28d0da94357ad3625af1e58f342",
"value" : "水厂测试门户1",
"name" : "水厂测试门户1",
"parentId" : "e6a34203250b471c969fba90fccc6c87"
}, {
"id" : "757bc4e466b745b1adbfc39b887d4038",
"value" : "水厂5",
"name" : "水厂5",
"parentId" : "c95fe0e685a54030970e90e17864ace1"
}]
// 模态框名称
const modalTitle = searchParams.dataFillType==='produce' ? '在线概况' : '在线异常运维记录'
// 查看窗口
const updateViewWindow = (status = true) => {
updateState({
viewItem: {
visible: status
}
})
}
const viewItemProps = {
modalProps: {
title: `${modalTitle} > 查看`,
visible: viewItem.visible,
onCancel: () => updateViewWindow(false),
width: 1000
},
contentProps: {
...viewItem,
btnType: 'view'
}
}
// 编辑窗口
const updateEditWindow = (status = true) => {
updateState({
editItem: {
visible: status
}
})
}
const editItemProps = {
modalProps: {
title: `${modalTitle} > 编辑`,
visible: editItem.visible,
onCancel: () => updateEditWindow(false),
width: 1000
},
contentProps: {
...editItem,
btnType: 'edit'
}
}
// 新增窗口
const updateNewWindow = (status = true) => {
updateState({
newItem: {
visible: status
}
})
if(!status) {
dispatch({ type: 'onlineOperation/initNewItem' })
}
}
const newItemProps = {
modalProps: {
title: `${modalTitle} > 新增`,
visible: newItem.visible,
onCancel: () => updateNewWindow(false),
width: 1000
},
contentProps: {
...newItem,
btnType: 'add'
}
}
// 表格外功能-删除
const deleteItems = () => {
Modal.confirm({
content: `确定删除选中的${selectedRowKeys.length}条数据吗？`,
okText: '确定',
cancelText: '取消',
onOk() {
dispatch({
type: 'onlineOperation/deleteItems',
payload: {
ids: selectedRowKeys,
onSuccess: (ids) => {
let page = currentPage != 1 && ids.length === (total - (currentPage - 1) * pageSize) ? currentPage - 1 : currentPage;
dispatch({
type: 'onlineOperation/getList',
payload: {
selectedRowKeys: [],
currentPage: page
}
})
message.success('删除成功');
},
onError: (msg) => { message.error(msg); }
}
})
}
})
}
// 表格外功能-导出
let downloadURL = searchParams.dataFillType==='produce'?'/cloud/gzzhsw/api/cp/basic/pipelineNetPerformance/exportDataExcel':'/cloud/gzzhsw/api/cp/basic/sewageFactory/exportDataExcel'
const exportProps = {
downloadURL,
getExportParams(exportType) {
const param = {
tenantId: VtxUtil.getUrlParam('tenantId'),
};
switch (exportType) {
case 'rows':
if (selectedRowKeys.length === 0) {
message.info('需要选择一项进行导出');
return;
}
param.isAll = false;
param.ids = selectedRowKeys.join();
break;
case 'page':
if (dataSource.length === 0) {
message.info('当前页没有数据');
return;
}
const ids = dataSource.map((item, index) => {
return item.id;
});
param.isAll = false;
param.ids = ids.join();
break;
case 'all':
if (total === 0) {
message.info('暂无数据可进行导出');
return;
}
param.isAll = true;
}
return param
}
}
return (
<div className={styles.normal}>
{/* 条件查询 */}
<VtxGrid
titles={['水厂名称', '运维模式']}
gridweight={[1,1]}
confirm={vtxGridParams.query}
clear={vtxGridParams.clear}
>
<Select {...vtxGridParams.nameProps}>
{waterFactoryList.map(item=>{
return (
<Option key={item.id}>{item.name}</Option>
)
})} | </Select>
<Select {...vtxGridParams.nameProps}> | random_line_split | |
data_farmer.rs | ::get_simple_byte_values,
};
use regex::Regex;
pub type TimeOffset = f64;
pub type Value = f64;
#[derive(Debug, Default)]
pub struct TimedData {
pub rx_data: Value,
pub tx_data: Value,
pub cpu_data: Vec<Value>,
pub mem_data: Value,
pub swap_data: Value,
}
/// AppCollection represents the pooled data stored within the main app
/// thread. Basically stores a (occasionally cleaned) record of the data
/// collected, and what is needed to convert into a displayable form.
///
/// If the app is *frozen* - that is, we do not want to *display* any changing
/// data, keep updating this, don't convert to canvas displayable data!
///
/// Note that with this method, the *app* thread is responsible for cleaning -
/// not the data collector.
#[derive(Debug)]
pub struct DataCollection {
pub current_instant: Instant,
pub frozen_instant: Option<Instant>,
pub timed_data_vec: Vec<(Instant, TimedData)>,
pub network_harvest: network::NetworkHarvest,
pub memory_harvest: mem::MemHarvest,
pub swap_harvest: mem::MemHarvest,
pub cpu_harvest: cpu::CpuHarvest,
pub process_harvest: Vec<processes::ProcessHarvest>,
pub disk_harvest: Vec<disks::DiskHarvest>,
pub io_harvest: disks::IOHarvest,
pub io_labels_and_prev: Vec<((u64, u64), (u64, u64))>,
pub io_labels: Vec<(String, String)>,
pub temp_harvest: Vec<temperature::TempHarvest>,
pub battery_harvest: Vec<battery_harvester::BatteryHarvest>,
}
impl Default for DataCollection {
fn default() -> Self {
DataCollection {
current_instant: Instant::now(),
frozen_instant: None,
timed_data_vec: Vec::default(),
network_harvest: network::NetworkHarvest::default(),
memory_harvest: mem::MemHarvest::default(),
swap_harvest: mem::MemHarvest::default(),
cpu_harvest: cpu::CpuHarvest::default(),
process_harvest: Vec::default(),
disk_harvest: Vec::default(),
io_harvest: disks::IOHarvest::default(),
io_labels_and_prev: Vec::default(),
io_labels: Vec::default(),
temp_harvest: Vec::default(),
battery_harvest: Vec::default(),
}
}
}
impl DataCollection {
pub fn reset(&mut self) {
self.timed_data_vec = Vec::default();
self.network_harvest = network::NetworkHarvest::default();
self.memory_harvest = mem::MemHarvest::default();
self.swap_harvest = mem::MemHarvest::default();
self.cpu_harvest = cpu::CpuHarvest::default();
self.process_harvest = Vec::default();
self.disk_harvest = Vec::default();
self.io_harvest = disks::IOHarvest::default();
self.io_labels_and_prev = Vec::default();
self.temp_harvest = Vec::default();
self.battery_harvest = Vec::default();
}
pub fn set_frozen_time(&mut self) {
self.frozen_instant = Some(self.current_instant);
}
pub fn clean_data(&mut self, max_time_millis: u64) {
trace!("Cleaning data.");
let current_time = Instant::now();
let mut remove_index = 0;
for entry in &self.timed_data_vec {
if current_time.duration_since(entry.0).as_millis() >= max_time_millis as u128 {
remove_index += 1;
} else {
break;
}
}
self.timed_data_vec.drain(0..remove_index);
}
pub fn eat_data(&mut self, harvested_data: &Data) {
trace!("Eating data now...");
let harvested_time = harvested_data.last_collection_time;
trace!("Harvested time: {:?}", harvested_time);
trace!("New current instant: {:?}", self.current_instant);
let mut new_entry = TimedData::default();
// Network
if let Some(network) = &harvested_data.network {
self.eat_network(network, &mut new_entry);
}
// Memory and Swap
if let Some(memory) = &harvested_data.memory {
if let Some(swap) = &harvested_data.swap {
self.eat_memory_and_swap(memory, swap, &mut new_entry);
}
}
// CPU
if let Some(cpu) = &harvested_data.cpu {
self.eat_cpu(cpu, &mut new_entry);
}
// Temp
if let Some(temperature_sensors) = &harvested_data.temperature_sensors {
self.eat_temp(temperature_sensors);
}
// Disks
if let Some(disks) = &harvested_data.disks {
if let Some(io) = &harvested_data.io {
self.eat_disks(disks, io, harvested_time);
}
}
// Processes
if let Some(list_of_processes) = &harvested_data.list_of_processes {
self.eat_proc(list_of_processes);
}
// Battery
if let Some(list_of_batteries) = &harvested_data.list_of_batteries {
self.eat_battery(list_of_batteries);
}
// And we're done eating. Update time and push the new entry!
self.current_instant = harvested_time;
self.timed_data_vec.push((harvested_time, new_entry));
}
fn eat_memory_and_swap(
&mut self, memory: &mem::MemHarvest, swap: &mem::MemHarvest, new_entry: &mut TimedData,
) {
trace!("Eating mem and swap.");
// Memory
let mem_percent = match memory.mem_total_in_mb {
0 => 0f64,
total => (memory.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.mem_data = mem_percent;
// Swap
if swap.mem_total_in_mb > 0 {
let swap_percent = match swap.mem_total_in_mb {
0 => 0f64,
total => (swap.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.swap_data = swap_percent;
}
// In addition copy over latest data for easy reference
self.memory_harvest = memory.clone();
self.swap_harvest = swap.clone();
}
fn eat_network(&mut self, network: &network::NetworkHarvest, new_entry: &mut TimedData) {
trace!("Eating network.");
// FIXME [NETWORKING; CONFIG]: The ability to config this?
// FIXME [NETWORKING]: Support bits, support switching between decimal and binary units (move the log part to conversion and switch on the fly)
// RX
new_entry.rx_data = if network.rx > 0 {
(network.rx as f64).log2()
} else {
0.0
};
// TX
new_entry.tx_data = if network.tx > 0 | else {
0.0
};
// In addition copy over latest data for easy reference
self.network_harvest = network.clone();
}
fn eat_cpu(&mut self, cpu: &[cpu::CpuData], new_entry: &mut TimedData) {
trace!("Eating CPU.");
// Note this only pre-calculates the data points - the names will be
// within the local copy of cpu_harvest. Since it's all sequential
// it probably doesn't matter anyways.
cpu.iter()
.for_each(|cpu| new_entry.cpu_data.push(cpu.cpu_usage));
self.cpu_harvest = cpu.to_vec();
}
fn eat_temp(&mut self, temperature_sensors: &[temperature::TempHarvest]) {
trace!("Eating temps.");
// TODO: [PO] To implement
self.temp_harvest = temperature_sensors.to_vec();
}
fn eat_disks(
&mut self, disks: &[disks::DiskHarvest], io: &disks::IOHarvest, harvested_time: Instant,
) {
trace!("Eating disks.");
// TODO: [PO] To implement
let time_since_last_harvest = harvested_time
.duration_since(self.current_instant)
.as_secs_f64();
for (itx, device) in disks.iter().enumerate() {
if let Some(trim) = device.name.split('/').last() {
let io_device = if cfg!(target_os = "macos") {
// Must trim one level further!
lazy_static! {
static ref DISK_REGEX: Regex = Regex::new(r"disk\d+").unwrap();
}
if let Some(disk_trim) = DISK_REGEX.find(trim) {
io.get(disk_trim.as_str())
} else | {
(network.tx as f64).log2()
} | conditional_block |
data_farmer.rs | ::get_simple_byte_values,
};
use regex::Regex;
pub type TimeOffset = f64;
pub type Value = f64;
#[derive(Debug, Default)]
pub struct TimedData {
pub rx_data: Value,
pub tx_data: Value,
pub cpu_data: Vec<Value>,
pub mem_data: Value,
pub swap_data: Value,
}
/// AppCollection represents the pooled data stored within the main app
/// thread. Basically stores a (occasionally cleaned) record of the data
/// collected, and what is needed to convert into a displayable form.
///
/// If the app is *frozen* - that is, we do not want to *display* any changing
/// data, keep updating this, don't convert to canvas displayable data!
///
/// Note that with this method, the *app* thread is responsible for cleaning -
/// not the data collector.
#[derive(Debug)]
pub struct DataCollection {
pub current_instant: Instant,
pub frozen_instant: Option<Instant>,
pub timed_data_vec: Vec<(Instant, TimedData)>,
pub network_harvest: network::NetworkHarvest,
pub memory_harvest: mem::MemHarvest,
pub swap_harvest: mem::MemHarvest,
pub cpu_harvest: cpu::CpuHarvest,
pub process_harvest: Vec<processes::ProcessHarvest>,
pub disk_harvest: Vec<disks::DiskHarvest>,
pub io_harvest: disks::IOHarvest,
pub io_labels_and_prev: Vec<((u64, u64), (u64, u64))>,
pub io_labels: Vec<(String, String)>,
pub temp_harvest: Vec<temperature::TempHarvest>,
pub battery_harvest: Vec<battery_harvester::BatteryHarvest>, | fn default() -> Self {
DataCollection {
current_instant: Instant::now(),
frozen_instant: None,
timed_data_vec: Vec::default(),
network_harvest: network::NetworkHarvest::default(),
memory_harvest: mem::MemHarvest::default(),
swap_harvest: mem::MemHarvest::default(),
cpu_harvest: cpu::CpuHarvest::default(),
process_harvest: Vec::default(),
disk_harvest: Vec::default(),
io_harvest: disks::IOHarvest::default(),
io_labels_and_prev: Vec::default(),
io_labels: Vec::default(),
temp_harvest: Vec::default(),
battery_harvest: Vec::default(),
}
}
}
impl DataCollection {
pub fn reset(&mut self) {
self.timed_data_vec = Vec::default();
self.network_harvest = network::NetworkHarvest::default();
self.memory_harvest = mem::MemHarvest::default();
self.swap_harvest = mem::MemHarvest::default();
self.cpu_harvest = cpu::CpuHarvest::default();
self.process_harvest = Vec::default();
self.disk_harvest = Vec::default();
self.io_harvest = disks::IOHarvest::default();
self.io_labels_and_prev = Vec::default();
self.temp_harvest = Vec::default();
self.battery_harvest = Vec::default();
}
pub fn set_frozen_time(&mut self) {
self.frozen_instant = Some(self.current_instant);
}
pub fn clean_data(&mut self, max_time_millis: u64) {
trace!("Cleaning data.");
let current_time = Instant::now();
let mut remove_index = 0;
for entry in &self.timed_data_vec {
if current_time.duration_since(entry.0).as_millis() >= max_time_millis as u128 {
remove_index += 1;
} else {
break;
}
}
self.timed_data_vec.drain(0..remove_index);
}
pub fn eat_data(&mut self, harvested_data: &Data) {
trace!("Eating data now...");
let harvested_time = harvested_data.last_collection_time;
trace!("Harvested time: {:?}", harvested_time);
trace!("New current instant: {:?}", self.current_instant);
let mut new_entry = TimedData::default();
// Network
if let Some(network) = &harvested_data.network {
self.eat_network(network, &mut new_entry);
}
// Memory and Swap
if let Some(memory) = &harvested_data.memory {
if let Some(swap) = &harvested_data.swap {
self.eat_memory_and_swap(memory, swap, &mut new_entry);
}
}
// CPU
if let Some(cpu) = &harvested_data.cpu {
self.eat_cpu(cpu, &mut new_entry);
}
// Temp
if let Some(temperature_sensors) = &harvested_data.temperature_sensors {
self.eat_temp(temperature_sensors);
}
// Disks
if let Some(disks) = &harvested_data.disks {
if let Some(io) = &harvested_data.io {
self.eat_disks(disks, io, harvested_time);
}
}
// Processes
if let Some(list_of_processes) = &harvested_data.list_of_processes {
self.eat_proc(list_of_processes);
}
// Battery
if let Some(list_of_batteries) = &harvested_data.list_of_batteries {
self.eat_battery(list_of_batteries);
}
// And we're done eating. Update time and push the new entry!
self.current_instant = harvested_time;
self.timed_data_vec.push((harvested_time, new_entry));
}
fn eat_memory_and_swap(
&mut self, memory: &mem::MemHarvest, swap: &mem::MemHarvest, new_entry: &mut TimedData,
) {
trace!("Eating mem and swap.");
// Memory
let mem_percent = match memory.mem_total_in_mb {
0 => 0f64,
total => (memory.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.mem_data = mem_percent;
// Swap
if swap.mem_total_in_mb > 0 {
let swap_percent = match swap.mem_total_in_mb {
0 => 0f64,
total => (swap.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.swap_data = swap_percent;
}
// In addition copy over latest data for easy reference
self.memory_harvest = memory.clone();
self.swap_harvest = swap.clone();
}
fn eat_network(&mut self, network: &network::NetworkHarvest, new_entry: &mut TimedData) {
trace!("Eating network.");
// FIXME [NETWORKING; CONFIG]: The ability to config this?
// FIXME [NETWORKING]: Support bits, support switching between decimal and binary units (move the log part to conversion and switch on the fly)
// RX
new_entry.rx_data = if network.rx > 0 {
(network.rx as f64).log2()
} else {
0.0
};
// TX
new_entry.tx_data = if network.tx > 0 {
(network.tx as f64).log2()
} else {
0.0
};
// In addition copy over latest data for easy reference
self.network_harvest = network.clone();
}
fn eat_cpu(&mut self, cpu: &[cpu::CpuData], new_entry: &mut TimedData) {
trace!("Eating CPU.");
// Note this only pre-calculates the data points - the names will be
// within the local copy of cpu_harvest. Since it's all sequential
// it probably doesn't matter anyways.
cpu.iter()
.for_each(|cpu| new_entry.cpu_data.push(cpu.cpu_usage));
self.cpu_harvest = cpu.to_vec();
}
fn eat_temp(&mut self, temperature_sensors: &[temperature::TempHarvest]) {
trace!("Eating temps.");
// TODO: [PO] To implement
self.temp_harvest = temperature_sensors.to_vec();
}
fn eat_disks(
&mut self, disks: &[disks::DiskHarvest], io: &disks::IOHarvest, harvested_time: Instant,
) {
trace!("Eating disks.");
// TODO: [PO] To implement
let time_since_last_harvest = harvested_time
.duration_since(self.current_instant)
.as_secs_f64();
for (itx, device) in disks.iter().enumerate() {
if let Some(trim) = device.name.split('/').last() {
let io_device = if cfg!(target_os = "macos") {
// Must trim one level further!
lazy_static! {
static ref DISK_REGEX: Regex = Regex::new(r"disk\d+").unwrap();
}
if let Some(disk_trim) = DISK_REGEX.find(trim) {
io.get(disk_trim.as_str())
} else {
| }
impl Default for DataCollection { | random_line_split |
data_farmer.rs | ::get_simple_byte_values,
};
use regex::Regex;
pub type TimeOffset = f64;
pub type Value = f64;
#[derive(Debug, Default)]
pub struct | {
pub rx_data: Value,
pub tx_data: Value,
pub cpu_data: Vec<Value>,
pub mem_data: Value,
pub swap_data: Value,
}
/// AppCollection represents the pooled data stored within the main app
/// thread. Basically stores a (occasionally cleaned) record of the data
/// collected, and what is needed to convert into a displayable form.
///
/// If the app is *frozen* - that is, we do not want to *display* any changing
/// data, keep updating this, don't convert to canvas displayable data!
///
/// Note that with this method, the *app* thread is responsible for cleaning -
/// not the data collector.
#[derive(Debug)]
pub struct DataCollection {
pub current_instant: Instant,
pub frozen_instant: Option<Instant>,
pub timed_data_vec: Vec<(Instant, TimedData)>,
pub network_harvest: network::NetworkHarvest,
pub memory_harvest: mem::MemHarvest,
pub swap_harvest: mem::MemHarvest,
pub cpu_harvest: cpu::CpuHarvest,
pub process_harvest: Vec<processes::ProcessHarvest>,
pub disk_harvest: Vec<disks::DiskHarvest>,
pub io_harvest: disks::IOHarvest,
pub io_labels_and_prev: Vec<((u64, u64), (u64, u64))>,
pub io_labels: Vec<(String, String)>,
pub temp_harvest: Vec<temperature::TempHarvest>,
pub battery_harvest: Vec<battery_harvester::BatteryHarvest>,
}
impl Default for DataCollection {
fn default() -> Self {
DataCollection {
current_instant: Instant::now(),
frozen_instant: None,
timed_data_vec: Vec::default(),
network_harvest: network::NetworkHarvest::default(),
memory_harvest: mem::MemHarvest::default(),
swap_harvest: mem::MemHarvest::default(),
cpu_harvest: cpu::CpuHarvest::default(),
process_harvest: Vec::default(),
disk_harvest: Vec::default(),
io_harvest: disks::IOHarvest::default(),
io_labels_and_prev: Vec::default(),
io_labels: Vec::default(),
temp_harvest: Vec::default(),
battery_harvest: Vec::default(),
}
}
}
impl DataCollection {
pub fn reset(&mut self) {
self.timed_data_vec = Vec::default();
self.network_harvest = network::NetworkHarvest::default();
self.memory_harvest = mem::MemHarvest::default();
self.swap_harvest = mem::MemHarvest::default();
self.cpu_harvest = cpu::CpuHarvest::default();
self.process_harvest = Vec::default();
self.disk_harvest = Vec::default();
self.io_harvest = disks::IOHarvest::default();
self.io_labels_and_prev = Vec::default();
self.temp_harvest = Vec::default();
self.battery_harvest = Vec::default();
}
pub fn set_frozen_time(&mut self) {
self.frozen_instant = Some(self.current_instant);
}
pub fn clean_data(&mut self, max_time_millis: u64) {
trace!("Cleaning data.");
let current_time = Instant::now();
let mut remove_index = 0;
for entry in &self.timed_data_vec {
if current_time.duration_since(entry.0).as_millis() >= max_time_millis as u128 {
remove_index += 1;
} else {
break;
}
}
self.timed_data_vec.drain(0..remove_index);
}
pub fn eat_data(&mut self, harvested_data: &Data) {
trace!("Eating data now...");
let harvested_time = harvested_data.last_collection_time;
trace!("Harvested time: {:?}", harvested_time);
trace!("New current instant: {:?}", self.current_instant);
let mut new_entry = TimedData::default();
// Network
if let Some(network) = &harvested_data.network {
self.eat_network(network, &mut new_entry);
}
// Memory and Swap
if let Some(memory) = &harvested_data.memory {
if let Some(swap) = &harvested_data.swap {
self.eat_memory_and_swap(memory, swap, &mut new_entry);
}
}
// CPU
if let Some(cpu) = &harvested_data.cpu {
self.eat_cpu(cpu, &mut new_entry);
}
// Temp
if let Some(temperature_sensors) = &harvested_data.temperature_sensors {
self.eat_temp(temperature_sensors);
}
// Disks
if let Some(disks) = &harvested_data.disks {
if let Some(io) = &harvested_data.io {
self.eat_disks(disks, io, harvested_time);
}
}
// Processes
if let Some(list_of_processes) = &harvested_data.list_of_processes {
self.eat_proc(list_of_processes);
}
// Battery
if let Some(list_of_batteries) = &harvested_data.list_of_batteries {
self.eat_battery(list_of_batteries);
}
// And we're done eating. Update time and push the new entry!
self.current_instant = harvested_time;
self.timed_data_vec.push((harvested_time, new_entry));
}
fn eat_memory_and_swap(
&mut self, memory: &mem::MemHarvest, swap: &mem::MemHarvest, new_entry: &mut TimedData,
) {
trace!("Eating mem and swap.");
// Memory
let mem_percent = match memory.mem_total_in_mb {
0 => 0f64,
total => (memory.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.mem_data = mem_percent;
// Swap
if swap.mem_total_in_mb > 0 {
let swap_percent = match swap.mem_total_in_mb {
0 => 0f64,
total => (swap.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.swap_data = swap_percent;
}
// In addition copy over latest data for easy reference
self.memory_harvest = memory.clone();
self.swap_harvest = swap.clone();
}
fn eat_network(&mut self, network: &network::NetworkHarvest, new_entry: &mut TimedData) {
trace!("Eating network.");
// FIXME [NETWORKING; CONFIG]: The ability to config this?
// FIXME [NETWORKING]: Support bits, support switching between decimal and binary units (move the log part to conversion and switch on the fly)
// RX
new_entry.rx_data = if network.rx > 0 {
(network.rx as f64).log2()
} else {
0.0
};
// TX
new_entry.tx_data = if network.tx > 0 {
(network.tx as f64).log2()
} else {
0.0
};
// In addition copy over latest data for easy reference
self.network_harvest = network.clone();
}
fn eat_cpu(&mut self, cpu: &[cpu::CpuData], new_entry: &mut TimedData) {
trace!("Eating CPU.");
// Note this only pre-calculates the data points - the names will be
// within the local copy of cpu_harvest. Since it's all sequential
// it probably doesn't matter anyways.
cpu.iter()
.for_each(|cpu| new_entry.cpu_data.push(cpu.cpu_usage));
self.cpu_harvest = cpu.to_vec();
}
fn eat_temp(&mut self, temperature_sensors: &[temperature::TempHarvest]) {
trace!("Eating temps.");
// TODO: [PO] To implement
self.temp_harvest = temperature_sensors.to_vec();
}
fn eat_disks(
&mut self, disks: &[disks::DiskHarvest], io: &disks::IOHarvest, harvested_time: Instant,
) {
trace!("Eating disks.");
// TODO: [PO] To implement
let time_since_last_harvest = harvested_time
.duration_since(self.current_instant)
.as_secs_f64();
for (itx, device) in disks.iter().enumerate() {
if let Some(trim) = device.name.split('/').last() {
let io_device = if cfg!(target_os = "macos") {
// Must trim one level further!
lazy_static! {
static ref DISK_REGEX: Regex = Regex::new(r"disk\d+").unwrap();
}
if let Some(disk_trim) = DISK_REGEX.find(trim) {
io.get(disk_trim.as_str())
} else | TimedData | identifier_name |
data_farmer.rs | get_simple_byte_values,
};
use regex::Regex;
pub type TimeOffset = f64;
pub type Value = f64;
#[derive(Debug, Default)]
pub struct TimedData {
pub rx_data: Value,
pub tx_data: Value,
pub cpu_data: Vec<Value>,
pub mem_data: Value,
pub swap_data: Value,
}
/// AppCollection represents the pooled data stored within the main app
/// thread. Basically stores a (occasionally cleaned) record of the data
/// collected, and what is needed to convert into a displayable form.
///
/// If the app is *frozen* - that is, we do not want to *display* any changing
/// data, keep updating this, don't convert to canvas displayable data!
///
/// Note that with this method, the *app* thread is responsible for cleaning -
/// not the data collector.
#[derive(Debug)]
pub struct DataCollection {
pub current_instant: Instant,
pub frozen_instant: Option<Instant>,
pub timed_data_vec: Vec<(Instant, TimedData)>,
pub network_harvest: network::NetworkHarvest,
pub memory_harvest: mem::MemHarvest,
pub swap_harvest: mem::MemHarvest,
pub cpu_harvest: cpu::CpuHarvest,
pub process_harvest: Vec<processes::ProcessHarvest>,
pub disk_harvest: Vec<disks::DiskHarvest>,
pub io_harvest: disks::IOHarvest,
pub io_labels_and_prev: Vec<((u64, u64), (u64, u64))>,
pub io_labels: Vec<(String, String)>,
pub temp_harvest: Vec<temperature::TempHarvest>,
pub battery_harvest: Vec<battery_harvester::BatteryHarvest>,
}
impl Default for DataCollection {
fn default() -> Self {
DataCollection {
current_instant: Instant::now(),
frozen_instant: None,
timed_data_vec: Vec::default(),
network_harvest: network::NetworkHarvest::default(),
memory_harvest: mem::MemHarvest::default(),
swap_harvest: mem::MemHarvest::default(),
cpu_harvest: cpu::CpuHarvest::default(),
process_harvest: Vec::default(),
disk_harvest: Vec::default(),
io_harvest: disks::IOHarvest::default(),
io_labels_and_prev: Vec::default(),
io_labels: Vec::default(),
temp_harvest: Vec::default(),
battery_harvest: Vec::default(),
}
}
}
impl DataCollection {
pub fn reset(&mut self) |
pub fn set_frozen_time(&mut self) {
self.frozen_instant = Some(self.current_instant);
}
pub fn clean_data(&mut self, max_time_millis: u64) {
trace!("Cleaning data.");
let current_time = Instant::now();
let mut remove_index = 0;
for entry in &self.timed_data_vec {
if current_time.duration_since(entry.0).as_millis() >= max_time_millis as u128 {
remove_index += 1;
} else {
break;
}
}
self.timed_data_vec.drain(0..remove_index);
}
pub fn eat_data(&mut self, harvested_data: &Data) {
trace!("Eating data now...");
let harvested_time = harvested_data.last_collection_time;
trace!("Harvested time: {:?}", harvested_time);
trace!("New current instant: {:?}", self.current_instant);
let mut new_entry = TimedData::default();
// Network
if let Some(network) = &harvested_data.network {
self.eat_network(network, &mut new_entry);
}
// Memory and Swap
if let Some(memory) = &harvested_data.memory {
if let Some(swap) = &harvested_data.swap {
self.eat_memory_and_swap(memory, swap, &mut new_entry);
}
}
// CPU
if let Some(cpu) = &harvested_data.cpu {
self.eat_cpu(cpu, &mut new_entry);
}
// Temp
if let Some(temperature_sensors) = &harvested_data.temperature_sensors {
self.eat_temp(temperature_sensors);
}
// Disks
if let Some(disks) = &harvested_data.disks {
if let Some(io) = &harvested_data.io {
self.eat_disks(disks, io, harvested_time);
}
}
// Processes
if let Some(list_of_processes) = &harvested_data.list_of_processes {
self.eat_proc(list_of_processes);
}
// Battery
if let Some(list_of_batteries) = &harvested_data.list_of_batteries {
self.eat_battery(list_of_batteries);
}
// And we're done eating. Update time and push the new entry!
self.current_instant = harvested_time;
self.timed_data_vec.push((harvested_time, new_entry));
}
fn eat_memory_and_swap(
&mut self, memory: &mem::MemHarvest, swap: &mem::MemHarvest, new_entry: &mut TimedData,
) {
trace!("Eating mem and swap.");
// Memory
let mem_percent = match memory.mem_total_in_mb {
0 => 0f64,
total => (memory.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.mem_data = mem_percent;
// Swap
if swap.mem_total_in_mb > 0 {
let swap_percent = match swap.mem_total_in_mb {
0 => 0f64,
total => (swap.mem_used_in_mb as f64) / (total as f64) * 100.0,
};
new_entry.swap_data = swap_percent;
}
// In addition copy over latest data for easy reference
self.memory_harvest = memory.clone();
self.swap_harvest = swap.clone();
}
fn eat_network(&mut self, network: &network::NetworkHarvest, new_entry: &mut TimedData) {
trace!("Eating network.");
// FIXME [NETWORKING; CONFIG]: The ability to config this?
// FIXME [NETWORKING]: Support bits, support switching between decimal and binary units (move the log part to conversion and switch on the fly)
// RX
new_entry.rx_data = if network.rx > 0 {
(network.rx as f64).log2()
} else {
0.0
};
// TX
new_entry.tx_data = if network.tx > 0 {
(network.tx as f64).log2()
} else {
0.0
};
// In addition copy over latest data for easy reference
self.network_harvest = network.clone();
}
fn eat_cpu(&mut self, cpu: &[cpu::CpuData], new_entry: &mut TimedData) {
trace!("Eating CPU.");
// Note this only pre-calculates the data points - the names will be
// within the local copy of cpu_harvest. Since it's all sequential
// it probably doesn't matter anyways.
cpu.iter()
.for_each(|cpu| new_entry.cpu_data.push(cpu.cpu_usage));
self.cpu_harvest = cpu.to_vec();
}
fn eat_temp(&mut self, temperature_sensors: &[temperature::TempHarvest]) {
trace!("Eating temps.");
// TODO: [PO] To implement
self.temp_harvest = temperature_sensors.to_vec();
}
fn eat_disks(
&mut self, disks: &[disks::DiskHarvest], io: &disks::IOHarvest, harvested_time: Instant,
) {
trace!("Eating disks.");
// TODO: [PO] To implement
let time_since_last_harvest = harvested_time
.duration_since(self.current_instant)
.as_secs_f64();
for (itx, device) in disks.iter().enumerate() {
if let Some(trim) = device.name.split('/').last() {
let io_device = if cfg!(target_os = "macos") {
// Must trim one level further!
lazy_static! {
static ref DISK_REGEX: Regex = Regex::new(r"disk\d+").unwrap();
}
if let Some(disk_trim) = DISK_REGEX.find(trim) {
io.get(disk_trim.as_str())
} else | {
self.timed_data_vec = Vec::default();
self.network_harvest = network::NetworkHarvest::default();
self.memory_harvest = mem::MemHarvest::default();
self.swap_harvest = mem::MemHarvest::default();
self.cpu_harvest = cpu::CpuHarvest::default();
self.process_harvest = Vec::default();
self.disk_harvest = Vec::default();
self.io_harvest = disks::IOHarvest::default();
self.io_labels_and_prev = Vec::default();
self.temp_harvest = Vec::default();
self.battery_harvest = Vec::default();
} | identifier_body |
lib.rs | <X>(a: X, b: X) -> X where
X: PrimInt + Integer + Signed,
{
let GcdData { gcd, .. } = extended_gcd__inline(a, b);
gcd
}
/// Compute a least common multiple.
pub fn lcm<X>(a: X, b: X) -> X where
X: PrimInt + Integer + Signed,
{
let GcdData { lcm, .. } = extended_gcd__inline(a, b);
lcm
}
/// Compute a modular multiplicative inverse, if it exists.
///
/// This implementation uses the extended Gcd algorithm,
pub fn inverse_mod<X>(a: X, m: X) -> Option<X> where
X: PrimInt + Integer + Signed,
{
let GcdData { gcd: g, coeffs: (inv, _), .. } = extended_gcd__inline(a, m);
if g == X::one() { Some(inv.mod_floor(&m)) } else { None }
}
/// Merge many equations of the form `x = ai (mod ni)` into one.
///
/// The moduli don't need to be coprime;
/// ``None`` is returned if the equations are inconsistent.
///
/// `chinese_remainder(vec![])` is defined to be `Some((0,1))`.
pub fn chinese_remainder<X,I>(congruences: I) -> Option<(X,X)> where
X: PrimInt + Integer + Signed,
I: IntoIterator<Item=(X,X)>,
{
// something something "monadic" something "fold"
congruences.into_iter().fold(Some((X::zero(),X::one())),
|opt, new_pair| opt.and_then(|acc_pair|
chinese_remainder2(acc_pair, new_pair)
)
)
}
/// Merge two equations of the form ``x = ai (mod ni)`` into one.
///
/// The moduli don't need to be coprime;
/// `None` is returned if the equations are inconsistent.
///
/// Panics if a modulus is negative or zero.
pub fn chinese_remainder2<X>((a1,n1):(X,X), (a2,n2):(X,X)) -> Option<(X,X)> where
X: PrimInt + Integer + Signed,
{
// I'm too lazy right now to consider whether there is a
// reasonable behavior for negative moduli
assert!(n1.is_positive());
assert!(n2.is_positive());
let GcdData {
gcd: g,
lcm: n3,
coeffs: (c1,c2),
..
} = extended_gcd__inline(n1, n2);
let (a1div, a1rem) = a1.div_rem(&g);
let (a2div, a2rem) = a2.div_rem(&g);
if a1rem != a2rem { None }
else {
let a3 = (a2div*c1*n1 + a1div*c2*n2 + a1rem).mod_floor(&n3);
Some((a3, n3))
}
}
// used for conversions of literals (which will clearly never fail)
fn lit<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
// slightly more verbose for use outside mathematical expressions
fn convert<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
/// An argument to tame function count explosion for functions
/// which can optionally deal with permutation symmetry.
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum OrderType {
/// Order matters; consider all distinct permutations.
Ordered,
/// Order does not matter; only consider distinct combinations.
Unordered,
}
/// Used as a half-baked alternative to writing a generic interface
/// over RangeTo and RangeToInclusive
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum UpperBound<X> { Upto(X), Under(X), }
impl<X> UpperBound<X> where X: Integer + One,
{
// FIXME: I think it is hard to read code that uses this.
/// a generic form of (min..x).next_back() or (min...x).next_back()
fn inclusive_limit_from(self, min: X) -> Option<X> {
match self {
Under(upper) => if min >= upper { None } else { Some(upper - One::one()) },
Upto(max) => if min > max { None } else { Some(max) },
}
}
}
#[test]
fn test_inclusive_limit_from() {
assert_eq!(Upto(4).inclusive_limit_from(3), Some(4));
assert_eq!(Upto(3).inclusive_limit_from(3), Some(3));
assert_eq!(Upto(2).inclusive_limit_from(3), None);
assert_eq!(Upto(1).inclusive_limit_from(3), None);
assert_eq!(Under(5).inclusive_limit_from(3), Some(4));
assert_eq!(Under(4).inclusive_limit_from(3), Some(3));
assert_eq!(Under(3).inclusive_limit_from(3), None);
assert_eq!(Under(2).inclusive_limit_from(3), None);
// no underflow please kthx
assert_eq!(Under(0).inclusive_limit_from(0), None);
}
use UpperBound::*;
use OrderType::*;
// NOTE: Further possible generalizations:
// * Take a Range instead of UpperBound so that zero can optionally be included
// (however it would also require solving how to produce correct results
// for all other lower bounds)
// * count_coprime_tuplets(max, n)
/// Counts coprime pairs of integers `>= 1`
///
/// # Notes
///
/// `(0,1)` and `(1,0)` are not counted.
/// `(1,1)` (the only symmetric pair) is counted once.
///
/// # Reference
///
/// http://laurentmazare.github.io/2014/09/14/counting-coprime-pairs/
pub fn count_coprime_pairs<X>(bound: UpperBound<X>, order_type: OrderType) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
let max = {
if let Some(max) = bound.inclusive_limit_from(lit(1)) { max }
else { return lit(0); } // catches Under(0), Upto(0), Under(1)
};
let ordered = count_ordered_coprime_pairs(max);
match order_type {
Ordered => ordered,
// Every combination was counted twice except for (1,1);
// Add 1 so that they are ALL double counted, then halve it.
// (this also fortituously produces 0 for max == 0)
Unordered => (ordered + lit(1)) / lit(2),
}
}
fn count_ordered_coprime_pairs<X>(max: X) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
// Function can be described with this recursion relation:
//
// c(n) = n**2 - sum_{k=2}^n c(n // k)
//
// where '//' is floored division.
//
// Many values of k share the same value of (n // k),
// thereby permitting a coarse-graining approach.
// unique values of m (=floor(n/k)) for small k
let fine_deps = |n|
(2..).map(convert::<X>)
.map(move |k| n/k).take_while(move |&m| m*m > n);
// values of m (=floor(n/k)) shared by many large k.
let coarse_deps = |n|
(1..).map(convert::<X>)
.take_while(move |&m| m*m <= n)
// don't produce m == 1 for n == 1
.skip_while(move |_| n == lit(1));
let coarse_multiplicity = |n,m| n/m - n/(m + lit(1));
// Get all values that need to be computed at some point.
//
// Interestingly, these are just 'max' and its direct dependencies
// (which are of the form 'max // k'). The reason the subproblems
// never introduce new dependencies is because integer division
// apparently satisfies the following property for x non-negative
// and a,b positive:
//
// (x // a) // b == (x // b) // a == x // (a*b)
//
// (NOTE: euclidean division wins *yet again*; it is the only sign convention
// under which this also works for negative 'x', 'a', and 'b'!)
let order = {
let mut vec = vec![max];
vec.extend(fine_deps(max));
vec.extend(coarse_deps(max));
vec.sort();
vec
};
let mut memo = HashMap::new();
let compute = |n, memo: &HashMap<X,X>| {
let acc = n*n;
let acc = coarse_deps(n)
.map(|m| memo[&m.into()] * coarse_multiplicity(n,m))
.fold(acc, |a,b| a-b);
let acc = fine_deps(n)
.map(|m| memo[&m.into | gcd | identifier_name | |
lib.rs | : X) -> X where
X: PrimInt + Integer + Signed,
{
let GcdData { gcd, .. } = extended_gcd__inline(a, b);
gcd
}
/// Compute a least common multiple.
pub fn lcm<X>(a: X, b: X) -> X where
X: PrimInt + Integer + Signed,
{
let GcdData { lcm, .. } = extended_gcd__inline(a, b);
lcm
}
/// Compute a modular multiplicative inverse, if it exists.
///
/// This implementation uses the extended Gcd algorithm,
pub fn inverse_mod<X>(a: X, m: X) -> Option<X> where
X: PrimInt + Integer + Signed,
{
let GcdData { gcd: g, coeffs: (inv, _), .. } = extended_gcd__inline(a, m);
if g == X::one() { Some(inv.mod_floor(&m)) } else { None }
}
/// Merge many equations of the form `x = ai (mod ni)` into one.
///
/// The moduli don't need to be coprime;
/// ``None`` is returned if the equations are inconsistent.
///
/// `chinese_remainder(vec![])` is defined to be `Some((0,1))`.
pub fn chinese_remainder<X,I>(congruences: I) -> Option<(X,X)> where
X: PrimInt + Integer + Signed,
I: IntoIterator<Item=(X,X)>,
{
// something something "monadic" something "fold"
congruences.into_iter().fold(Some((X::zero(),X::one())),
|opt, new_pair| opt.and_then(|acc_pair|
chinese_remainder2(acc_pair, new_pair)
)
)
}
/// Merge two equations of the form ``x = ai (mod ni)`` into one.
///
/// The moduli don't need to be coprime;
/// `None` is returned if the equations are inconsistent.
///
/// Panics if a modulus is negative or zero.
pub fn chinese_remainder2<X>((a1,n1):(X,X), (a2,n2):(X,X)) -> Option<(X,X)> where
X: PrimInt + Integer + Signed,
{
// I'm too lazy right now to consider whether there is a
// reasonable behavior for negative moduli
assert!(n1.is_positive());
assert!(n2.is_positive());
let GcdData {
gcd: g,
lcm: n3,
coeffs: (c1,c2),
..
} = extended_gcd__inline(n1, n2);
let (a1div, a1rem) = a1.div_rem(&g);
let (a2div, a2rem) = a2.div_rem(&g);
if a1rem != a2rem { None }
else {
let a3 = (a2div*c1*n1 + a1div*c2*n2 + a1rem).mod_floor(&n3);
Some((a3, n3))
}
}
// used for conversions of literals (which will clearly never fail)
fn lit<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
// slightly more verbose for use outside mathematical expressions
fn convert<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
/// An argument to tame function count explosion for functions
/// which can optionally deal with permutation symmetry.
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum OrderType {
/// Order matters; consider all distinct permutations.
Ordered,
/// Order does not matter; only consider distinct combinations.
Unordered,
}
/// Used as a half-baked alternative to writing a generic interface
/// over RangeTo and RangeToInclusive
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum UpperBound<X> { Upto(X), Under(X), }
impl<X> UpperBound<X> where X: Integer + One,
{
// FIXME: I think it is hard to read code that uses this.
/// a generic form of (min..x).next_back() or (min...x).next_back()
fn inclusive_limit_from(self, min: X) -> Option<X> {
match self {
Under(upper) => if min >= upper | else { Some(upper - One::one()) },
Upto(max) => if min > max { None } else { Some(max) },
}
}
}
#[test]
fn test_inclusive_limit_from() {
assert_eq!(Upto(4).inclusive_limit_from(3), Some(4));
assert_eq!(Upto(3).inclusive_limit_from(3), Some(3));
assert_eq!(Upto(2).inclusive_limit_from(3), None);
assert_eq!(Upto(1).inclusive_limit_from(3), None);
assert_eq!(Under(5).inclusive_limit_from(3), Some(4));
assert_eq!(Under(4).inclusive_limit_from(3), Some(3));
assert_eq!(Under(3).inclusive_limit_from(3), None);
assert_eq!(Under(2).inclusive_limit_from(3), None);
// no underflow please kthx
assert_eq!(Under(0).inclusive_limit_from(0), None);
}
use UpperBound::*;
use OrderType::*;
// NOTE: Further possible generalizations:
// * Take a Range instead of UpperBound so that zero can optionally be included
// (however it would also require solving how to produce correct results
// for all other lower bounds)
// * count_coprime_tuplets(max, n)
/// Counts coprime pairs of integers `>= 1`
///
/// # Notes
///
/// `(0,1)` and `(1,0)` are not counted.
/// `(1,1)` (the only symmetric pair) is counted once.
///
/// # Reference
///
/// http://laurentmazare.github.io/2014/09/14/counting-coprime-pairs/
pub fn count_coprime_pairs<X>(bound: UpperBound<X>, order_type: OrderType) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
let max = {
if let Some(max) = bound.inclusive_limit_from(lit(1)) { max }
else { return lit(0); } // catches Under(0), Upto(0), Under(1)
};
let ordered = count_ordered_coprime_pairs(max);
match order_type {
Ordered => ordered,
// Every combination was counted twice except for (1,1);
// Add 1 so that they are ALL double counted, then halve it.
// (this also fortituously produces 0 for max == 0)
Unordered => (ordered + lit(1)) / lit(2),
}
}
fn count_ordered_coprime_pairs<X>(max: X) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
// Function can be described with this recursion relation:
//
// c(n) = n**2 - sum_{k=2}^n c(n // k)
//
// where '//' is floored division.
//
// Many values of k share the same value of (n // k),
// thereby permitting a coarse-graining approach.
// unique values of m (=floor(n/k)) for small k
let fine_deps = |n|
(2..).map(convert::<X>)
.map(move |k| n/k).take_while(move |&m| m*m > n);
// values of m (=floor(n/k)) shared by many large k.
let coarse_deps = |n|
(1..).map(convert::<X>)
.take_while(move |&m| m*m <= n)
// don't produce m == 1 for n == 1
.skip_while(move |_| n == lit(1));
let coarse_multiplicity = |n,m| n/m - n/(m + lit(1));
// Get all values that need to be computed at some point.
//
// Interestingly, these are just 'max' and its direct dependencies
// (which are of the form 'max // k'). The reason the subproblems
// never introduce new dependencies is because integer division
// apparently satisfies the following property for x non-negative
// and a,b positive:
//
// (x // a) // b == (x // b) // a == x // (a*b)
//
// (NOTE: euclidean division wins *yet again*; it is the only sign convention
// under which this also works for negative 'x', 'a', and 'b'!)
let order = {
let mut vec = vec![max];
vec.extend(fine_deps(max));
vec.extend(coarse_deps(max));
vec.sort();
vec
};
let mut memo = HashMap::new();
let compute = |n, memo: &HashMap<X,X>| {
let acc = n*n;
let acc = coarse_deps(n)
.map(|m| memo[&m.into()] * coarse_multiplicity(n,m))
.fold(acc, |a,b| a-b);
let acc = fine_deps(n)
.map(|m| memo[&m.into()])
.fold(acc, | | { None } | conditional_block |
lib.rs | : X) -> X where
X: PrimInt + Integer + Signed,
|
/// Compute a least common multiple.
pub fn lcm<X>(a: X, b: X) -> X where
X: PrimInt + Integer + Signed,
{
let GcdData { lcm, .. } = extended_gcd__inline(a, b);
lcm
}
/// Compute a modular multiplicative inverse, if it exists.
///
/// This implementation uses the extended Gcd algorithm,
pub fn inverse_mod<X>(a: X, m: X) -> Option<X> where
X: PrimInt + Integer + Signed,
{
let GcdData { gcd: g, coeffs: (inv, _), .. } = extended_gcd__inline(a, m);
if g == X::one() { Some(inv.mod_floor(&m)) } else { None }
}
/// Merge many equations of the form `x = ai (mod ni)` into one.
///
/// The moduli don't need to be coprime;
/// ``None`` is returned if the equations are inconsistent.
///
/// `chinese_remainder(vec![])` is defined to be `Some((0,1))`.
pub fn chinese_remainder<X,I>(congruences: I) -> Option<(X,X)> where
X: PrimInt + Integer + Signed,
I: IntoIterator<Item=(X,X)>,
{
// something something "monadic" something "fold"
congruences.into_iter().fold(Some((X::zero(),X::one())),
|opt, new_pair| opt.and_then(|acc_pair|
chinese_remainder2(acc_pair, new_pair)
)
)
}
/// Merge two equations of the form ``x = ai (mod ni)`` into one.
///
/// The moduli don't need to be coprime;
/// `None` is returned if the equations are inconsistent.
///
/// Panics if a modulus is negative or zero.
pub fn chinese_remainder2<X>((a1,n1):(X,X), (a2,n2):(X,X)) -> Option<(X,X)> where
X: PrimInt + Integer + Signed,
{
// I'm too lazy right now to consider whether there is a
// reasonable behavior for negative moduli
assert!(n1.is_positive());
assert!(n2.is_positive());
let GcdData {
gcd: g,
lcm: n3,
coeffs: (c1,c2),
..
} = extended_gcd__inline(n1, n2);
let (a1div, a1rem) = a1.div_rem(&g);
let (a2div, a2rem) = a2.div_rem(&g);
if a1rem != a2rem { None }
else {
let a3 = (a2div*c1*n1 + a1div*c2*n2 + a1rem).mod_floor(&n3);
Some((a3, n3))
}
}
// used for conversions of literals (which will clearly never fail)
fn lit<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
// slightly more verbose for use outside mathematical expressions
fn convert<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
/// An argument to tame function count explosion for functions
/// which can optionally deal with permutation symmetry.
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum OrderType {
/// Order matters; consider all distinct permutations.
Ordered,
/// Order does not matter; only consider distinct combinations.
Unordered,
}
/// Used as a half-baked alternative to writing a generic interface
/// over RangeTo and RangeToInclusive
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum UpperBound<X> { Upto(X), Under(X), }
impl<X> UpperBound<X> where X: Integer + One,
{
// FIXME: I think it is hard to read code that uses this.
/// a generic form of (min..x).next_back() or (min...x).next_back()
fn inclusive_limit_from(self, min: X) -> Option<X> {
match self {
Under(upper) => if min >= upper { None } else { Some(upper - One::one()) },
Upto(max) => if min > max { None } else { Some(max) },
}
}
}
#[test]
fn test_inclusive_limit_from() {
assert_eq!(Upto(4).inclusive_limit_from(3), Some(4));
assert_eq!(Upto(3).inclusive_limit_from(3), Some(3));
assert_eq!(Upto(2).inclusive_limit_from(3), None);
assert_eq!(Upto(1).inclusive_limit_from(3), None);
assert_eq!(Under(5).inclusive_limit_from(3), Some(4));
assert_eq!(Under(4).inclusive_limit_from(3), Some(3));
assert_eq!(Under(3).inclusive_limit_from(3), None);
assert_eq!(Under(2).inclusive_limit_from(3), None);
// no underflow please kthx
assert_eq!(Under(0).inclusive_limit_from(0), None);
}
use UpperBound::*;
use OrderType::*;
// NOTE: Further possible generalizations:
// * Take a Range instead of UpperBound so that zero can optionally be included
// (however it would also require solving how to produce correct results
// for all other lower bounds)
// * count_coprime_tuplets(max, n)
/// Counts coprime pairs of integers `>= 1`
///
/// # Notes
///
/// `(0,1)` and `(1,0)` are not counted.
/// `(1,1)` (the only symmetric pair) is counted once.
///
/// # Reference
///
/// http://laurentmazare.github.io/2014/09/14/counting-coprime-pairs/
pub fn count_coprime_pairs<X>(bound: UpperBound<X>, order_type: OrderType) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
let max = {
if let Some(max) = bound.inclusive_limit_from(lit(1)) { max }
else { return lit(0); } // catches Under(0), Upto(0), Under(1)
};
let ordered = count_ordered_coprime_pairs(max);
match order_type {
Ordered => ordered,
// Every combination was counted twice except for (1,1);
// Add 1 so that they are ALL double counted, then halve it.
// (this also fortituously produces 0 for max == 0)
Unordered => (ordered + lit(1)) / lit(2),
}
}
fn count_ordered_coprime_pairs<X>(max: X) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
// Function can be described with this recursion relation:
//
// c(n) = n**2 - sum_{k=2}^n c(n // k)
//
// where '//' is floored division.
//
// Many values of k share the same value of (n // k),
// thereby permitting a coarse-graining approach.
// unique values of m (=floor(n/k)) for small k
let fine_deps = |n|
(2..).map(convert::<X>)
.map(move |k| n/k).take_while(move |&m| m*m > n);
// values of m (=floor(n/k)) shared by many large k.
let coarse_deps = |n|
(1..).map(convert::<X>)
.take_while(move |&m| m*m <= n)
// don't produce m == 1 for n == 1
.skip_while(move |_| n == lit(1));
let coarse_multiplicity = |n,m| n/m - n/(m + lit(1));
// Get all values that need to be computed at some point.
//
// Interestingly, these are just 'max' and its direct dependencies
// (which are of the form 'max // k'). The reason the subproblems
// never introduce new dependencies is because integer division
// apparently satisfies the following property for x non-negative
// and a,b positive:
//
// (x // a) // b == (x // b) // a == x // (a*b)
//
// (NOTE: euclidean division wins *yet again*; it is the only sign convention
// under which this also works for negative 'x', 'a', and 'b'!)
let order = {
let mut vec = vec![max];
vec.extend(fine_deps(max));
vec.extend(coarse_deps(max));
vec.sort();
vec
};
let mut memo = HashMap::new();
let compute = |n, memo: &HashMap<X,X>| {
let acc = n*n;
let acc = coarse_deps(n)
.map(|m| memo[&m.into()] * coarse_multiplicity(n,m))
.fold(acc, |a,b| a-b);
let acc = fine_deps(n)
.map(|m| memo[&m.into()])
.fold(acc, | | {
let GcdData { gcd, .. } = extended_gcd__inline(a, b);
gcd
} | identifier_body |
lib.rs | a2.div_rem(&g);
if a1rem != a2rem { None }
else {
let a3 = (a2div*c1*n1 + a1div*c2*n2 + a1rem).mod_floor(&n3);
Some((a3, n3))
}
}
// used for conversions of literals (which will clearly never fail)
fn lit<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
// slightly more verbose for use outside mathematical expressions
fn convert<X>(x: i64) -> X where X: PrimInt { X::from(x).unwrap() }
/// An argument to tame function count explosion for functions
/// which can optionally deal with permutation symmetry.
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum OrderType {
/// Order matters; consider all distinct permutations.
Ordered,
/// Order does not matter; only consider distinct combinations.
Unordered,
}
/// Used as a half-baked alternative to writing a generic interface
/// over RangeTo and RangeToInclusive
#[derive(Copy,Clone,Hash,PartialEq,Eq,Debug)]
pub enum UpperBound<X> { Upto(X), Under(X), }
impl<X> UpperBound<X> where X: Integer + One,
{
// FIXME: I think it is hard to read code that uses this.
/// a generic form of (min..x).next_back() or (min...x).next_back()
fn inclusive_limit_from(self, min: X) -> Option<X> {
match self {
Under(upper) => if min >= upper { None } else { Some(upper - One::one()) },
Upto(max) => if min > max { None } else { Some(max) },
}
}
}
#[test]
fn test_inclusive_limit_from() {
assert_eq!(Upto(4).inclusive_limit_from(3), Some(4));
assert_eq!(Upto(3).inclusive_limit_from(3), Some(3));
assert_eq!(Upto(2).inclusive_limit_from(3), None);
assert_eq!(Upto(1).inclusive_limit_from(3), None);
assert_eq!(Under(5).inclusive_limit_from(3), Some(4));
assert_eq!(Under(4).inclusive_limit_from(3), Some(3));
assert_eq!(Under(3).inclusive_limit_from(3), None);
assert_eq!(Under(2).inclusive_limit_from(3), None);
// no underflow please kthx
assert_eq!(Under(0).inclusive_limit_from(0), None);
}
use UpperBound::*;
use OrderType::*;
// NOTE: Further possible generalizations:
// * Take a Range instead of UpperBound so that zero can optionally be included
// (however it would also require solving how to produce correct results
// for all other lower bounds)
// * count_coprime_tuplets(max, n)
/// Counts coprime pairs of integers `>= 1`
///
/// # Notes
///
/// `(0,1)` and `(1,0)` are not counted.
/// `(1,1)` (the only symmetric pair) is counted once.
///
/// # Reference
///
/// http://laurentmazare.github.io/2014/09/14/counting-coprime-pairs/
pub fn count_coprime_pairs<X>(bound: UpperBound<X>, order_type: OrderType) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
let max = {
if let Some(max) = bound.inclusive_limit_from(lit(1)) { max }
else { return lit(0); } // catches Under(0), Upto(0), Under(1)
};
let ordered = count_ordered_coprime_pairs(max);
match order_type {
Ordered => ordered,
// Every combination was counted twice except for (1,1);
// Add 1 so that they are ALL double counted, then halve it.
// (this also fortituously produces 0 for max == 0)
Unordered => (ordered + lit(1)) / lit(2),
}
}
fn count_ordered_coprime_pairs<X>(max: X) -> X where
X: PrimInt + Integer + Hash,
X: ::std::fmt::Debug,
{
// Function can be described with this recursion relation:
//
// c(n) = n**2 - sum_{k=2}^n c(n // k)
//
// where '//' is floored division.
//
// Many values of k share the same value of (n // k),
// thereby permitting a coarse-graining approach.
// unique values of m (=floor(n/k)) for small k
let fine_deps = |n|
(2..).map(convert::<X>)
.map(move |k| n/k).take_while(move |&m| m*m > n);
// values of m (=floor(n/k)) shared by many large k.
let coarse_deps = |n|
(1..).map(convert::<X>)
.take_while(move |&m| m*m <= n)
// don't produce m == 1 for n == 1
.skip_while(move |_| n == lit(1));
let coarse_multiplicity = |n,m| n/m - n/(m + lit(1));
// Get all values that need to be computed at some point.
//
// Interestingly, these are just 'max' and its direct dependencies
// (which are of the form 'max // k'). The reason the subproblems
// never introduce new dependencies is because integer division
// apparently satisfies the following property for x non-negative
// and a,b positive:
//
// (x // a) // b == (x // b) // a == x // (a*b)
//
// (NOTE: euclidean division wins *yet again*; it is the only sign convention
// under which this also works for negative 'x', 'a', and 'b'!)
let order = {
let mut vec = vec![max];
vec.extend(fine_deps(max));
vec.extend(coarse_deps(max));
vec.sort();
vec
};
let mut memo = HashMap::new();
let compute = |n, memo: &HashMap<X,X>| {
let acc = n*n;
let acc = coarse_deps(n)
.map(|m| memo[&m.into()] * coarse_multiplicity(n,m))
.fold(acc, |a,b| a-b);
let acc = fine_deps(n)
.map(|m| memo[&m.into()])
.fold(acc, |a,b| a-b);
acc
};
for x in order {
let value = compute(x, &memo);
memo.insert(x, value);
}
memo[&max]
}
#[cfg(test)]
mod tests {
use super::*;
use super::OrderType::*;
use super::UpperBound::*;
use ::num_integer::Integer;
use ::num_traits::{PrimInt,Signed};
use test;
use rand::{Rng};
#[test]
fn test_gcd() {
// swap left/right
// (using a pair that takes several iterations)
assert_eq!(gcd(234,123), 3);
assert_eq!(gcd(123,234), 3);
// negatives
assert_eq!(gcd(-15,20), 5);
assert_eq!(gcd(15,-20), 5);
assert_eq!(gcd(-15,-20), 5);
// zeroes
assert_eq!(gcd(0,17), 17);
assert_eq!(gcd(17,0), 17);
assert_eq!(gcd(0,0), 0);
}
#[test]
fn test_chinese_remainder() {
// test both interfaces
let eq1 = (2328,16256);
let eq2 = (410,5418);
let soln = (28450328, 44037504);
assert_eq!(chinese_remainder2(eq1,eq2), Some(soln));
assert_eq!(chinese_remainder(vec![eq1,eq2]), Some(soln));
// (0,1) serves as an "identity"
assert_eq!(chinese_remainder(vec![]), Some((0,1)));
assert_eq!(chinese_remainder(vec![(0,1)]), Some((0,1)));
assert_eq!(chinese_remainder(vec![(0,1),(13,36)]), Some((13,36)));
assert_eq!(chinese_remainder(vec![(13,36),(0,1)]), Some((13,36)));
// single equation
assert_eq!(chinese_remainder(vec![eq1]), Some(eq1));
// inconsistent equations
assert_eq!(chinese_remainder2((10,7),(4,14)), None);
assert_eq!(chinese_remainder(vec![(10,7),(4,14)]), None);
// FIXME: test more than 2 equations
// FIXME: do we specify behavior for when the input a_i are | random_line_split | ||
main.rs |
fn print_current(last_secs: &mut u32, cur_secs: f32, total_secs: f32) {
let secs = cur_secs.trunc() as u32;
if *last_secs == secs {
return;
}
*last_secs = secs;
print!("\r");
print_time(secs);
print!(" -> ");
print_time((total_secs - cur_secs).trunc() as u32);
stdout().flush().unwrap();
}
/****************************************************************************/
/* PLAYER */
/****************************************************************************/
struct PlayEnv {
ym_file: YmSong,
ampl_level: f32,
repeat: u32,
channel_map: ChannelMap,
track: bool,
}
fn play_with_blep<A, B, SD, S>(
PlayEnv { mut ym_file, ampl_level, repeat, channel_map, track }: PlayEnv,
mut audio: AudioHandle<S>,
bandlim: &mut B,
render_audio: &dyn Fn(&mut BlepAmpFilter<&mut B>, &mut Vec<S>)
)
where A: AmpLevels<SD>,
B: BandLimitedExt<SD, S> + ?Sized,
SD: SampleDelta + FromSample<f32> + MulNorm,
S: AudioSample + cpal::SizedSample
{
log::debug!("Channels: {channel_map} {:?}", channel_map.0);
/* Spectrusty's emulated AY is clocked at a half frequency of a host CPU clock,
we need to adjust cycles counter */
let host_frame_cycles = (ym_file.frame_cycles() * HOST_CLOCK_RATIO as f32) as i32;
let host_frequency = ym_file.chipset_frequency as f64 * HOST_CLOCK_RATIO as f64;
log::trace!("AY host frequency: {} Hz, frame: {} cycles", host_frequency, host_frame_cycles);
/* create a BLEP amplitude filter wrapper */
let mut bandlim = BlepAmpFilter::new(SD::from_sample(ampl_level), bandlim);
/* ensure BLEP has enough space to fit a single audio frame
(there is no margin - our frames will have constant size). */
bandlim.ensure_frame_time(audio.sample_rate, host_frequency, host_frame_cycles, 0);
/* number of audio output channels */
let channels = audio.channels as usize;
/* create an emulator instance */
let mut ay = Ay3_891xAudio::default();
/* buffered frame changes to AY-3-891x registers */
let mut changes = Vec::new();
/* play counter */
let mut counter = repeat;
/* total seconds */
let total_secs = ym_file.frames.len() as f32 / ym_file.frame_frequency as f32;
let mut last_secs: u32 = u32::MAX;
loop {
if track {
let cur_secs = ym_file.cursor() as f32 / ym_file.frame_frequency as f32;
print_current(&mut last_secs, cur_secs, total_secs);
}
/* produce YM chipset changes */
let finished = ym_file.produce_next_ay_frame(|ts, reg, val| {
changes.push(
AyRegChange::new(
(ts * HOST_CLOCK_RATIO as f32).trunc() as i32,
AyRegister::from(reg),
val))
});
/* render audio into BLEP */
ay.render_audio::<A,_,_>(changes.drain(..),
&mut bandlim,
host_frame_cycles,
host_frame_cycles,
channel_map.0);
/* close frame */
let frame_sample_count = bandlim.end_frame(host_frame_cycles);
/* render BLEP frame into the sample buffer */
audio.producer.render_frame(|ref mut buf| {
/* ensure the BLEP frame fits into the sample buffer */
buf.resize(frame_sample_count * channels, S::silence());
render_audio(&mut bandlim, buf);
});
/* send a rendered sample buffer to the consumer */
audio.producer.send_frame().unwrap();
if finished {
log::info!("Finished.");
if repeat != 0 {
counter -= 1;
if counter == 0 {
break;
}
}
}
}
/* let the audio thread finish playing */
for _ in 0..50 {
audio.producer.render_frame(|ref mut buf| {
buf.fill(S::silence());
});
audio.producer.send_frame().unwrap();
}
audio.close();
}
fn play_with_amps<A, SD, S>(
audio: AudioHandle<S>,
ym_file: YmSong,
args: Args
)
where A: AmpLevels<SD>,
SD: SampleDelta + FromSample<f32> + AddAssign + MulNorm + 'static + std::fmt::Debug,
S: FromSample<SD> + AudioSample + cpal::SizedSample
{
let Args { volume, repeat, channels: channel_map, mode, track, hpass, lpass, .. } = args;
log::debug!("Repeat: {repeat}, volume: {volume}%");
let ampl_level = amplitude_level(args.volume);
log::trace!("Amplitude filter: {ampl_level}");
let mut env = PlayEnv { ym_file, ampl_level, repeat, channel_map, track };
let channels = audio.channels as usize;
match mode {
ChannelMode::MixedStereo(mono_filter) if channels >= 2 => {
/* a multi-channel to stereo mixer */
let mut blep = BlepStereo::new(mono_filter.into_sample(),
/* a stereo band-limited pulse buffer */
BandLimitedAny::new(2, lpass, hpass));
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_map_interleaved(buf, channels, &[0, 1]);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
ChannelMode::Channel(channel) if channels >= channel as usize => {
/* a multi-channel band-limited pulse buffer */
let third_chan = (channel - 1) as usize;
let mut blep = BandLimitedAny::new(3, lpass, hpass);
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_map_interleaved(buf, channels, &[0, 1, third_chan]);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
_ => {
/* a monophonic band-limited pulse buffer */
let mut blep = BandLimitedAny::new(1, lpass, hpass);
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
env.channel_map = MONO_CHANNEL_MAP;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_fill_interleaved(buf, channels, 0);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
}
}
fn play<SD, S>(
audio: AudioHandle<S>,
ym_file: YmSong,
args: Args
)
where SD: SampleDelta + FromSample<f32> + AddAssign + MulNorm + 'static + std::fmt::Debug,
S: FromSample<SD> + AudioSample + cpal::SizedSample,
AyFuseAmps<SD>: AmpLevels<SD>,
AyAmps<SD>: AmpLevels<SD>
{
if args.fuse {
log::debug!("YM amplitide levels: fuse (measured)");
play_with_amps::<AyFuseAmps<_>, _, _>(audio, ym_file, args)
}
else {
log::debug!("YM amplitide levels: default (specs)");
play_with_amps::<AyAmps<_>, _, _>(audio, ym_file, args)
}
}
/****************************************************************************/
/* MAIN */
/****************************************************************************/
#[derive(Default, Debug, Clone, Copy, PartialEq)]
struct StreamConfigHint {
channels: Option<cpal::ChannelCount>,
sample_rate: Option<cpal::SampleRate>,
sample_format: Option<cpal::SampleFormat>
}
impl fmt::Display for StreamConfigHint {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self == &StreamConfigHint:: | {
let hours = secs / 3600;
let minutes = (secs % 3600) / 60;
let secs = secs % 60;
if hours != 0 {
print!("{hours}:{minutes:02}:{secs:02}");
}
else {
print!("{minutes:02}:{secs:02}");
}
} | identifier_body | |
main.rs | + MulNorm + 'static + std::fmt::Debug,
S: FromSample<SD> + AudioSample + cpal::SizedSample
{
let Args { volume, repeat, channels: channel_map, mode, track, hpass, lpass, .. } = args;
log::debug!("Repeat: {repeat}, volume: {volume}%");
let ampl_level = amplitude_level(args.volume);
log::trace!("Amplitude filter: {ampl_level}");
let mut env = PlayEnv { ym_file, ampl_level, repeat, channel_map, track };
let channels = audio.channels as usize;
match mode {
ChannelMode::MixedStereo(mono_filter) if channels >= 2 => {
/* a multi-channel to stereo mixer */
let mut blep = BlepStereo::new(mono_filter.into_sample(),
/* a stereo band-limited pulse buffer */
BandLimitedAny::new(2, lpass, hpass));
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_map_interleaved(buf, channels, &[0, 1]);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
ChannelMode::Channel(channel) if channels >= channel as usize => {
/* a multi-channel band-limited pulse buffer */
let third_chan = (channel - 1) as usize;
let mut blep = BandLimitedAny::new(3, lpass, hpass);
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_map_interleaved(buf, channels, &[0, 1, third_chan]);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
_ => {
/* a monophonic band-limited pulse buffer */
let mut blep = BandLimitedAny::new(1, lpass, hpass);
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
env.channel_map = MONO_CHANNEL_MAP;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_fill_interleaved(buf, channels, 0);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
}
}
fn play<SD, S>(
audio: AudioHandle<S>,
ym_file: YmSong,
args: Args
)
where SD: SampleDelta + FromSample<f32> + AddAssign + MulNorm + 'static + std::fmt::Debug,
S: FromSample<SD> + AudioSample + cpal::SizedSample,
AyFuseAmps<SD>: AmpLevels<SD>,
AyAmps<SD>: AmpLevels<SD>
{
if args.fuse {
log::debug!("YM amplitide levels: fuse (measured)");
play_with_amps::<AyFuseAmps<_>, _, _>(audio, ym_file, args)
}
else {
log::debug!("YM amplitide levels: default (specs)");
play_with_amps::<AyAmps<_>, _, _>(audio, ym_file, args)
}
}
/****************************************************************************/
/* MAIN */
/****************************************************************************/
#[derive(Default, Debug, Clone, Copy, PartialEq)]
struct StreamConfigHint {
channels: Option<cpal::ChannelCount>,
sample_rate: Option<cpal::SampleRate>,
sample_format: Option<cpal::SampleFormat>
}
impl fmt::Display for StreamConfigHint {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self == &StreamConfigHint::default() {
return f.write_str("*");
}
if let Some(format) = self.sample_format {
write!(f, "{:?}", format)?;
}
if self.channels.is_some() && self.sample_rate.is_some() {
f.write_str(",")?;
}
if let Some(channels) = self.channels {
write!(f, "{}", channels)?;
}
if let Some(rate) = self.sample_rate {
write!(f, "@{}", rate.0)?;
}
Ok(())
}
}
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
/// A file path to an YM song.
ym_file: Option<String>,
/// Audio mixer volume: 0 - 100.
#[arg(short, long, default_value_t = 50, value_parser = volume_in_range)]
volume: u8,
/// Play counter, 0 to play forever.
#[arg(short, long, default_value_t = 0)]
repeat: u32,
/// YM channels map: Left Center Right.
#[arg(short, long, default_value_t = ChannelMap::default(), value_parser = parse_channels)]
channels: ChannelMap,
/// Channel mode: s|m|0.s|N.
///
/// "s" - stereo mode with a center channel mixed with an amplitude of 0.8
///
/// "m" - monophonic mode, played on all audio channels
///
/// "0.s" - stereo mode, center channel amplitude: 0.s
///
/// "N" - multi-channel mode, redirect center channel to Nth (3+) audio channel
#[arg(short, long, default_value_t = ChannelMode::default(), value_parser = parse_channel_mode)]
mode: ChannelMode,
/// Switch to alternative YM amplitude levels (measured vs specs).
#[arg(short, long, default_value_t = false)]
fuse: bool,
/// Enable low-pass audio band filter.
#[arg(long, default_value_t = false)]
lpass: bool,
/// Enable high-pass audio band filter.
#[arg(long, default_value_t = false)]
hpass: bool,
/// Desired audio output parameters: ST,CHANS@RATE.
///
/// ST is a sample type, e.g.: U8, I16, U32, F32.
///
/// CHANS is the number of channels and RATE is the sample rate.
#[arg(short, long, default_value_t = StreamConfigHint::default(), value_parser = parse_stream_config)]
audio: StreamConfigHint,
/// Track the current song time.
#[arg(short, long, default_value_t = false)]
track: bool,
/// Log verbosity level.
///
/// -d for INFO, -dd for DEBUG, -ddd for TRACE
#[arg(short, long, action = clap::ArgAction::Count)]
debug: u8
}
fn volume_in_range(s: &str) -> Result<u8, String> {
let volume: usize = s
.parse()
.map_err(|_| format!("`{s}` isn't a volume"))?;
if (0..=NORMAL_AMPLITUDE as usize).contains(&volume) {
Ok(volume as u8)
} else {
Err(format!("volume not in range 0 - {NORMAL_AMPLITUDE}"))
}
}
fn parse_channel_mode(s: &str) -> Result<ChannelMode, String> {
Ok(match s {
"s"|"S" => ChannelMode::MixedStereo(0.8),
"m"|"M" => ChannelMode::Mono,
s if s.starts_with("0.") => {
let amp: f32 = s.parse().map_err(|_| format!("`{s}` isn't a stereo mixer amplitude"))?;
ChannelMode::MixedStereo(amp)
}
s => {
let channel: u32 = s.parse().map_err(|_| format!("`{s}` isn't a mixer mode channel"))?;
if channel < 3 {
return Err("mixer mode channel must be >= 3".into());
}
ChannelMode::Channel(channel)
}
})
}
fn parse_channels(s: &str) -> Result<ChannelMap, String> {
const ERROR_MSG: &str = "channel mapping should be a permutation of ABC characters";
if s.len() != 3 {
return Err(ERROR_MSG.into());
}
let mut channels = [usize::MAX; 3];
// [A, B, C], where N -> 0: left, 1: right, 2: center
for (ch, chan) in s.chars().zip([0, 2, 1].into_iter()) {
let pos = match ch.to_ascii_uppercase() {
'A' => 0,
'B' => 1,
'C' => 2,
_ => return Err(ERROR_MSG.into())
};
if channels[pos] != usize::MAX {
return Err(ERROR_MSG.into());
}
channels[pos] = chan;
}
Ok(ChannelMap(channels))
}
fn | parse_stream_config | identifier_name | |
main.rs | frame fits into the sample buffer */
buf.resize(frame_sample_count * channels, S::silence());
render_audio(&mut bandlim, buf);
});
/* send a rendered sample buffer to the consumer */
audio.producer.send_frame().unwrap();
if finished {
log::info!("Finished.");
if repeat != 0 {
counter -= 1;
if counter == 0 {
break;
}
}
}
}
/* let the audio thread finish playing */
for _ in 0..50 {
audio.producer.render_frame(|ref mut buf| {
buf.fill(S::silence());
});
audio.producer.send_frame().unwrap();
}
audio.close();
}
fn play_with_amps<A, SD, S>(
audio: AudioHandle<S>,
ym_file: YmSong,
args: Args
)
where A: AmpLevels<SD>,
SD: SampleDelta + FromSample<f32> + AddAssign + MulNorm + 'static + std::fmt::Debug,
S: FromSample<SD> + AudioSample + cpal::SizedSample
{
let Args { volume, repeat, channels: channel_map, mode, track, hpass, lpass, .. } = args;
log::debug!("Repeat: {repeat}, volume: {volume}%");
let ampl_level = amplitude_level(args.volume);
log::trace!("Amplitude filter: {ampl_level}");
let mut env = PlayEnv { ym_file, ampl_level, repeat, channel_map, track };
let channels = audio.channels as usize;
match mode {
ChannelMode::MixedStereo(mono_filter) if channels >= 2 => {
/* a multi-channel to stereo mixer */
let mut blep = BlepStereo::new(mono_filter.into_sample(),
/* a stereo band-limited pulse buffer */
BandLimitedAny::new(2, lpass, hpass));
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_map_interleaved(buf, channels, &[0, 1]);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
ChannelMode::Channel(channel) if channels >= channel as usize => {
/* a multi-channel band-limited pulse buffer */
let third_chan = (channel - 1) as usize;
let mut blep = BandLimitedAny::new(3, lpass, hpass);
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_map_interleaved(buf, channels, &[0, 1, third_chan]);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
_ => {
/* a monophonic band-limited pulse buffer */
let mut blep = BandLimitedAny::new(1, lpass, hpass);
log::debug!("Band limited: {blep:?}");
let blep: &mut dyn BandLimitedExt<_, _> = &mut blep;
env.channel_map = MONO_CHANNEL_MAP;
play_with_blep::<A, _, _, _>(env, audio, blep,
&|blep, buf| {
blep.render_audio_fill_interleaved(buf, channels, 0);
/* prepare BLEP for the next frame */
blep.next_frame_ext();
}
);
}
}
}
fn play<SD, S>(
audio: AudioHandle<S>,
ym_file: YmSong,
args: Args
)
where SD: SampleDelta + FromSample<f32> + AddAssign + MulNorm + 'static + std::fmt::Debug,
S: FromSample<SD> + AudioSample + cpal::SizedSample,
AyFuseAmps<SD>: AmpLevels<SD>,
AyAmps<SD>: AmpLevels<SD>
{
if args.fuse {
log::debug!("YM amplitide levels: fuse (measured)");
play_with_amps::<AyFuseAmps<_>, _, _>(audio, ym_file, args)
}
else {
log::debug!("YM amplitide levels: default (specs)");
play_with_amps::<AyAmps<_>, _, _>(audio, ym_file, args)
}
}
/****************************************************************************/
/* MAIN */
/****************************************************************************/
#[derive(Default, Debug, Clone, Copy, PartialEq)]
struct StreamConfigHint {
channels: Option<cpal::ChannelCount>,
sample_rate: Option<cpal::SampleRate>,
sample_format: Option<cpal::SampleFormat>
}
impl fmt::Display for StreamConfigHint {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self == &StreamConfigHint::default() {
return f.write_str("*");
}
if let Some(format) = self.sample_format {
write!(f, "{:?}", format)?;
}
if self.channels.is_some() && self.sample_rate.is_some() {
f.write_str(",")?;
}
if let Some(channels) = self.channels {
write!(f, "{}", channels)?;
}
if let Some(rate) = self.sample_rate {
write!(f, "@{}", rate.0)?;
}
Ok(())
}
}
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
/// A file path to an YM song.
ym_file: Option<String>,
/// Audio mixer volume: 0 - 100.
#[arg(short, long, default_value_t = 50, value_parser = volume_in_range)]
volume: u8,
/// Play counter, 0 to play forever.
#[arg(short, long, default_value_t = 0)]
repeat: u32,
/// YM channels map: Left Center Right.
#[arg(short, long, default_value_t = ChannelMap::default(), value_parser = parse_channels)]
channels: ChannelMap,
/// Channel mode: s|m|0.s|N.
///
/// "s" - stereo mode with a center channel mixed with an amplitude of 0.8
///
/// "m" - monophonic mode, played on all audio channels
///
/// "0.s" - stereo mode, center channel amplitude: 0.s
///
/// "N" - multi-channel mode, redirect center channel to Nth (3+) audio channel
#[arg(short, long, default_value_t = ChannelMode::default(), value_parser = parse_channel_mode)]
mode: ChannelMode,
/// Switch to alternative YM amplitude levels (measured vs specs).
#[arg(short, long, default_value_t = false)]
fuse: bool,
/// Enable low-pass audio band filter.
#[arg(long, default_value_t = false)]
lpass: bool,
/// Enable high-pass audio band filter.
#[arg(long, default_value_t = false)]
hpass: bool,
/// Desired audio output parameters: ST,CHANS@RATE.
///
/// ST is a sample type, e.g.: U8, I16, U32, F32.
///
/// CHANS is the number of channels and RATE is the sample rate.
#[arg(short, long, default_value_t = StreamConfigHint::default(), value_parser = parse_stream_config)]
audio: StreamConfigHint,
/// Track the current song time.
#[arg(short, long, default_value_t = false)]
track: bool,
/// Log verbosity level.
///
/// -d for INFO, -dd for DEBUG, -ddd for TRACE
#[arg(short, long, action = clap::ArgAction::Count)]
debug: u8
}
fn volume_in_range(s: &str) -> Result<u8, String> {
let volume: usize = s
.parse()
.map_err(|_| format!("`{s}` isn't a volume"))?;
if (0..=NORMAL_AMPLITUDE as usize).contains(&volume) {
Ok(volume as u8)
} else {
Err(format!("volume not in range 0 - {NORMAL_AMPLITUDE}"))
}
}
fn parse_channel_mode(s: &str) -> Result<ChannelMode, String> {
Ok(match s {
"s"|"S" => ChannelMode::MixedStereo(0.8),
"m"|"M" => ChannelMode::Mono,
s if s.starts_with("0.") => {
let amp: f32 = s.parse().map_err(|_| format!("`{s}` isn't a stereo mixer amplitude"))?;
ChannelMode::MixedStereo(amp)
}
s => {
let channel: u32 = s.parse().map_err(|_| format!("`{s}` isn't a mixer mode channel"))?;
if channel < 3 {
return Err("mixer mode channel must be >= 3".into());
} | ChannelMode::Channel(channel)
} | random_line_split | |
component.py | {} on "
"topic {}".format(rpc_id, rpc_method, self.target.topic))
rpc = self.RPC.query.one(rpc_id)
return rpc
def cast(self, ctxt, method, args):
"""Asynchronous Call"""
rpc = self.RPC(action=self.RPC.CAST,
ctxt=ctxt, method=method, args=args)
assert (rpc.enqueued)
rpc_id = rpc.id
topic = self.target.topic
LOG.info(
_LI("Message {} on topic {} enqueued").format(rpc_id, topic))
if self.conf.messaging_server.debug:
LOG.debug("Casting method {} with args {}".format(method, args))
return rpc_id
def call(self, ctxt, method, args):
"""Synchronous Call"""
# # check if the call has a message saved in cache
# # key: string concatenation of ctxt + method + args
# # value: rpc response object
# key = ""
# for k, v in ctxt.items():
# key += str(k)
# key += '#' + str(v) + '#'
# key += '|' + str(method) + '|'
# for k, v in args.items():
# key += str(k)
# key += '#' + str(v) + '#'
#
# # check if the method has been called before
# # and cached
# if key in self.message_cache:
# LOG.debug("Retrieved method {} with args "
# "{} from cache".format(method, args))
# return self.message_cache[key]
rpc_start_time = time.time()
rpc = self.RPC(action=self.RPC.CALL,
ctxt=ctxt, method=method, args=args)
# TODO(jdandrea): Do something if the assert fails.
assert (rpc.enqueued)
rpc_id = rpc.id
topic = self.target.topic
LOG.info(
_LI("Message {} on topic {} enqueued.").format(rpc_id, topic))
if self.conf.messaging_server.debug:
LOG.debug("Calling method {} with args {}".format(method, args))
# Check message status within a thread
executor = futurist.ThreadPoolExecutor()
started_at = time.time()
while (time.time() - started_at) <= self.conf.messaging_server.response_timeout:
fut = executor.submit(self.__check_rpc_status, rpc_id, method)
rpc = fut.result()
if rpc and rpc.finished:
if self.conf.messaging_server.debug:
LOG.debug("Message {} method {} response received".
format(rpc_id, method))
break
executor.shutdown()
# Get response, delete message, and return response
if not rpc or not rpc.finished:
LOG.error(_LE("Message {} on topic {} timed out at {} seconds").
format(rpc_id, topic,
self.conf.messaging_server.response_timeout))
elif not rpc.ok:
LOG.error(_LE("Message {} on topic {} returned an error").
format(rpc_id, topic))
response = rpc.response
failure = rpc.failure
rpc.delete() # TODO(jdandrea): Put a TTL on the msg instead?
# self.message_cache[key] = response
LOG.debug("Elapsed time: {0:.3f} sec".format(
time.time() - rpc_start_time)
)
# If there's a failure, raise it as an exception
allowed = []
if failure is not None and failure != '':
# TODO(jdandrea): Do we need to populate allowed(_remote_exmods)?
raise rpc_common.deserialize_remote_exception(failure, allowed)
return response
class RPCService(cotyledon.Service):
"""Listener for the RPC service.
An RPC Service exposes a number of endpoints, each of which contain
a set of methods which may be invoked remotely by clients over a
given transport. To create an RPC server, you supply a transport,
target, and a list of endpoints.
Start the server with server.run()
"""
# This will appear in 'ps xaf'
name = RPCSVRNAME
def __init__(self, worker_id, conf, **kwargs):
"""Initializer"""
super(RPCService, self).__init__(worker_id)
if conf.messaging_server.debug:
LOG.debug("%s" % self.__class__.__name__)
self._init(conf, **kwargs)
self.running = True
def _init(self, conf, **kwargs):
"""Prepare to process requests"""
self.conf = conf
self.rpc_listener = None
self.transport = kwargs.pop('transport')
self.target = kwargs.pop('target')
self.endpoints = kwargs.pop('endpoints')
self.flush = kwargs.pop('flush')
self.kwargs = kwargs
self.RPC = self.target.topic_class
self.name = "{}, topic({})".format(RPCSVRNAME, self.target.topic)
self.messaging_owner_condition = {
"owner": socket.gethostname()
}
self.enqueued_status_condition = {
"status": message.Message.ENQUEUED
}
self.working_status_condition = {
"status": message.Message.WORKING
}
if self.flush:
self._flush_enqueued()
def _flush_enqueued(self):
"""Flush all messages with an enqueued status.
Use this only when the parent service is not running concurrently.
"""
msgs = self.RPC.query.all()
for msg in msgs:
if msg.enqueued:
if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))
elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.args['plan_name']))
msg.delete()
def _log_error_and_update_msg(self, msg, error_msg):
LOG.error(error_msg)
msg.response = {
'error': {
'message': error_msg
}
}
msg.status = message.Message.ERROR
msg.update(condition=self.messaging_owner_condition)
def current_time_seconds(self):
"""Current time in milliseconds."""
return int(round(time.time()))
def millisec_to_sec(self, millisec):
"""Convert milliseconds to seconds"""
return millisec / 1000
def __check_for_messages(self):
"""Wait for the polling interval, then do the real message check."""
# Wait for at least poll_interval sec
polling_interval = self.conf.messaging_server.polling_interval
time.sleep(polling_interval)
if self.conf.messaging_server.debug:
LOG.debug("Topic {}: Checking for new messages".format(
self.target.topic))
self._do()
return True
# FIXME(jdandrea): Better name for this, please, kthx.
def _do(self):
"""Look for a new RPC call and serve it"""
# Get all the messages in queue
msgs = self.RPC.query.all()
for msg in msgs:
# Find the first msg marked as enqueued.
if msg.working and \
(self.current_time_seconds() - self.millisec_to_sec(msg.updated)) \
> self.conf.messaging_server.response_timeout:
msg.status = message.Message.ENQUEUED
msg.update(condition=self.working_status_condition)
if not msg.enqueued:
continue
if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))
elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.args['plan_name']))
# Change the status to WORKING (operation with a lock)
msg.status = message.Message.WORKING
msg.owner = socket.gethostname()
# All update should have a condition (status == enqueued)
_is_updated = msg.update(condition=self.enqueued_status_condition)
if not _is_updated or 'FAILURE' in _is_updated:
continue
# RPC methods must not start/end with an underscore.
if msg.method.startswith('_') or msg.method.endswith('_'):
error_msg = _LE("Method {} must not start or end"
"with underscores").format(msg.method)
self._log_error_and_update_msg(msg, error_msg)
return
# The first endpoint that supports the method wins.
method = None
for endpoint in self.endpoints:
if msg.method not in dir(endpoint):
continue
endpoint_method = getattr(endpoint, msg.method)
if callable(endpoint_method):
method = endpoint_method
if self.conf.messaging_server.debug:
LOG.debug("Message {} method {} is "
"handled by endpoint {}".
format(msg.id, msg.method,
method.__str__.__name__))
break
if not method:
error_msg = _LE("Message {} method {} unsupported "
"in endpoints.").format(msg.id, msg.method)
self._log_error_and_update_msg(msg, error_msg)
return
# All methods must take a ctxt and args param.
if inspect.getfullargspec(method).args != ['self', 'ctx', 'arg']:
error_msg = _LE("Method {} must take three args: "
"self, ctx, arg").format(msg.method)
self._log_error_and_update_msg(msg, error_msg)
return
| random_line_split | ||
component.py | .'),
]
CONF.register_opts(MESSAGING_SERVER_OPTS, group='messaging_server')
# Some class/method descriptions taken from this Oslo Messaging
# RPC API Tutorial/Demo: https://www.youtube.com/watch?v=Bf4gkeoBzvA
RPCSVRNAME = "Music-RPC Server"
class Target(object):
"""Returns a messaging target.
A target encapsulates all the information to identify where a message
should be sent or what messages a server is listening for.
"""
_topic = None
_topic_class = None
def __init__(self, topic):
"""Set the topic and topic class"""
self._topic = topic
# Because this is Music-specific, the server is
# built-in to the API class, stored as the transport.
# Thus, unlike oslo.messaging, there is no server
# specified for a target. There also isn't an
# exchange, namespace, or version at the moment.
# Dynamically create a message class for this topic.
self._topic_class = base.create_dynamic_model(
keyspace=CONF.messaging_server.keyspace,
baseclass=message.Message, classname=self.topic)
if not self._topic_class:
raise RuntimeError("Error setting the topic class for the messaging layer.")
@property
def topic(self):
"""Topic Property"""
return self._topic
@property
def topic_class(self):
"""Topic Class Property"""
return self._topic_class
class RPCClient(object):
"""Returns an RPC client using Music as a transport.
The RPC client is responsible for sending method invocations
to remote servers via a messaging transport.
A method invocation consists of a request context dictionary
a method name, and a dictionary of arguments. A cast() invocation
just sends the request and returns immediately. A call() invocation
waits for the server to send a return value.
"""
def __init__(self, conf, transport, target):
"""Set the transport and target"""
self.conf = conf
self.transport = transport
self.target = target
self.RPC = self.target.topic_class
# introduced as a quick means to cache messages
# with the aim of preventing unnecessary communication
# across conductor components.
# self.message_cache = dict()
def __check_rpc_status(self, rpc_id, rpc_method):
"""Check status for a given message id"""
# Wait check_interval seconds before proceeding
check_interval = self.conf.messaging_server.check_interval
time.sleep(check_interval)
if self.conf.messaging_server.debug:
LOG.debug("Checking status for message {} method {} on "
"topic {}".format(rpc_id, rpc_method, self.target.topic))
rpc = self.RPC.query.one(rpc_id)
return rpc
def cast(self, ctxt, method, args):
"""Asynchronous Call"""
rpc = self.RPC(action=self.RPC.CAST,
ctxt=ctxt, method=method, args=args)
assert (rpc.enqueued)
rpc_id = rpc.id
topic = self.target.topic
LOG.info(
_LI("Message {} on topic {} enqueued").format(rpc_id, topic))
if self.conf.messaging_server.debug:
LOG.debug("Casting method {} with args {}".format(method, args))
return rpc_id
def call(self, ctxt, method, args):
"""Synchronous Call"""
# # check if the call has a message saved in cache
# # key: string concatenation of ctxt + method + args
# # value: rpc response object
# key = ""
# for k, v in ctxt.items():
# key += str(k)
# key += '#' + str(v) + '#'
# key += '|' + str(method) + '|'
# for k, v in args.items():
# key += str(k)
# key += '#' + str(v) + '#'
#
# # check if the method has been called before
# # and cached
# if key in self.message_cache:
# LOG.debug("Retrieved method {} with args "
# "{} from cache".format(method, args))
# return self.message_cache[key]
rpc_start_time = time.time()
rpc = self.RPC(action=self.RPC.CALL,
ctxt=ctxt, method=method, args=args)
# TODO(jdandrea): Do something if the assert fails.
assert (rpc.enqueued)
rpc_id = rpc.id
topic = self.target.topic
LOG.info(
_LI("Message {} on topic {} enqueued.").format(rpc_id, topic))
if self.conf.messaging_server.debug:
LOG.debug("Calling method {} with args {}".format(method, args))
# Check message status within a thread
executor = futurist.ThreadPoolExecutor()
started_at = time.time()
while (time.time() - started_at) <= self.conf.messaging_server.response_timeout:
fut = executor.submit(self.__check_rpc_status, rpc_id, method)
rpc = fut.result()
if rpc and rpc.finished:
if self.conf.messaging_server.debug:
LOG.debug("Message {} method {} response received".
format(rpc_id, method))
break
executor.shutdown()
# Get response, delete message, and return response
if not rpc or not rpc.finished:
LOG.error(_LE("Message {} on topic {} timed out at {} seconds").
format(rpc_id, topic,
self.conf.messaging_server.response_timeout))
elif not rpc.ok:
LOG.error(_LE("Message {} on topic {} returned an error").
format(rpc_id, topic))
response = rpc.response
failure = rpc.failure
rpc.delete() # TODO(jdandrea): Put a TTL on the msg instead?
# self.message_cache[key] = response
LOG.debug("Elapsed time: {0:.3f} sec".format(
time.time() - rpc_start_time)
)
# If there's a failure, raise it as an exception
allowed = []
if failure is not None and failure != '':
# TODO(jdandrea): Do we need to populate allowed(_remote_exmods)?
raise rpc_common.deserialize_remote_exception(failure, allowed)
return response
class RPCService(cotyledon.Service):
"""Listener for the RPC service.
An RPC Service exposes a number of endpoints, each of which contain
a set of methods which may be invoked remotely by clients over a
given transport. To create an RPC server, you supply a transport,
target, and a list of endpoints.
Start the server with server.run()
"""
# This will appear in 'ps xaf'
name = RPCSVRNAME
def __init__(self, worker_id, conf, **kwargs):
"""Initializer"""
super(RPCService, self).__init__(worker_id)
if conf.messaging_server.debug:
LOG.debug("%s" % self.__class__.__name__)
self._init(conf, **kwargs)
self.running = True
def _init(self, conf, **kwargs):
"""Prepare to process requests"""
self.conf = conf
self.rpc_listener = None
self.transport = kwargs.pop('transport')
self.target = kwargs.pop('target')
self.endpoints = kwargs.pop('endpoints')
self.flush = kwargs.pop('flush')
self.kwargs = kwargs
self.RPC = self.target.topic_class
self.name = "{}, topic({})".format(RPCSVRNAME, self.target.topic)
self.messaging_owner_condition = {
"owner": socket.gethostname()
}
self.enqueued_status_condition = {
"status": message.Message.ENQUEUED
}
self.working_status_condition = {
"status": message.Message.WORKING
}
if self.flush:
|
def _flush_enqueued(self):
"""Flush all messages with an enqueued status.
Use this only when the parent service is not running concurrently.
"""
msgs = self.RPC.query.all()
for msg in msgs:
if msg.enqueued:
if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))
elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.args['plan_name']))
msg.delete()
def _log_error_and_update_msg(self, msg, error_msg):
LOG.error(error_msg)
msg.response = {
'error': {
'message': error_msg
}
}
msg.status = message.Message.ERROR
msg.update(condition=self.messaging_owner_condition)
def current_time_seconds(self):
"""Current time in milliseconds."""
return int(round(time.time()))
def millisec_to_sec(self, millisec):
"""Convert milliseconds to seconds"""
return millisec / 1000
def __check_for_messages(self):
"""Wait for the polling interval, then do the real message check."""
# Wait for at least poll_interval sec
polling_interval = self.conf.messaging_server.polling_interval
time.sleep(polling_interval)
if self.conf.messaging_server.debug:
LOG.debug("Topic {}: Checking for new messages".format(
self.target.topic))
self._do()
return True
# FIXME(jdandrea): Better name for this, please, kthx.
def _do(self | self._flush_enqueued() | conditional_block |
component.py | .'),
]
CONF.register_opts(MESSAGING_SERVER_OPTS, group='messaging_server')
# Some class/method descriptions taken from this Oslo Messaging
# RPC API Tutorial/Demo: https://www.youtube.com/watch?v=Bf4gkeoBzvA
RPCSVRNAME = "Music-RPC Server"
class Target(object):
"""Returns a messaging target.
A target encapsulates all the information to identify where a message
should be sent or what messages a server is listening for.
"""
_topic = None
_topic_class = None
def | (self, topic):
"""Set the topic and topic class"""
self._topic = topic
# Because this is Music-specific, the server is
# built-in to the API class, stored as the transport.
# Thus, unlike oslo.messaging, there is no server
# specified for a target. There also isn't an
# exchange, namespace, or version at the moment.
# Dynamically create a message class for this topic.
self._topic_class = base.create_dynamic_model(
keyspace=CONF.messaging_server.keyspace,
baseclass=message.Message, classname=self.topic)
if not self._topic_class:
raise RuntimeError("Error setting the topic class for the messaging layer.")
@property
def topic(self):
"""Topic Property"""
return self._topic
@property
def topic_class(self):
"""Topic Class Property"""
return self._topic_class
class RPCClient(object):
"""Returns an RPC client using Music as a transport.
The RPC client is responsible for sending method invocations
to remote servers via a messaging transport.
A method invocation consists of a request context dictionary
a method name, and a dictionary of arguments. A cast() invocation
just sends the request and returns immediately. A call() invocation
waits for the server to send a return value.
"""
def __init__(self, conf, transport, target):
"""Set the transport and target"""
self.conf = conf
self.transport = transport
self.target = target
self.RPC = self.target.topic_class
# introduced as a quick means to cache messages
# with the aim of preventing unnecessary communication
# across conductor components.
# self.message_cache = dict()
def __check_rpc_status(self, rpc_id, rpc_method):
"""Check status for a given message id"""
# Wait check_interval seconds before proceeding
check_interval = self.conf.messaging_server.check_interval
time.sleep(check_interval)
if self.conf.messaging_server.debug:
LOG.debug("Checking status for message {} method {} on "
"topic {}".format(rpc_id, rpc_method, self.target.topic))
rpc = self.RPC.query.one(rpc_id)
return rpc
def cast(self, ctxt, method, args):
"""Asynchronous Call"""
rpc = self.RPC(action=self.RPC.CAST,
ctxt=ctxt, method=method, args=args)
assert (rpc.enqueued)
rpc_id = rpc.id
topic = self.target.topic
LOG.info(
_LI("Message {} on topic {} enqueued").format(rpc_id, topic))
if self.conf.messaging_server.debug:
LOG.debug("Casting method {} with args {}".format(method, args))
return rpc_id
def call(self, ctxt, method, args):
"""Synchronous Call"""
# # check if the call has a message saved in cache
# # key: string concatenation of ctxt + method + args
# # value: rpc response object
# key = ""
# for k, v in ctxt.items():
# key += str(k)
# key += '#' + str(v) + '#'
# key += '|' + str(method) + '|'
# for k, v in args.items():
# key += str(k)
# key += '#' + str(v) + '#'
#
# # check if the method has been called before
# # and cached
# if key in self.message_cache:
# LOG.debug("Retrieved method {} with args "
# "{} from cache".format(method, args))
# return self.message_cache[key]
rpc_start_time = time.time()
rpc = self.RPC(action=self.RPC.CALL,
ctxt=ctxt, method=method, args=args)
# TODO(jdandrea): Do something if the assert fails.
assert (rpc.enqueued)
rpc_id = rpc.id
topic = self.target.topic
LOG.info(
_LI("Message {} on topic {} enqueued.").format(rpc_id, topic))
if self.conf.messaging_server.debug:
LOG.debug("Calling method {} with args {}".format(method, args))
# Check message status within a thread
executor = futurist.ThreadPoolExecutor()
started_at = time.time()
while (time.time() - started_at) <= self.conf.messaging_server.response_timeout:
fut = executor.submit(self.__check_rpc_status, rpc_id, method)
rpc = fut.result()
if rpc and rpc.finished:
if self.conf.messaging_server.debug:
LOG.debug("Message {} method {} response received".
format(rpc_id, method))
break
executor.shutdown()
# Get response, delete message, and return response
if not rpc or not rpc.finished:
LOG.error(_LE("Message {} on topic {} timed out at {} seconds").
format(rpc_id, topic,
self.conf.messaging_server.response_timeout))
elif not rpc.ok:
LOG.error(_LE("Message {} on topic {} returned an error").
format(rpc_id, topic))
response = rpc.response
failure = rpc.failure
rpc.delete() # TODO(jdandrea): Put a TTL on the msg instead?
# self.message_cache[key] = response
LOG.debug("Elapsed time: {0:.3f} sec".format(
time.time() - rpc_start_time)
)
# If there's a failure, raise it as an exception
allowed = []
if failure is not None and failure != '':
# TODO(jdandrea): Do we need to populate allowed(_remote_exmods)?
raise rpc_common.deserialize_remote_exception(failure, allowed)
return response
class RPCService(cotyledon.Service):
"""Listener for the RPC service.
An RPC Service exposes a number of endpoints, each of which contain
a set of methods which may be invoked remotely by clients over a
given transport. To create an RPC server, you supply a transport,
target, and a list of endpoints.
Start the server with server.run()
"""
# This will appear in 'ps xaf'
name = RPCSVRNAME
def __init__(self, worker_id, conf, **kwargs):
"""Initializer"""
super(RPCService, self).__init__(worker_id)
if conf.messaging_server.debug:
LOG.debug("%s" % self.__class__.__name__)
self._init(conf, **kwargs)
self.running = True
def _init(self, conf, **kwargs):
"""Prepare to process requests"""
self.conf = conf
self.rpc_listener = None
self.transport = kwargs.pop('transport')
self.target = kwargs.pop('target')
self.endpoints = kwargs.pop('endpoints')
self.flush = kwargs.pop('flush')
self.kwargs = kwargs
self.RPC = self.target.topic_class
self.name = "{}, topic({})".format(RPCSVRNAME, self.target.topic)
self.messaging_owner_condition = {
"owner": socket.gethostname()
}
self.enqueued_status_condition = {
"status": message.Message.ENQUEUED
}
self.working_status_condition = {
"status": message.Message.WORKING
}
if self.flush:
self._flush_enqueued()
def _flush_enqueued(self):
"""Flush all messages with an enqueued status.
Use this only when the parent service is not running concurrently.
"""
msgs = self.RPC.query.all()
for msg in msgs:
if msg.enqueued:
if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))
elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.args['plan_name']))
msg.delete()
def _log_error_and_update_msg(self, msg, error_msg):
LOG.error(error_msg)
msg.response = {
'error': {
'message': error_msg
}
}
msg.status = message.Message.ERROR
msg.update(condition=self.messaging_owner_condition)
def current_time_seconds(self):
"""Current time in milliseconds."""
return int(round(time.time()))
def millisec_to_sec(self, millisec):
"""Convert milliseconds to seconds"""
return millisec / 1000
def __check_for_messages(self):
"""Wait for the polling interval, then do the real message check."""
# Wait for at least poll_interval sec
polling_interval = self.conf.messaging_server.polling_interval
time.sleep(polling_interval)
if self.conf.messaging_server.debug:
LOG.debug("Topic {}: Checking for new messages".format(
self.target.topic))
self._do()
return True
# FIXME(jdandrea): Better name for this, please, kthx.
def _do(self | __init__ | identifier_name |
component.py | out at {} seconds").
format(rpc_id, topic,
self.conf.messaging_server.response_timeout))
elif not rpc.ok:
LOG.error(_LE("Message {} on topic {} returned an error").
format(rpc_id, topic))
response = rpc.response
failure = rpc.failure
rpc.delete() # TODO(jdandrea): Put a TTL on the msg instead?
# self.message_cache[key] = response
LOG.debug("Elapsed time: {0:.3f} sec".format(
time.time() - rpc_start_time)
)
# If there's a failure, raise it as an exception
allowed = []
if failure is not None and failure != '':
# TODO(jdandrea): Do we need to populate allowed(_remote_exmods)?
raise rpc_common.deserialize_remote_exception(failure, allowed)
return response
class RPCService(cotyledon.Service):
"""Listener for the RPC service.
An RPC Service exposes a number of endpoints, each of which contain
a set of methods which may be invoked remotely by clients over a
given transport. To create an RPC server, you supply a transport,
target, and a list of endpoints.
Start the server with server.run()
"""
# This will appear in 'ps xaf'
name = RPCSVRNAME
def __init__(self, worker_id, conf, **kwargs):
"""Initializer"""
super(RPCService, self).__init__(worker_id)
if conf.messaging_server.debug:
LOG.debug("%s" % self.__class__.__name__)
self._init(conf, **kwargs)
self.running = True
def _init(self, conf, **kwargs):
"""Prepare to process requests"""
self.conf = conf
self.rpc_listener = None
self.transport = kwargs.pop('transport')
self.target = kwargs.pop('target')
self.endpoints = kwargs.pop('endpoints')
self.flush = kwargs.pop('flush')
self.kwargs = kwargs
self.RPC = self.target.topic_class
self.name = "{}, topic({})".format(RPCSVRNAME, self.target.topic)
self.messaging_owner_condition = {
"owner": socket.gethostname()
}
self.enqueued_status_condition = {
"status": message.Message.ENQUEUED
}
self.working_status_condition = {
"status": message.Message.WORKING
}
if self.flush:
self._flush_enqueued()
def _flush_enqueued(self):
"""Flush all messages with an enqueued status.
Use this only when the parent service is not running concurrently.
"""
msgs = self.RPC.query.all()
for msg in msgs:
if msg.enqueued:
if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))
elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.args['plan_name']))
msg.delete()
def _log_error_and_update_msg(self, msg, error_msg):
LOG.error(error_msg)
msg.response = {
'error': {
'message': error_msg
}
}
msg.status = message.Message.ERROR
msg.update(condition=self.messaging_owner_condition)
def current_time_seconds(self):
"""Current time in milliseconds."""
return int(round(time.time()))
def millisec_to_sec(self, millisec):
"""Convert milliseconds to seconds"""
return millisec / 1000
def __check_for_messages(self):
"""Wait for the polling interval, then do the real message check."""
# Wait for at least poll_interval sec
polling_interval = self.conf.messaging_server.polling_interval
time.sleep(polling_interval)
if self.conf.messaging_server.debug:
LOG.debug("Topic {}: Checking for new messages".format(
self.target.topic))
self._do()
return True
# FIXME(jdandrea): Better name for this, please, kthx.
def _do(self):
"""Look for a new RPC call and serve it"""
# Get all the messages in queue
msgs = self.RPC.query.all()
for msg in msgs:
# Find the first msg marked as enqueued.
if msg.working and \
(self.current_time_seconds() - self.millisec_to_sec(msg.updated)) \
> self.conf.messaging_server.response_timeout:
msg.status = message.Message.ENQUEUED
msg.update(condition=self.working_status_condition)
if not msg.enqueued:
continue
if 'plan_name' in list(msg.ctxt.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.ctxt['plan_name']))
elif 'plan_name' in list(msg.args.keys()): # Python 3 Conversion -- dict object to list object
LOG.info('Plan name: {}'.format(msg.args['plan_name']))
# Change the status to WORKING (operation with a lock)
msg.status = message.Message.WORKING
msg.owner = socket.gethostname()
# All update should have a condition (status == enqueued)
_is_updated = msg.update(condition=self.enqueued_status_condition)
if not _is_updated or 'FAILURE' in _is_updated:
continue
# RPC methods must not start/end with an underscore.
if msg.method.startswith('_') or msg.method.endswith('_'):
error_msg = _LE("Method {} must not start or end"
"with underscores").format(msg.method)
self._log_error_and_update_msg(msg, error_msg)
return
# The first endpoint that supports the method wins.
method = None
for endpoint in self.endpoints:
if msg.method not in dir(endpoint):
continue
endpoint_method = getattr(endpoint, msg.method)
if callable(endpoint_method):
method = endpoint_method
if self.conf.messaging_server.debug:
LOG.debug("Message {} method {} is "
"handled by endpoint {}".
format(msg.id, msg.method,
method.__str__.__name__))
break
if not method:
error_msg = _LE("Message {} method {} unsupported "
"in endpoints.").format(msg.id, msg.method)
self._log_error_and_update_msg(msg, error_msg)
return
# All methods must take a ctxt and args param.
if inspect.getfullargspec(method).args != ['self', 'ctx', 'arg']:
error_msg = _LE("Method {} must take three args: "
"self, ctx, arg").format(msg.method)
self._log_error_and_update_msg(msg, error_msg)
return
LOG.info(_LI("Message {} method {} received").format(
msg.id, msg.method))
if self.conf.messaging_server.debug:
LOG.debug(
_LI("Message {} method {} context: {}, args: {}").format(
msg.id, msg.method, msg.ctxt, msg.args))
failure = None
try:
# Add the template to conductor.plan table
# Methods return an opaque dictionary
result = method(msg.ctxt, msg.args)
# FIXME(jdandrea): Remove response/error and make it opaque.
# That means this would just be assigned result outright.
msg.response = result.get('response', result)
except Exception:
# Current sys.exc_info() content can be overridden
# by another exception raised by a log handler during
# LOG.exception(). So keep a copy and delete it later.
failure = sys.exc_info()
# Do not log details about the failure here. It will
# be returned later upstream.
LOG.exception(_LE('Exception during message handling'))
try:
if failure is None:
msg.status = message.Message.COMPLETED
else:
msg.failure = \
rpc_common.serialize_remote_exception(failure)
msg.status = message.Message.ERROR
LOG.info(_LI("Message {} method {}, status: {}").format(
msg.id, msg.method, msg.status))
if self.conf.messaging_server.debug:
LOG.debug("Message {} method {}, response: {}".format(
msg.id, msg.method, msg.response))
_is_success = 'FAILURE'
while 'FAILURE' in _is_success and (self.current_time_seconds() - self.millisec_to_sec(msg.updated)) \
<= self.conf.messaging_server.response_timeout:
_is_success = msg.update()
LOG.info(_LI("updating the message status from working to {}, "
"atomic update response from MUSIC {}").format(msg.status, _is_success))
except Exception:
LOG.exception(_LE("Can not send reply for message {} "
"method {}").
format(msg.id, msg.method))
finally:
# Remove circular object reference between the current
# stack frame and the traceback in exc_info.
del failure
def _gracefully_stop(self):
"""Gracefully stop working on things"""
pass
def _restart(self):
"""Prepare to restart the RPC Server"""
pass
def run(self):
| """Run"""
# The server listens for messages and calls the
# appropriate methods. It also deletes messages once
# processed.
if self.conf.messaging_server.debug:
LOG.debug("%s" % self.__class__.__name__)
# Listen for messages within a thread
executor = futurist.ThreadPoolExecutor()
while self.running:
fut = executor.submit(self.__check_for_messages)
fut.result()
executor.shutdown() | identifier_body | |
mod.rs | world.get_resource::<RenderResources>().unwrap();
let vertex_shader = Shader::from_glsl(ShaderStage::Vertex, include_str!("pbr.vert"))
.get_spirv_shader(None)
.unwrap();
let fragment_shader = Shader::from_glsl(ShaderStage::Fragment, include_str!("pbr.frag"))
.get_spirv_shader(None)
.unwrap();
let vertex_layout = vertex_shader.reflect_layout(&Default::default()).unwrap();
let fragment_layout = fragment_shader.reflect_layout(&Default::default()).unwrap();
let mut pipeline_layout =
PipelineLayout::from_shader_layouts(&mut [vertex_layout, fragment_layout]);
let vertex = render_resources.create_shader_module(&vertex_shader);
let fragment = render_resources.create_shader_module(&fragment_shader);
pipeline_layout.vertex_buffer_descriptors = vec![VertexBufferLayout {
stride: 32,
name: "Vertex".into(),
step_mode: InputStepMode::Vertex,
attributes: vec![
// GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically)
VertexAttribute {
name: "Vertex_Position".into(),
format: VertexFormat::Float32x3,
offset: 12,
shader_location: 0,
},
VertexAttribute {
name: "Vertex_Normals".into(),
format: VertexFormat::Float32x3,
offset: 0,
shader_location: 1,
},
VertexAttribute {
name: "Vertex_Uv".into(),
format: VertexFormat::Float32x2,
offset: 24,
shader_location: 2,
},
],
}];
pipeline_layout.bind_group_mut(0).bindings[0].set_dynamic(true);
pipeline_layout.bind_group_mut(0).bindings[1].set_dynamic(true);
if let BindType::Texture { sample_type, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[2].bind_type
{
*sample_type = TextureSampleType::Depth;
}
if let BindType::Sampler { comparison, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[3].bind_type
{
*comparison = true;
}
pipeline_layout.bind_group_mut(1).bindings[0].set_dynamic(true);
pipeline_layout.update_bind_group_ids();
let pipeline_descriptor = RenderPipelineDescriptor {
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: CompareFunction::Less,
stencil: StencilState {
front: StencilFaceState::IGNORE,
back: StencilFaceState::IGNORE,
read_mask: 0,
write_mask: 0,
},
bias: DepthBiasState {
constant: 0,
slope_scale: 0.0,
clamp: 0.0,
},
}),
color_target_states: vec![ColorTargetState {
format: TextureFormat::default(),
blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add,
},
alpha: BlendComponent {
src_factor: BlendFactor::One,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
}),
write_mask: ColorWrite::ALL,
}],
..RenderPipelineDescriptor::new(
ShaderStages {
vertex,
fragment: Some(fragment),
},
pipeline_layout,
)
};
let pipeline = render_resources.create_render_pipeline(&pipeline_descriptor);
PbrShaders {
pipeline,
pipeline_descriptor,
}
}
}
struct ExtractedMesh {
transform: Mat4,
vertex_buffer: BufferId,
index_info: Option<IndexInfo>,
transform_binding_offset: u32,
}
struct IndexInfo {
buffer: BufferId,
count: u32,
}
pub struct ExtractedMeshes {
meshes: Vec<ExtractedMesh>,
}
pub fn extract_meshes(
mut commands: Commands,
meshes: Res<Assets<Mesh>>,
_materials: Res<Assets<StandardMaterial>>,
query: Query<(&GlobalTransform, &Handle<Mesh>, &Handle<StandardMaterial>)>,
) {
let mut extracted_meshes = Vec::new();
for (transform, mesh_handle, _material_handle) in query.iter() {
if let Some(mesh) = meshes.get(mesh_handle) |
}
commands.insert_resource(ExtractedMeshes {
meshes: extracted_meshes,
});
}
#[derive(Default)]
pub struct MeshMeta {
transform_uniforms: DynamicUniformVec<Mat4>,
}
pub fn prepare_meshes(
render_resources: Res<RenderResources>,
mut mesh_meta: ResMut<MeshMeta>,
mut extracted_meshes: ResMut<ExtractedMeshes>,
) {
mesh_meta
.transform_uniforms
.reserve_and_clear(extracted_meshes.meshes.len(), &render_resources);
for extracted_mesh in extracted_meshes.meshes.iter_mut() {
extracted_mesh.transform_binding_offset =
mesh_meta.transform_uniforms.push(extracted_mesh.transform);
}
mesh_meta
.transform_uniforms
.write_to_staging_buffer(&render_resources);
}
// TODO: This is temporary. Once we expose BindGroupLayouts directly, we can create view bind groups without specific shader context
struct MeshViewBindGroups {
view_bind_group: BindGroupId,
mesh_transform_bind_group: BindGroupId,
}
pub fn queue_meshes(
mut commands: Commands,
draw_functions: Res<DrawFunctions>,
render_resources: Res<RenderResources>,
pbr_shaders: Res<PbrShaders>,
shadow_shaders: Res<ShadowShaders>,
mesh_meta: Res<MeshMeta>,
light_meta: Res<LightMeta>,
view_meta: Res<ViewMeta>,
extracted_meshes: Res<ExtractedMeshes>,
mut views: Query<(Entity, &ViewLights, &mut RenderPhase<Transparent3dPhase>)>,
mut view_light_shadow_phases: Query<&mut RenderPhase<ShadowPhase>>,
) {
if extracted_meshes.meshes.is_empty() {
return;
}
for (entity, view_lights, mut transparent_phase) in views.iter_mut() {
let layout = &pbr_shaders.pipeline_descriptor.layout;
let view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.add_binding(1, light_meta.view_gpu_lights.binding())
.add_binding(2, view_lights.light_depth_texture_view)
.add_binding(3, shadow_shaders.light_sampler)
.finish();
// TODO: this will only create the bind group if it isn't already created. this is a bit nasty
render_resources.create_bind_group(layout.bind_group(0).id, &view_bind_group);
let mesh_transform_bind_group = BindGroupBuilder::default()
.add_binding(0, mesh_meta.transform_uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(1).id, &mesh_transform_bind_group);
commands.entity(entity).insert(MeshViewBindGroups {
view_bind_group: view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
let draw_pbr = draw_functions.read().get_id::<DrawPbr>().unwrap();
for i in 0..extracted_meshes.meshes.len() {
// TODO: currently there is only "transparent phase". this should pick transparent vs opaque according to the mesh material
transparent_phase.add(Drawable {
draw_function: draw_pbr,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
});
}
// ultimately lights should check meshes for relevancy (ex: light views can "see" different meshes than the main view can)
let draw_shadow_mesh = draw_functions.read().get_id::<DrawShadowMesh>().unwrap();
for view_light_entity in view_lights.lights.iter().copied() {
let mut shadow_phase = view_light_shadow_phases.get_mut(view_light_entity).unwrap();
let layout = &shadow_shaders.pipeline_descriptor.layout;
let shadow_view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(0).id, &shadow_view_bind_group);
// TODO: this should only queue up meshes that are actually visible by each "light view"
for i in 0..extracted_meshes.meshes.len() {
shadow_phase.add(Drawable {
draw_function: draw_shadow_mesh,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
})
}
commands
.entity(view_light_entity)
.insert(MeshViewBindGroups {
view_bind_group: shadow_view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
}
}
}
// TODO: this logic can be moved to prepare_mesh | {
if let Some(gpu_data) = &mesh.gpu_data() {
extracted_meshes.push(ExtractedMesh {
transform: transform.compute_matrix(),
vertex_buffer: gpu_data.vertex_buffer,
index_info: gpu_data.index_buffer.map(|i| IndexInfo {
buffer: i,
count: mesh.indices().unwrap().len() as u32,
}),
transform_binding_offset: 0,
})
}
} | conditional_block |
mod.rs | Float32x3,
offset: 12,
shader_location: 0,
},
VertexAttribute {
name: "Vertex_Normals".into(),
format: VertexFormat::Float32x3,
offset: 0,
shader_location: 1,
},
VertexAttribute {
name: "Vertex_Uv".into(),
format: VertexFormat::Float32x2,
offset: 24,
shader_location: 2,
},
],
}];
pipeline_layout.bind_group_mut(0).bindings[0].set_dynamic(true);
pipeline_layout.bind_group_mut(0).bindings[1].set_dynamic(true);
if let BindType::Texture { sample_type, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[2].bind_type
{
*sample_type = TextureSampleType::Depth;
}
if let BindType::Sampler { comparison, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[3].bind_type
{
*comparison = true;
}
pipeline_layout.bind_group_mut(1).bindings[0].set_dynamic(true);
pipeline_layout.update_bind_group_ids();
let pipeline_descriptor = RenderPipelineDescriptor {
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: CompareFunction::Less,
stencil: StencilState {
front: StencilFaceState::IGNORE,
back: StencilFaceState::IGNORE,
read_mask: 0,
write_mask: 0,
},
bias: DepthBiasState {
constant: 0,
slope_scale: 0.0,
clamp: 0.0,
},
}),
color_target_states: vec![ColorTargetState {
format: TextureFormat::default(),
blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add,
},
alpha: BlendComponent {
src_factor: BlendFactor::One,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
}),
write_mask: ColorWrite::ALL,
}],
..RenderPipelineDescriptor::new(
ShaderStages {
vertex,
fragment: Some(fragment),
},
pipeline_layout,
)
};
let pipeline = render_resources.create_render_pipeline(&pipeline_descriptor);
PbrShaders {
pipeline,
pipeline_descriptor,
}
}
}
struct ExtractedMesh {
transform: Mat4,
vertex_buffer: BufferId,
index_info: Option<IndexInfo>,
transform_binding_offset: u32,
}
struct IndexInfo {
buffer: BufferId,
count: u32,
}
pub struct ExtractedMeshes {
meshes: Vec<ExtractedMesh>,
}
pub fn extract_meshes(
mut commands: Commands,
meshes: Res<Assets<Mesh>>,
_materials: Res<Assets<StandardMaterial>>,
query: Query<(&GlobalTransform, &Handle<Mesh>, &Handle<StandardMaterial>)>,
) {
let mut extracted_meshes = Vec::new();
for (transform, mesh_handle, _material_handle) in query.iter() {
if let Some(mesh) = meshes.get(mesh_handle) {
if let Some(gpu_data) = &mesh.gpu_data() {
extracted_meshes.push(ExtractedMesh {
transform: transform.compute_matrix(),
vertex_buffer: gpu_data.vertex_buffer,
index_info: gpu_data.index_buffer.map(|i| IndexInfo {
buffer: i,
count: mesh.indices().unwrap().len() as u32,
}),
transform_binding_offset: 0,
})
}
}
}
commands.insert_resource(ExtractedMeshes {
meshes: extracted_meshes,
});
}
#[derive(Default)]
pub struct MeshMeta {
transform_uniforms: DynamicUniformVec<Mat4>,
}
pub fn prepare_meshes(
render_resources: Res<RenderResources>,
mut mesh_meta: ResMut<MeshMeta>,
mut extracted_meshes: ResMut<ExtractedMeshes>,
) {
mesh_meta
.transform_uniforms
.reserve_and_clear(extracted_meshes.meshes.len(), &render_resources);
for extracted_mesh in extracted_meshes.meshes.iter_mut() {
extracted_mesh.transform_binding_offset =
mesh_meta.transform_uniforms.push(extracted_mesh.transform);
}
mesh_meta
.transform_uniforms
.write_to_staging_buffer(&render_resources);
}
// TODO: This is temporary. Once we expose BindGroupLayouts directly, we can create view bind groups without specific shader context
struct MeshViewBindGroups {
view_bind_group: BindGroupId,
mesh_transform_bind_group: BindGroupId,
}
pub fn queue_meshes(
mut commands: Commands,
draw_functions: Res<DrawFunctions>,
render_resources: Res<RenderResources>,
pbr_shaders: Res<PbrShaders>,
shadow_shaders: Res<ShadowShaders>,
mesh_meta: Res<MeshMeta>,
light_meta: Res<LightMeta>,
view_meta: Res<ViewMeta>,
extracted_meshes: Res<ExtractedMeshes>,
mut views: Query<(Entity, &ViewLights, &mut RenderPhase<Transparent3dPhase>)>,
mut view_light_shadow_phases: Query<&mut RenderPhase<ShadowPhase>>,
) {
if extracted_meshes.meshes.is_empty() {
return;
}
for (entity, view_lights, mut transparent_phase) in views.iter_mut() {
let layout = &pbr_shaders.pipeline_descriptor.layout;
let view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.add_binding(1, light_meta.view_gpu_lights.binding())
.add_binding(2, view_lights.light_depth_texture_view)
.add_binding(3, shadow_shaders.light_sampler)
.finish();
// TODO: this will only create the bind group if it isn't already created. this is a bit nasty
render_resources.create_bind_group(layout.bind_group(0).id, &view_bind_group);
let mesh_transform_bind_group = BindGroupBuilder::default()
.add_binding(0, mesh_meta.transform_uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(1).id, &mesh_transform_bind_group);
commands.entity(entity).insert(MeshViewBindGroups {
view_bind_group: view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
let draw_pbr = draw_functions.read().get_id::<DrawPbr>().unwrap();
for i in 0..extracted_meshes.meshes.len() {
// TODO: currently there is only "transparent phase". this should pick transparent vs opaque according to the mesh material
transparent_phase.add(Drawable {
draw_function: draw_pbr,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
});
}
// ultimately lights should check meshes for relevancy (ex: light views can "see" different meshes than the main view can)
let draw_shadow_mesh = draw_functions.read().get_id::<DrawShadowMesh>().unwrap();
for view_light_entity in view_lights.lights.iter().copied() {
let mut shadow_phase = view_light_shadow_phases.get_mut(view_light_entity).unwrap();
let layout = &shadow_shaders.pipeline_descriptor.layout;
let shadow_view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(0).id, &shadow_view_bind_group);
// TODO: this should only queue up meshes that are actually visible by each "light view"
for i in 0..extracted_meshes.meshes.len() {
shadow_phase.add(Drawable {
draw_function: draw_shadow_mesh,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
})
}
commands
.entity(view_light_entity)
.insert(MeshViewBindGroups {
view_bind_group: shadow_view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
}
}
}
// TODO: this logic can be moved to prepare_meshes once wgpu::Queue is exposed directly
pub struct PbrNode;
impl Node for PbrNode {
fn run(
&self,
_graph: &mut RenderGraphContext,
render_context: &mut dyn RenderContext,
world: &World,
) -> Result<(), NodeRunError> {
let mesh_meta = world.get_resource::<MeshMeta>().unwrap();
let light_meta = world.get_resource::<LightMeta>().unwrap();
mesh_meta
.transform_uniforms
.write_to_uniform_buffer(render_context);
light_meta
.view_gpu_lights
.write_to_uniform_buffer(render_context);
Ok(())
}
}
type DrawPbrParams<'a> = (
Res<'a, PbrShaders>,
Res<'a, ExtractedMeshes>,
Query<'a, (&'a ViewUniform, &'a MeshViewBindGroups, &'a ViewLights)>,
);
pub struct DrawPbr {
params: SystemState<DrawPbrParams<'static>>,
}
impl DrawPbr {
pub fn new(world: &mut World) -> Self | {
Self {
params: SystemState::new(world),
}
} | identifier_body | |
mod.rs | br.vert"))
.get_spirv_shader(None)
.unwrap();
let fragment_shader = Shader::from_glsl(ShaderStage::Fragment, include_str!("pbr.frag"))
.get_spirv_shader(None)
.unwrap();
let vertex_layout = vertex_shader.reflect_layout(&Default::default()).unwrap();
let fragment_layout = fragment_shader.reflect_layout(&Default::default()).unwrap();
let mut pipeline_layout =
PipelineLayout::from_shader_layouts(&mut [vertex_layout, fragment_layout]);
let vertex = render_resources.create_shader_module(&vertex_shader);
let fragment = render_resources.create_shader_module(&fragment_shader);
pipeline_layout.vertex_buffer_descriptors = vec![VertexBufferLayout {
stride: 32,
name: "Vertex".into(),
step_mode: InputStepMode::Vertex,
attributes: vec![
// GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically)
VertexAttribute {
name: "Vertex_Position".into(),
format: VertexFormat::Float32x3,
offset: 12,
shader_location: 0,
},
VertexAttribute {
name: "Vertex_Normals".into(),
format: VertexFormat::Float32x3,
offset: 0,
shader_location: 1,
},
VertexAttribute {
name: "Vertex_Uv".into(),
format: VertexFormat::Float32x2,
offset: 24,
shader_location: 2,
},
],
}];
pipeline_layout.bind_group_mut(0).bindings[0].set_dynamic(true);
pipeline_layout.bind_group_mut(0).bindings[1].set_dynamic(true);
if let BindType::Texture { sample_type, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[2].bind_type
{
*sample_type = TextureSampleType::Depth;
}
if let BindType::Sampler { comparison, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[3].bind_type
{
*comparison = true;
}
pipeline_layout.bind_group_mut(1).bindings[0].set_dynamic(true);
pipeline_layout.update_bind_group_ids();
let pipeline_descriptor = RenderPipelineDescriptor {
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: CompareFunction::Less,
stencil: StencilState {
front: StencilFaceState::IGNORE,
back: StencilFaceState::IGNORE,
read_mask: 0,
write_mask: 0,
},
bias: DepthBiasState {
constant: 0,
slope_scale: 0.0,
clamp: 0.0,
},
}),
color_target_states: vec![ColorTargetState {
format: TextureFormat::default(),
blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add,
},
alpha: BlendComponent {
src_factor: BlendFactor::One,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
}),
write_mask: ColorWrite::ALL,
}],
..RenderPipelineDescriptor::new(
ShaderStages {
vertex,
fragment: Some(fragment),
},
pipeline_layout,
)
};
let pipeline = render_resources.create_render_pipeline(&pipeline_descriptor);
PbrShaders {
pipeline,
pipeline_descriptor,
}
}
}
struct ExtractedMesh {
transform: Mat4,
vertex_buffer: BufferId,
index_info: Option<IndexInfo>,
transform_binding_offset: u32,
}
struct IndexInfo {
buffer: BufferId,
count: u32,
}
pub struct ExtractedMeshes {
meshes: Vec<ExtractedMesh>,
}
pub fn extract_meshes(
mut commands: Commands,
meshes: Res<Assets<Mesh>>,
_materials: Res<Assets<StandardMaterial>>,
query: Query<(&GlobalTransform, &Handle<Mesh>, &Handle<StandardMaterial>)>,
) {
let mut extracted_meshes = Vec::new();
for (transform, mesh_handle, _material_handle) in query.iter() {
if let Some(mesh) = meshes.get(mesh_handle) {
if let Some(gpu_data) = &mesh.gpu_data() {
extracted_meshes.push(ExtractedMesh {
transform: transform.compute_matrix(),
vertex_buffer: gpu_data.vertex_buffer,
index_info: gpu_data.index_buffer.map(|i| IndexInfo {
buffer: i,
count: mesh.indices().unwrap().len() as u32,
}),
transform_binding_offset: 0,
})
}
}
}
commands.insert_resource(ExtractedMeshes {
meshes: extracted_meshes,
});
}
#[derive(Default)]
pub struct MeshMeta {
transform_uniforms: DynamicUniformVec<Mat4>,
}
pub fn prepare_meshes(
render_resources: Res<RenderResources>,
mut mesh_meta: ResMut<MeshMeta>,
mut extracted_meshes: ResMut<ExtractedMeshes>,
) {
mesh_meta
.transform_uniforms
.reserve_and_clear(extracted_meshes.meshes.len(), &render_resources);
for extracted_mesh in extracted_meshes.meshes.iter_mut() {
extracted_mesh.transform_binding_offset =
mesh_meta.transform_uniforms.push(extracted_mesh.transform);
}
mesh_meta
.transform_uniforms
.write_to_staging_buffer(&render_resources);
}
// TODO: This is temporary. Once we expose BindGroupLayouts directly, we can create view bind groups without specific shader context
struct MeshViewBindGroups {
view_bind_group: BindGroupId,
mesh_transform_bind_group: BindGroupId,
}
pub fn queue_meshes(
mut commands: Commands,
draw_functions: Res<DrawFunctions>,
render_resources: Res<RenderResources>,
pbr_shaders: Res<PbrShaders>,
shadow_shaders: Res<ShadowShaders>,
mesh_meta: Res<MeshMeta>,
light_meta: Res<LightMeta>,
view_meta: Res<ViewMeta>,
extracted_meshes: Res<ExtractedMeshes>,
mut views: Query<(Entity, &ViewLights, &mut RenderPhase<Transparent3dPhase>)>,
mut view_light_shadow_phases: Query<&mut RenderPhase<ShadowPhase>>,
) {
if extracted_meshes.meshes.is_empty() {
return;
}
for (entity, view_lights, mut transparent_phase) in views.iter_mut() {
let layout = &pbr_shaders.pipeline_descriptor.layout;
let view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.add_binding(1, light_meta.view_gpu_lights.binding())
.add_binding(2, view_lights.light_depth_texture_view)
.add_binding(3, shadow_shaders.light_sampler)
.finish();
// TODO: this will only create the bind group if it isn't already created. this is a bit nasty
render_resources.create_bind_group(layout.bind_group(0).id, &view_bind_group);
let mesh_transform_bind_group = BindGroupBuilder::default()
.add_binding(0, mesh_meta.transform_uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(1).id, &mesh_transform_bind_group);
commands.entity(entity).insert(MeshViewBindGroups {
view_bind_group: view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
let draw_pbr = draw_functions.read().get_id::<DrawPbr>().unwrap();
for i in 0..extracted_meshes.meshes.len() {
// TODO: currently there is only "transparent phase". this should pick transparent vs opaque according to the mesh material
transparent_phase.add(Drawable {
draw_function: draw_pbr,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
});
}
// ultimately lights should check meshes for relevancy (ex: light views can "see" different meshes than the main view can)
let draw_shadow_mesh = draw_functions.read().get_id::<DrawShadowMesh>().unwrap();
for view_light_entity in view_lights.lights.iter().copied() {
let mut shadow_phase = view_light_shadow_phases.get_mut(view_light_entity).unwrap();
let layout = &shadow_shaders.pipeline_descriptor.layout;
let shadow_view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(0).id, &shadow_view_bind_group);
// TODO: this should only queue up meshes that are actually visible by each "light view"
for i in 0..extracted_meshes.meshes.len() {
shadow_phase.add(Drawable {
draw_function: draw_shadow_mesh,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
})
}
commands
.entity(view_light_entity)
.insert(MeshViewBindGroups {
view_bind_group: shadow_view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
}
}
}
// TODO: this logic can be moved to prepare_meshes once wgpu::Queue is exposed directly
pub struct PbrNode;
impl Node for PbrNode { | fn run(
&self, | random_line_split | |
mod.rs | include_str!("pbr.vert"))
.get_spirv_shader(None)
.unwrap();
let fragment_shader = Shader::from_glsl(ShaderStage::Fragment, include_str!("pbr.frag"))
.get_spirv_shader(None)
.unwrap();
let vertex_layout = vertex_shader.reflect_layout(&Default::default()).unwrap();
let fragment_layout = fragment_shader.reflect_layout(&Default::default()).unwrap();
let mut pipeline_layout =
PipelineLayout::from_shader_layouts(&mut [vertex_layout, fragment_layout]);
let vertex = render_resources.create_shader_module(&vertex_shader);
let fragment = render_resources.create_shader_module(&fragment_shader);
pipeline_layout.vertex_buffer_descriptors = vec![VertexBufferLayout {
stride: 32,
name: "Vertex".into(),
step_mode: InputStepMode::Vertex,
attributes: vec![
// GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically)
VertexAttribute {
name: "Vertex_Position".into(),
format: VertexFormat::Float32x3,
offset: 12,
shader_location: 0,
},
VertexAttribute {
name: "Vertex_Normals".into(),
format: VertexFormat::Float32x3,
offset: 0,
shader_location: 1,
},
VertexAttribute {
name: "Vertex_Uv".into(),
format: VertexFormat::Float32x2,
offset: 24,
shader_location: 2,
},
],
}];
pipeline_layout.bind_group_mut(0).bindings[0].set_dynamic(true);
pipeline_layout.bind_group_mut(0).bindings[1].set_dynamic(true);
if let BindType::Texture { sample_type, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[2].bind_type
{
*sample_type = TextureSampleType::Depth;
}
if let BindType::Sampler { comparison, .. } =
&mut pipeline_layout.bind_group_mut(0).bindings[3].bind_type
{
*comparison = true;
}
pipeline_layout.bind_group_mut(1).bindings[0].set_dynamic(true);
pipeline_layout.update_bind_group_ids();
let pipeline_descriptor = RenderPipelineDescriptor {
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: CompareFunction::Less,
stencil: StencilState {
front: StencilFaceState::IGNORE,
back: StencilFaceState::IGNORE,
read_mask: 0,
write_mask: 0,
},
bias: DepthBiasState {
constant: 0,
slope_scale: 0.0,
clamp: 0.0,
},
}),
color_target_states: vec![ColorTargetState {
format: TextureFormat::default(),
blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add,
},
alpha: BlendComponent {
src_factor: BlendFactor::One,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
}),
write_mask: ColorWrite::ALL,
}],
..RenderPipelineDescriptor::new(
ShaderStages {
vertex,
fragment: Some(fragment),
},
pipeline_layout,
)
};
let pipeline = render_resources.create_render_pipeline(&pipeline_descriptor);
PbrShaders {
pipeline,
pipeline_descriptor,
}
}
}
struct ExtractedMesh {
transform: Mat4,
vertex_buffer: BufferId,
index_info: Option<IndexInfo>,
transform_binding_offset: u32,
}
struct IndexInfo {
buffer: BufferId,
count: u32,
}
pub struct ExtractedMeshes {
meshes: Vec<ExtractedMesh>,
}
pub fn extract_meshes(
mut commands: Commands,
meshes: Res<Assets<Mesh>>,
_materials: Res<Assets<StandardMaterial>>,
query: Query<(&GlobalTransform, &Handle<Mesh>, &Handle<StandardMaterial>)>,
) {
let mut extracted_meshes = Vec::new();
for (transform, mesh_handle, _material_handle) in query.iter() {
if let Some(mesh) = meshes.get(mesh_handle) {
if let Some(gpu_data) = &mesh.gpu_data() {
extracted_meshes.push(ExtractedMesh {
transform: transform.compute_matrix(),
vertex_buffer: gpu_data.vertex_buffer,
index_info: gpu_data.index_buffer.map(|i| IndexInfo {
buffer: i,
count: mesh.indices().unwrap().len() as u32,
}),
transform_binding_offset: 0,
})
}
}
}
commands.insert_resource(ExtractedMeshes {
meshes: extracted_meshes,
});
}
#[derive(Default)]
pub struct MeshMeta {
transform_uniforms: DynamicUniformVec<Mat4>,
}
pub fn prepare_meshes(
render_resources: Res<RenderResources>,
mut mesh_meta: ResMut<MeshMeta>,
mut extracted_meshes: ResMut<ExtractedMeshes>,
) {
mesh_meta
.transform_uniforms
.reserve_and_clear(extracted_meshes.meshes.len(), &render_resources);
for extracted_mesh in extracted_meshes.meshes.iter_mut() {
extracted_mesh.transform_binding_offset =
mesh_meta.transform_uniforms.push(extracted_mesh.transform);
}
mesh_meta
.transform_uniforms
.write_to_staging_buffer(&render_resources);
}
// TODO: This is temporary. Once we expose BindGroupLayouts directly, we can create view bind groups without specific shader context
struct MeshViewBindGroups {
view_bind_group: BindGroupId,
mesh_transform_bind_group: BindGroupId,
}
pub fn queue_meshes(
mut commands: Commands,
draw_functions: Res<DrawFunctions>,
render_resources: Res<RenderResources>,
pbr_shaders: Res<PbrShaders>,
shadow_shaders: Res<ShadowShaders>,
mesh_meta: Res<MeshMeta>,
light_meta: Res<LightMeta>,
view_meta: Res<ViewMeta>,
extracted_meshes: Res<ExtractedMeshes>,
mut views: Query<(Entity, &ViewLights, &mut RenderPhase<Transparent3dPhase>)>,
mut view_light_shadow_phases: Query<&mut RenderPhase<ShadowPhase>>,
) {
if extracted_meshes.meshes.is_empty() {
return;
}
for (entity, view_lights, mut transparent_phase) in views.iter_mut() {
let layout = &pbr_shaders.pipeline_descriptor.layout;
let view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.add_binding(1, light_meta.view_gpu_lights.binding())
.add_binding(2, view_lights.light_depth_texture_view)
.add_binding(3, shadow_shaders.light_sampler)
.finish();
// TODO: this will only create the bind group if it isn't already created. this is a bit nasty
render_resources.create_bind_group(layout.bind_group(0).id, &view_bind_group);
let mesh_transform_bind_group = BindGroupBuilder::default()
.add_binding(0, mesh_meta.transform_uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(1).id, &mesh_transform_bind_group);
commands.entity(entity).insert(MeshViewBindGroups {
view_bind_group: view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
let draw_pbr = draw_functions.read().get_id::<DrawPbr>().unwrap();
for i in 0..extracted_meshes.meshes.len() {
// TODO: currently there is only "transparent phase". this should pick transparent vs opaque according to the mesh material
transparent_phase.add(Drawable {
draw_function: draw_pbr,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
});
}
// ultimately lights should check meshes for relevancy (ex: light views can "see" different meshes than the main view can)
let draw_shadow_mesh = draw_functions.read().get_id::<DrawShadowMesh>().unwrap();
for view_light_entity in view_lights.lights.iter().copied() {
let mut shadow_phase = view_light_shadow_phases.get_mut(view_light_entity).unwrap();
let layout = &shadow_shaders.pipeline_descriptor.layout;
let shadow_view_bind_group = BindGroupBuilder::default()
.add_binding(0, view_meta.uniforms.binding())
.finish();
render_resources.create_bind_group(layout.bind_group(0).id, &shadow_view_bind_group);
// TODO: this should only queue up meshes that are actually visible by each "light view"
for i in 0..extracted_meshes.meshes.len() {
shadow_phase.add(Drawable {
draw_function: draw_shadow_mesh,
draw_key: i,
sort_key: 0, // TODO: sort back-to-front
})
}
commands
.entity(view_light_entity)
.insert(MeshViewBindGroups {
view_bind_group: shadow_view_bind_group.id,
mesh_transform_bind_group: mesh_transform_bind_group.id,
});
}
}
}
// TODO: this logic can be moved to prepare_meshes once wgpu::Queue is exposed directly
pub struct PbrNode;
impl Node for PbrNode {
fn | run | identifier_name | |
kafka_scaler.go | (config *ScalerConfig) (Scaler, error) {
metricType, err := GetMetricTargetType(config)
if err != nil {
return nil, fmt.Errorf("error getting scaler metric type: %w", err)
}
logger := InitializeLogger(config, "kafka_scaler")
kafkaMetadata, err := parseKafkaMetadata(config, logger)
if err != nil {
return nil, fmt.Errorf("error parsing kafka metadata: %w", err)
}
client, admin, err := getKafkaClients(kafkaMetadata)
if err != nil {
return nil, err
}
previousOffsets := make(map[string]map[int32]int64)
return &kafkaScaler{
client: client,
admin: admin,
metricType: metricType,
metadata: kafkaMetadata,
logger: logger,
previousOffsets: previousOffsets,
}, nil
}
func parseKafkaAuthParams(config *ScalerConfig, meta *kafkaMetadata) error {
meta.saslType = KafkaSASLTypeNone
var saslAuthType string
switch {
case config.TriggerMetadata["sasl"] != "":
saslAuthType = config.TriggerMetadata["sasl"]
default:
saslAuthType = ""
}
if val, ok := config.AuthParams["sasl"]; ok {
if saslAuthType != "" {
return errors.New("unable to set `sasl` in both ScaledObject and TriggerAuthentication together")
}
saslAuthType = val
}
if saslAuthType != "" {
saslAuthType = strings.TrimSpace(saslAuthType)
mode := kafkaSaslType(saslAuthType)
if mode == KafkaSASLTypePlaintext || mode == KafkaSASLTypeSCRAMSHA256 || mode == KafkaSASLTypeSCRAMSHA512 || mode == KafkaSASLTypeOAuthbearer {
if config.AuthParams["username"] == "" {
return errors.New("no username given")
}
meta.username = strings.TrimSpace(config.AuthParams["username"])
if config.AuthParams["password"] == "" {
return errors.New("no password given")
}
meta.password = strings.TrimSpace(config.AuthParams["password"])
meta.saslType = mode
if mode == KafkaSASLTypeOAuthbearer {
meta.scopes = strings.Split(config.AuthParams["scopes"], ",")
if config.AuthParams["oauthTokenEndpointUri"] == "" {
return errors.New("no oauth token endpoint uri given")
}
meta.oauthTokenEndpointURI = strings.TrimSpace(config.AuthParams["oauthTokenEndpointUri"])
meta.oauthExtensions = make(map[string]string)
oauthExtensionsRaw := config.AuthParams["oauthExtensions"]
if oauthExtensionsRaw != "" {
for _, extension := range strings.Split(oauthExtensionsRaw, ",") {
splittedExtension := strings.Split(extension, "=")
if len(splittedExtension) != 2 {
return errors.New("invalid OAuthBearer extension, must be of format key=value")
}
meta.oauthExtensions[splittedExtension[0]] = splittedExtension[1]
}
}
}
} else {
return fmt.Errorf("err SASL mode %s given", mode)
}
}
meta.enableTLS = false
enableTLS := false
if val, ok := config.TriggerMetadata["tls"]; ok {
switch val {
case stringEnable:
enableTLS = true
case stringDisable:
enableTLS = false
default:
return fmt.Errorf("error incorrect TLS value given, got %s", val)
}
}
if val, ok := config.AuthParams["tls"]; ok {
val = strings.TrimSpace(val)
if enableTLS {
return errors.New("unable to set `tls` in both ScaledObject and TriggerAuthentication together")
}
switch val {
case stringEnable:
enableTLS = true
case stringDisable:
enableTLS = false
default:
return fmt.Errorf("error incorrect TLS value given, got %s", val)
}
}
if enableTLS {
certGiven := config.AuthParams["cert"] != ""
keyGiven := config.AuthParams["key"] != ""
if certGiven && !keyGiven {
return errors.New("key must be provided with cert")
}
if keyGiven && !certGiven {
return errors.New("cert must be provided with key")
}
meta.ca = config.AuthParams["ca"]
meta.cert = config.AuthParams["cert"]
meta.key = config.AuthParams["key"]
if value, found := config.AuthParams["keyPassword"]; found {
meta.keyPassword = value
} else {
meta.keyPassword = ""
}
meta.enableTLS = true
}
return nil
}
func parseKafkaMetadata(config *ScalerConfig, logger logr.Logger) (kafkaMetadata, error) {
meta := kafkaMetadata{}
switch {
case config.TriggerMetadata["bootstrapServersFromEnv"] != "":
meta.bootstrapServers = strings.Split(config.ResolvedEnv[config.TriggerMetadata["bootstrapServersFromEnv"]], ",")
case config.TriggerMetadata["bootstrapServers"] != "":
meta.bootstrapServers = strings.Split(config.TriggerMetadata["bootstrapServers"], ",")
default:
return meta, errors.New("no bootstrapServers given")
}
switch {
case config.TriggerMetadata["consumerGroupFromEnv"] != "":
meta.group = config.ResolvedEnv[config.TriggerMetadata["consumerGroupFromEnv"]]
case config.TriggerMetadata["consumerGroup"] != "":
meta.group = config.TriggerMetadata["consumerGroup"]
default:
return meta, errors.New("no consumer group given")
}
switch {
case config.TriggerMetadata["topicFromEnv"] != "":
meta.topic = config.ResolvedEnv[config.TriggerMetadata["topicFromEnv"]]
case config.TriggerMetadata["topic"] != "":
meta.topic = config.TriggerMetadata["topic"]
default:
meta.topic = ""
logger.V(1).Info(fmt.Sprintf("consumer group %q has no topic specified, "+
"will use all topics subscribed by the consumer group for scaling", meta.group))
}
meta.partitionLimitation = nil
partitionLimitationMetadata := strings.TrimSpace(config.TriggerMetadata["partitionLimitation"])
if partitionLimitationMetadata != "" {
if meta.topic == "" {
logger.V(1).Info("no specific topic set, ignoring partitionLimitation setting")
} else {
pattern := config.TriggerMetadata["partitionLimitation"]
parsed, err := kedautil.ParseInt32List(pattern)
if err != nil {
return meta, fmt.Errorf("error parsing in partitionLimitation '%s': %w", pattern, err)
}
meta.partitionLimitation = parsed
logger.V(0).Info(fmt.Sprintf("partition limit active '%s'", pattern))
}
}
meta.offsetResetPolicy = defaultOffsetResetPolicy
if config.TriggerMetadata["offsetResetPolicy"] != "" {
policy := offsetResetPolicy(config.TriggerMetadata["offsetResetPolicy"])
if policy != earliest && policy != latest {
return meta, fmt.Errorf("err offsetResetPolicy policy %q given", policy)
}
meta.offsetResetPolicy = policy
}
meta.lagThreshold = defaultKafkaLagThreshold
if val, ok := config.TriggerMetadata[lagThresholdMetricName]; ok {
t, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return meta, fmt.Errorf("error parsing %q: %w", lagThresholdMetricName, err)
}
if t <= 0 {
return meta, fmt.Errorf("%q must be positive number", lagThresholdMetricName)
}
meta.lagThreshold = t
}
meta.activationLagThreshold = defaultKafkaActivationLagThreshold
if val, ok := config.TriggerMetadata[activationLagThresholdMetricName]; ok {
t, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return meta, fmt.Errorf("error parsing %q: %w", activationLagThresholdMetricName, err)
}
if t < 0 {
return meta, fmt.Errorf("%q must be positive number", activationLagThresholdMetricName)
}
meta.activationLagThreshold = t
}
if err := parseKafkaAuthParams(config, &meta); err != nil {
return meta, err
}
meta.allowIdleConsumers = false
if val, ok := config.TriggerMetadata["allowIdleConsumers"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing allowIdleConsumers: %w", err)
}
meta.allowIdleConsumers = t
}
meta.excludePersistentLag = false
if val, ok := config.TriggerMetadata["excludePersistentLag"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing excludePersistentLag: %w", err)
}
meta.excludePersistentLag = t
}
meta.scaleToZeroOnInvalidOffset = false
if val, ok := config.TriggerMetadata["scaleToZeroOnInvalidOffset"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing scaleToZeroOnInvalidOffset: %w", err)
| NewKafkaScaler | identifier_name | |
kafka_scaler.go | enableTLS = true
case stringDisable:
enableTLS = false
default:
return fmt.Errorf("error incorrect TLS value given, got %s", val)
}
}
if enableTLS {
certGiven := config.AuthParams["cert"] != ""
keyGiven := config.AuthParams["key"] != ""
if certGiven && !keyGiven {
return errors.New("key must be provided with cert")
}
if keyGiven && !certGiven {
return errors.New("cert must be provided with key")
}
meta.ca = config.AuthParams["ca"]
meta.cert = config.AuthParams["cert"]
meta.key = config.AuthParams["key"]
if value, found := config.AuthParams["keyPassword"]; found {
meta.keyPassword = value
} else {
meta.keyPassword = ""
}
meta.enableTLS = true
}
return nil
}
func parseKafkaMetadata(config *ScalerConfig, logger logr.Logger) (kafkaMetadata, error) {
meta := kafkaMetadata{}
switch {
case config.TriggerMetadata["bootstrapServersFromEnv"] != "":
meta.bootstrapServers = strings.Split(config.ResolvedEnv[config.TriggerMetadata["bootstrapServersFromEnv"]], ",")
case config.TriggerMetadata["bootstrapServers"] != "":
meta.bootstrapServers = strings.Split(config.TriggerMetadata["bootstrapServers"], ",")
default:
return meta, errors.New("no bootstrapServers given")
}
switch {
case config.TriggerMetadata["consumerGroupFromEnv"] != "":
meta.group = config.ResolvedEnv[config.TriggerMetadata["consumerGroupFromEnv"]]
case config.TriggerMetadata["consumerGroup"] != "":
meta.group = config.TriggerMetadata["consumerGroup"]
default:
return meta, errors.New("no consumer group given")
}
switch {
case config.TriggerMetadata["topicFromEnv"] != "":
meta.topic = config.ResolvedEnv[config.TriggerMetadata["topicFromEnv"]]
case config.TriggerMetadata["topic"] != "":
meta.topic = config.TriggerMetadata["topic"]
default:
meta.topic = ""
logger.V(1).Info(fmt.Sprintf("consumer group %q has no topic specified, "+
"will use all topics subscribed by the consumer group for scaling", meta.group))
}
meta.partitionLimitation = nil
partitionLimitationMetadata := strings.TrimSpace(config.TriggerMetadata["partitionLimitation"])
if partitionLimitationMetadata != "" {
if meta.topic == "" {
logger.V(1).Info("no specific topic set, ignoring partitionLimitation setting")
} else {
pattern := config.TriggerMetadata["partitionLimitation"]
parsed, err := kedautil.ParseInt32List(pattern)
if err != nil {
return meta, fmt.Errorf("error parsing in partitionLimitation '%s': %w", pattern, err)
}
meta.partitionLimitation = parsed
logger.V(0).Info(fmt.Sprintf("partition limit active '%s'", pattern))
}
}
meta.offsetResetPolicy = defaultOffsetResetPolicy
if config.TriggerMetadata["offsetResetPolicy"] != "" {
policy := offsetResetPolicy(config.TriggerMetadata["offsetResetPolicy"])
if policy != earliest && policy != latest {
return meta, fmt.Errorf("err offsetResetPolicy policy %q given", policy)
}
meta.offsetResetPolicy = policy
}
meta.lagThreshold = defaultKafkaLagThreshold
if val, ok := config.TriggerMetadata[lagThresholdMetricName]; ok {
t, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return meta, fmt.Errorf("error parsing %q: %w", lagThresholdMetricName, err)
}
if t <= 0 {
return meta, fmt.Errorf("%q must be positive number", lagThresholdMetricName)
}
meta.lagThreshold = t
}
meta.activationLagThreshold = defaultKafkaActivationLagThreshold
if val, ok := config.TriggerMetadata[activationLagThresholdMetricName]; ok {
t, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return meta, fmt.Errorf("error parsing %q: %w", activationLagThresholdMetricName, err)
}
if t < 0 {
return meta, fmt.Errorf("%q must be positive number", activationLagThresholdMetricName)
}
meta.activationLagThreshold = t
}
if err := parseKafkaAuthParams(config, &meta); err != nil {
return meta, err
}
meta.allowIdleConsumers = false
if val, ok := config.TriggerMetadata["allowIdleConsumers"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing allowIdleConsumers: %w", err)
}
meta.allowIdleConsumers = t
}
meta.excludePersistentLag = false
if val, ok := config.TriggerMetadata["excludePersistentLag"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing excludePersistentLag: %w", err)
}
meta.excludePersistentLag = t
}
meta.scaleToZeroOnInvalidOffset = false
if val, ok := config.TriggerMetadata["scaleToZeroOnInvalidOffset"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing scaleToZeroOnInvalidOffset: %w", err)
}
meta.scaleToZeroOnInvalidOffset = t
}
meta.version = sarama.V1_0_0_0
if val, ok := config.TriggerMetadata["version"]; ok {
val = strings.TrimSpace(val)
version, err := sarama.ParseKafkaVersion(val)
if err != nil {
return meta, fmt.Errorf("error parsing kafka version: %w", err)
}
meta.version = version
}
meta.scalerIndex = config.ScalerIndex
return meta, nil
}
func getKafkaClients(metadata kafkaMetadata) (sarama.Client, sarama.ClusterAdmin, error) {
config := sarama.NewConfig()
config.Version = metadata.version
if metadata.saslType != KafkaSASLTypeNone {
config.Net.SASL.Enable = true
config.Net.SASL.User = metadata.username
config.Net.SASL.Password = metadata.password
}
if metadata.enableTLS {
config.Net.TLS.Enable = true
tlsConfig, err := kedautil.NewTLSConfigWithPassword(metadata.cert, metadata.key, metadata.keyPassword, metadata.ca, false)
if err != nil {
return nil, nil, err
}
config.Net.TLS.Config = tlsConfig
}
if metadata.saslType == KafkaSASLTypePlaintext {
config.Net.SASL.Mechanism = sarama.SASLTypePlaintext
}
if metadata.saslType == KafkaSASLTypeSCRAMSHA256 {
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &XDGSCRAMClient{HashGeneratorFcn: SHA256} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA256
}
if metadata.saslType == KafkaSASLTypeSCRAMSHA512 {
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &XDGSCRAMClient{HashGeneratorFcn: SHA512} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA512
}
if metadata.saslType == KafkaSASLTypeOAuthbearer {
config.Net.SASL.Mechanism = sarama.SASLTypeOAuth
config.Net.SASL.TokenProvider = OAuthBearerTokenProvider(metadata.username, metadata.password, metadata.oauthTokenEndpointURI, metadata.scopes, metadata.oauthExtensions)
}
client, err := sarama.NewClient(metadata.bootstrapServers, config)
if err != nil {
return nil, nil, fmt.Errorf("error creating kafka client: %w", err)
}
admin, err := sarama.NewClusterAdminFromClient(client)
if err != nil {
if !client.Closed() {
client.Close()
}
return nil, nil, fmt.Errorf("error creating kafka admin: %w", err)
}
return client, admin, nil
}
func (s *kafkaScaler) getTopicPartitions() (map[string][]int32, error) | {
var topicsToDescribe = make([]string, 0)
// when no topic is specified, query to cg group to fetch all subscribed topics
if s.metadata.topic == "" {
listCGOffsetResponse, err := s.admin.ListConsumerGroupOffsets(s.metadata.group, nil)
if err != nil {
return nil, fmt.Errorf("error listing cg offset: %w", err)
}
if listCGOffsetResponse.Err > 0 {
errMsg := fmt.Errorf("error listing cg offset: %w", listCGOffsetResponse.Err)
s.logger.Error(errMsg, "")
}
for topicName := range listCGOffsetResponse.Blocks {
topicsToDescribe = append(topicsToDescribe, topicName)
}
} else {
topicsToDescribe = []string{s.metadata.topic} | identifier_body | |
kafka_scaler.go | Bearer extension, must be of format key=value")
}
meta.oauthExtensions[splittedExtension[0]] = splittedExtension[1]
}
}
}
} else {
return fmt.Errorf("err SASL mode %s given", mode)
}
}
meta.enableTLS = false
enableTLS := false
if val, ok := config.TriggerMetadata["tls"]; ok {
switch val {
case stringEnable:
enableTLS = true
case stringDisable:
enableTLS = false
default:
return fmt.Errorf("error incorrect TLS value given, got %s", val)
}
}
if val, ok := config.AuthParams["tls"]; ok {
val = strings.TrimSpace(val)
if enableTLS {
return errors.New("unable to set `tls` in both ScaledObject and TriggerAuthentication together")
}
switch val {
case stringEnable:
enableTLS = true
case stringDisable:
enableTLS = false
default:
return fmt.Errorf("error incorrect TLS value given, got %s", val)
}
}
if enableTLS {
certGiven := config.AuthParams["cert"] != ""
keyGiven := config.AuthParams["key"] != ""
if certGiven && !keyGiven {
return errors.New("key must be provided with cert")
}
if keyGiven && !certGiven {
return errors.New("cert must be provided with key")
}
meta.ca = config.AuthParams["ca"]
meta.cert = config.AuthParams["cert"]
meta.key = config.AuthParams["key"]
if value, found := config.AuthParams["keyPassword"]; found {
meta.keyPassword = value
} else {
meta.keyPassword = ""
}
meta.enableTLS = true
}
return nil
}
func parseKafkaMetadata(config *ScalerConfig, logger logr.Logger) (kafkaMetadata, error) {
meta := kafkaMetadata{}
switch {
case config.TriggerMetadata["bootstrapServersFromEnv"] != "":
meta.bootstrapServers = strings.Split(config.ResolvedEnv[config.TriggerMetadata["bootstrapServersFromEnv"]], ",")
case config.TriggerMetadata["bootstrapServers"] != "":
meta.bootstrapServers = strings.Split(config.TriggerMetadata["bootstrapServers"], ",")
default:
return meta, errors.New("no bootstrapServers given")
}
switch {
case config.TriggerMetadata["consumerGroupFromEnv"] != "":
meta.group = config.ResolvedEnv[config.TriggerMetadata["consumerGroupFromEnv"]]
case config.TriggerMetadata["consumerGroup"] != "":
meta.group = config.TriggerMetadata["consumerGroup"]
default:
return meta, errors.New("no consumer group given")
}
switch {
case config.TriggerMetadata["topicFromEnv"] != "":
meta.topic = config.ResolvedEnv[config.TriggerMetadata["topicFromEnv"]]
case config.TriggerMetadata["topic"] != "":
meta.topic = config.TriggerMetadata["topic"]
default:
meta.topic = ""
logger.V(1).Info(fmt.Sprintf("consumer group %q has no topic specified, "+
"will use all topics subscribed by the consumer group for scaling", meta.group))
}
meta.partitionLimitation = nil
partitionLimitationMetadata := strings.TrimSpace(config.TriggerMetadata["partitionLimitation"])
if partitionLimitationMetadata != "" {
if meta.topic == "" {
logger.V(1).Info("no specific topic set, ignoring partitionLimitation setting")
} else {
pattern := config.TriggerMetadata["partitionLimitation"]
parsed, err := kedautil.ParseInt32List(pattern)
if err != nil {
return meta, fmt.Errorf("error parsing in partitionLimitation '%s': %w", pattern, err)
}
meta.partitionLimitation = parsed
logger.V(0).Info(fmt.Sprintf("partition limit active '%s'", pattern))
}
}
meta.offsetResetPolicy = defaultOffsetResetPolicy
if config.TriggerMetadata["offsetResetPolicy"] != "" {
policy := offsetResetPolicy(config.TriggerMetadata["offsetResetPolicy"])
if policy != earliest && policy != latest {
return meta, fmt.Errorf("err offsetResetPolicy policy %q given", policy)
}
meta.offsetResetPolicy = policy
}
meta.lagThreshold = defaultKafkaLagThreshold
if val, ok := config.TriggerMetadata[lagThresholdMetricName]; ok {
t, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return meta, fmt.Errorf("error parsing %q: %w", lagThresholdMetricName, err)
}
if t <= 0 {
return meta, fmt.Errorf("%q must be positive number", lagThresholdMetricName)
}
meta.lagThreshold = t
}
meta.activationLagThreshold = defaultKafkaActivationLagThreshold
if val, ok := config.TriggerMetadata[activationLagThresholdMetricName]; ok {
t, err := strconv.ParseInt(val, 10, 64)
if err != nil {
return meta, fmt.Errorf("error parsing %q: %w", activationLagThresholdMetricName, err)
}
if t < 0 {
return meta, fmt.Errorf("%q must be positive number", activationLagThresholdMetricName)
}
meta.activationLagThreshold = t
}
if err := parseKafkaAuthParams(config, &meta); err != nil {
return meta, err
}
meta.allowIdleConsumers = false
if val, ok := config.TriggerMetadata["allowIdleConsumers"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing allowIdleConsumers: %w", err)
}
meta.allowIdleConsumers = t
}
meta.excludePersistentLag = false
if val, ok := config.TriggerMetadata["excludePersistentLag"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing excludePersistentLag: %w", err)
}
meta.excludePersistentLag = t
}
meta.scaleToZeroOnInvalidOffset = false
if val, ok := config.TriggerMetadata["scaleToZeroOnInvalidOffset"]; ok {
t, err := strconv.ParseBool(val)
if err != nil {
return meta, fmt.Errorf("error parsing scaleToZeroOnInvalidOffset: %w", err)
}
meta.scaleToZeroOnInvalidOffset = t
}
meta.version = sarama.V1_0_0_0
if val, ok := config.TriggerMetadata["version"]; ok |
meta.scalerIndex = config.ScalerIndex
return meta, nil
}
func getKafkaClients(metadata kafkaMetadata) (sarama.Client, sarama.ClusterAdmin, error) {
config := sarama.NewConfig()
config.Version = metadata.version
if metadata.saslType != KafkaSASLTypeNone {
config.Net.SASL.Enable = true
config.Net.SASL.User = metadata.username
config.Net.SASL.Password = metadata.password
}
if metadata.enableTLS {
config.Net.TLS.Enable = true
tlsConfig, err := kedautil.NewTLSConfigWithPassword(metadata.cert, metadata.key, metadata.keyPassword, metadata.ca, false)
if err != nil {
return nil, nil, err
}
config.Net.TLS.Config = tlsConfig
}
if metadata.saslType == KafkaSASLTypePlaintext {
config.Net.SASL.Mechanism = sarama.SASLTypePlaintext
}
if metadata.saslType == KafkaSASLTypeSCRAMSHA256 {
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &XDGSCRAMClient{HashGeneratorFcn: SHA256} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA256
}
if metadata.saslType == KafkaSASLTypeSCRAMSHA512 {
config.Net.SASL.SCRAMClientGeneratorFunc = func() sarama.SCRAMClient { return &XDGSCRAMClient{HashGeneratorFcn: SHA512} }
config.Net.SASL.Mechanism = sarama.SASLTypeSCRAMSHA512
}
if metadata.saslType == KafkaSASLTypeOAuthbearer {
config.Net.SASL.Mechanism = sarama.SASLTypeOAuth
config.Net.SASL.TokenProvider = OAuthBearerTokenProvider(metadata.username, metadata.password, metadata.oauthTokenEndpointURI, metadata.scopes, metadata.oauthExtensions)
}
client, err := sarama.NewClient(metadata.bootstrapServers, config)
if err != nil {
return nil, nil, fmt.Errorf("error creating kafka client: %w", err)
}
admin, err := sarama.NewClusterAdminFromClient(client)
if err != nil {
if !client.Closed() {
client.Close()
}
return nil, nil, fmt.Errorf("error creating kafka admin: %w", err)
}
| {
val = strings.TrimSpace(val)
version, err := sarama.ParseKafkaVersion(val)
if err != nil {
return meta, fmt.Errorf("error parsing kafka version: %w", err)
}
meta.version = version
} | conditional_block |
kafka_scaler.go | listing cg offset: %w", listCGOffsetResponse.Err)
s.logger.Error(errMsg, "")
}
for topicName := range listCGOffsetResponse.Blocks {
topicsToDescribe = append(topicsToDescribe, topicName)
}
} else {
topicsToDescribe = []string{s.metadata.topic}
}
topicsMetadata, err := s.admin.DescribeTopics(topicsToDescribe)
if err != nil {
return nil, fmt.Errorf("error describing topics: %w", err)
}
if s.metadata.topic != "" && len(topicsMetadata) != 1 {
return nil, fmt.Errorf("expected only 1 topic metadata, got %d", len(topicsMetadata))
}
topicPartitions := make(map[string][]int32, len(topicsMetadata))
for _, topicMetadata := range topicsMetadata {
if topicMetadata.Err > 0 {
errMsg := fmt.Errorf("error describing topics: %w", topicMetadata.Err)
s.logger.Error(errMsg, "")
}
partitionMetadata := topicMetadata.Partitions
var partitions []int32
for _, p := range partitionMetadata {
if s.isActivePartition(p.ID) {
partitions = append(partitions, p.ID)
}
}
if len(partitions) == 0 {
return nil, fmt.Errorf("expected at least one active partition within the topic '%s'", topicMetadata.Name)
}
topicPartitions[topicMetadata.Name] = partitions
}
return topicPartitions, nil
}
func (s *kafkaScaler) isActivePartition(pID int32) bool {
if s.metadata.partitionLimitation == nil {
return true
}
for _, _pID := range s.metadata.partitionLimitation {
if pID == _pID {
return true
}
}
return false
}
func (s *kafkaScaler) getConsumerOffsets(topicPartitions map[string][]int32) (*sarama.OffsetFetchResponse, error) {
offsets, err := s.admin.ListConsumerGroupOffsets(s.metadata.group, topicPartitions)
if err != nil {
return nil, fmt.Errorf("error listing consumer group offsets: %w", err)
}
if offsets.Err > 0 {
errMsg := fmt.Errorf("error listing consumer group offsets: %w", offsets.Err)
s.logger.Error(errMsg, "")
}
return offsets, nil
}
// getLagForPartition returns (lag, lagWithPersistent, error)
// When excludePersistentLag is set to `false` (default), lag will always be equal to lagWithPersistent
// When excludePersistentLag is set to `true`, if partition is deemed to have persistent lag, lag will be set to 0 and lagWithPersistent will be latestOffset - consumerOffset
// These return values will allow proper scaling from 0 -> 1 replicas by the IsActive func.
func (s *kafkaScaler) getLagForPartition(topic string, partitionID int32, offsets *sarama.OffsetFetchResponse, topicPartitionOffsets map[string]map[int32]int64) (int64, int64, error) {
block := offsets.GetBlock(topic, partitionID)
if block == nil {
errMsg := fmt.Errorf("error finding offset block for topic %s and partition %d from offset block: %v", topic, partitionID, offsets.Blocks)
s.logger.Error(errMsg, "")
return 0, 0, errMsg
}
if block.Err > 0 {
errMsg := fmt.Errorf("error finding offset block for topic %s and partition %d: %w", topic, partitionID, offsets.Err)
s.logger.Error(errMsg, "")
}
consumerOffset := block.Offset
if consumerOffset == invalidOffset && s.metadata.offsetResetPolicy == latest {
retVal := int64(1)
if s.metadata.scaleToZeroOnInvalidOffset {
retVal = 0
}
msg := fmt.Sprintf(
"invalid offset found for topic %s in group %s and partition %d, probably no offset is committed yet. Returning with lag of %d",
topic, s.metadata.group, partitionID, retVal)
s.logger.V(1).Info(msg)
return retVal, retVal, nil
}
if _, found := topicPartitionOffsets[topic]; !found {
return 0, 0, fmt.Errorf("error finding partition offset for topic %s", topic)
}
latestOffset := topicPartitionOffsets[topic][partitionID]
if consumerOffset == invalidOffset && s.metadata.offsetResetPolicy == earliest {
return latestOffset, latestOffset, nil
}
// This code block tries to prevent KEDA Kafka trigger from scaling the scale target based on erroneous events
if s.metadata.excludePersistentLag {
switch previousOffset, found := s.previousOffsets[topic][partitionID]; {
case !found:
// No record of previous offset, so store current consumer offset
// Allow this consumer lag to be considered in scaling
if _, topicFound := s.previousOffsets[topic]; !topicFound {
s.previousOffsets[topic] = map[int32]int64{partitionID: consumerOffset}
} else {
s.previousOffsets[topic][partitionID] = consumerOffset
}
case previousOffset == consumerOffset:
// Indicates consumer is still on the same offset as the previous polling cycle, there may be some issue with consuming this offset.
// return 0, so this consumer lag is not considered for scaling
return 0, latestOffset - consumerOffset, nil
default:
// Successfully Consumed some messages, proceed to change the previous offset
s.previousOffsets[topic][partitionID] = consumerOffset
}
}
return latestOffset - consumerOffset, latestOffset - consumerOffset, nil
}
// Close closes the kafka admin and client
func (s *kafkaScaler) Close(context.Context) error {
// underlying client will also be closed on admin's Close() call
if s.admin == nil {
return nil
}
return s.admin.Close()
}
func (s *kafkaScaler) GetMetricSpecForScaling(context.Context) []v2.MetricSpec {
var metricName string
if s.metadata.topic != "" {
metricName = fmt.Sprintf("kafka-%s", s.metadata.topic)
} else {
metricName = fmt.Sprintf("kafka-%s-topics", s.metadata.group)
}
externalMetric := &v2.ExternalMetricSource{
Metric: v2.MetricIdentifier{
Name: GenerateMetricNameWithIndex(s.metadata.scalerIndex, kedautil.NormalizeString(metricName)),
},
Target: GetMetricTarget(s.metricType, s.metadata.lagThreshold),
}
metricSpec := v2.MetricSpec{External: externalMetric, Type: kafkaMetricType}
return []v2.MetricSpec{metricSpec}
}
type consumerOffsetResult struct {
consumerOffsets *sarama.OffsetFetchResponse
err error
}
type producerOffsetResult struct {
producerOffsets map[string]map[int32]int64
err error
}
func (s *kafkaScaler) getConsumerAndProducerOffsets(topicPartitions map[string][]int32) (*sarama.OffsetFetchResponse, map[string]map[int32]int64, error) {
consumerChan := make(chan consumerOffsetResult, 1)
go func() {
consumerOffsets, err := s.getConsumerOffsets(topicPartitions)
consumerChan <- consumerOffsetResult{consumerOffsets, err}
}()
producerChan := make(chan producerOffsetResult, 1)
go func() {
producerOffsets, err := s.getProducerOffsets(topicPartitions)
producerChan <- producerOffsetResult{producerOffsets, err}
}()
consumerRes := <-consumerChan
if consumerRes.err != nil {
return nil, nil, consumerRes.err
}
producerRes := <-producerChan
if producerRes.err != nil {
return nil, nil, producerRes.err
}
return consumerRes.consumerOffsets, producerRes.producerOffsets, nil
}
// GetMetricsAndActivity returns value for a supported metric and an error if there is a problem getting the metric
func (s *kafkaScaler) GetMetricsAndActivity(_ context.Context, metricName string) ([]external_metrics.ExternalMetricValue, bool, error) {
totalLag, totalLagWithPersistent, err := s.getTotalLag()
if err != nil {
return []external_metrics.ExternalMetricValue{}, false, err
}
metric := GenerateMetricInMili(metricName, float64(totalLag))
return []external_metrics.ExternalMetricValue{metric}, totalLagWithPersistent > s.metadata.activationLagThreshold, nil
}
// getTotalLag returns totalLag, totalLagWithPersistent, error
// totalLag and totalLagWithPersistent are the summations of lag and lagWithPersistent returned by getLagForPartition function respectively.
// totalLag maybe less than totalLagWithPersistent when excludePersistentLag is set to `true` due to some partitions deemed as having persistent lag
func (s *kafkaScaler) getTotalLag() (int64, int64, error) {
topicPartitions, err := s.getTopicPartitions()
if err != nil {
return 0, 0, err
}
consumerOffsets, producerOffsets, err := s.getConsumerAndProducerOffsets(topicPartitions)
if err != nil {
return 0, 0, err | } | random_line_split | |
auto.go | _update()
if play {
glog.Warningln("WITH PLAY MODE")
} else {
p.Merge(true, store)
}
atomic.StoreInt32(&p.loaded, 2)
return true
}
func (p *Stock) days_download(t time.Time) ([]int, error) {
inds := []int{}
tds, err := robot.Days_download(p.Id, t)
if err != nil {
return inds, err
}
for i, count := 0, len(tds); i < count; i++ {
ind, isnew := p.Days.Add(tds[i])
if isnew || ind > 0 {
inds = append(inds, ind)
}
}
return inds, nil
}
func (p *Stock) Days_update(store store.Store) int {
c := Day_collection_name(p.Id)
p.Days.start = store.GetStartTime(p.Id, LDay)
p.Days.Data, _ = store.LoadTDatas(c, p.Days.start)
t := p.Days.latest_time()
now := time.Now().AddDate(0, 0, -1).UTC().Truncate(time.Hour * 24)
for !IsTradeDay(now) {
now = now.AddDate(0, 0, -1)
}
if t.Equal(now) || t.After(now) {
return 0
}
inds, _ := p.days_download(t)
if len(inds) > 0 {
store.SaveTDatas(c, p.Days.Data, inds)
factor := p.Days.Factor()
store.UpdateFactor(p.Id, factor)
}
return len(inds)
}
func (p *Stock) Ticks_update(store store.Store) int {
c := Tick_collection_name(p.Id)
p.M1s.start = store.GetStartTime(p.Id, L1)
p.Ticks.Data, _ = store.LoadTicks(c, p.M1s.start)
begin_time := p.M1s.start
l := len(p.Ticks.Data)
if l > 0 {
begin_time = p.Ticks.Data[0].Time
}
now := time.Now().UTC()
end_time := now.Truncate(time.Hour * 24)
if now.Hour() > 10 {
end_time = end_time.AddDate(0, 0, 1)
}
if begin_time.Equal(market_begin_day) {
begin_time = end_time.AddDate(0, -2, -1)
}
begin_time = begin_time.AddDate(0, 0, 1).Truncate(time.Hour * 24)
daylen := len(p.Days.Data)
if daylen < 1 {
return 0
}
i, _ := ((TdataSlice)(p.Days.Data)).Search(begin_time)
glog.V(LogV).Infof("from %d/%d %s begin_time=%s end_time=%s", i, daylen, p.M1s.start, begin_time, end_time)
var t time.Time
for ; i <= daylen; i++ {
if i < daylen {
t = p.Days.Data[i].Time
} else if i == daylen {
t = p.Days.Data[i-1].Time.AddDate(0, 0, 1)
}
if !end_time.After(t) {
glog.V(LogV).Infoln(t, "reach end_time", end_time)
break
}
if p.Ticks.hasTimeData(t) {
continue
}
glog.V(LogV).Infoln("prepare download ticks", t)
if ticks, err := p.ticks_download(t); ticks != nil {
for j, _ := range ticks {
p.Ticks.Add(ticks[j])
}
store.SaveTicks(c, ticks)
glog.V(LogV).Infoln("download ticks succ", t)
} else if err != nil {
glog.V(LogD).Infoln("download ticks err", err)
}
}
count := len(p.Ticks.Data)
glog.V(LogV).Infof("download ticks %d/%d", count-l, count)
return count - l
}
/*
func (p *Tdata) parse_mins_from_sina(line []byte) error {
items := [6]string{"day:", "open:", "high:", "close:", "low:", "volume:"}
v := [6]string{}
line = bytes.TrimSpace(line)
line = bytes.Trim(line, "[{}]")
infos := bytes.Split(line, []byte(","))
if len(infos) != 6 {
return errors.New("could not parse line " + string(line))
}
for i, item := range items {
v[i] = ""
for _, info := range infos {
if bytes.HasPrefix(info, []byte(item)) {
info = bytes.TrimPrefix(info, []byte(item))
info = bytes.Trim(info, "\"")
v[i] = string(info)
}
}
}
p.FromString(v[0], v[1], v[2], v[3], v[4], v[5])
return nil
}
*/
var UnknowSinaRes error = errors.New("could not find '成交时间' in head line")
func (p *Stock) ticks_download(t time.Time) ([]Tick, error) {
body := robot.Tick_download_from_sina(p.Id, t)
if body == nil {
return nil, UnknowSinaRes
}
body = bytes.TrimSpace(body)
lines := bytes.Split(body, []byte("\n"))
count := len(lines) - 1
if count < 1 {
return nil, UnknowSinaRes
}
if bytes.Contains(lines[0], []byte("script")) {
return nil, UnknowSinaRes
}
if !bytes.Contains(lines[0], []byte("成交时间")) {
return nil, UnknowSinaRes
}
ticks := make([]Tick, count)
for i := count; i > 0; i-- {
line := bytes.TrimSpace(lines[i])
infos := bytes.Split(line, []byte("\t"))
if len(infos) != 6 {
err := errors.New("could not parse line " + string(line))
return nil, err
}
ticks[count-i].FromString(t, infos[0], infos[1], infos[2],
infos[3], infos[4], infos[5])
}
FixTickTime(ticks)
return ticks, nil
}
func (p *Stock) Ticks_today_update() int {
l := len(p.Ticks.Data)
now := time.Now().UTC()
if !IsTradeDay(now) {
return 0
}
nhour := now.Hour()
if nhour < 1 || nhour > 10 {
return 0
}
p.ticks_get_today()
count := len(p.Ticks.Data)
return count - l
}
func (p *Stock) ticks_get_today() bool {
last_t, name, err := Tick_get_today_date(p.Id)
if err != nil {
glog.Warningln("get today date fail", err)
return false
}
p.Name = name
t := time.Now().UTC().Truncate(time.Hour * 24)
if t.After(last_t) {
return false
}
body := robot.Tick_download_today_from_sina(p.Id)
if body == nil {
return false
}
body = bytes.TrimSpace(body)
lines := bytes.Split(body, []byte("\n"))
ticks := []Tick{}
tick := Tick{}
nul := []byte("")
for i := len(lines) - 1; i > 0; i-- {
line := bytes.TrimSpace(lines[i])
line = bytes.Trim(line, ");")
infos := bytes.Split(line, []byte("] = new Array("))
if len(infos) != 2 {
continue
}
line = bytes.Replace(infos[1], []byte(" "), nul, -1)
line = bytes.Replace(line, []byte("'"), nul, -1)
infos = bytes.Split(line, []byte(","))
if len(infos) != 4 {
continue
}
tick.FromString(t, infos[0], infos[2], nul, infos[1], nul, infos[3])
if tick.Volume == 0 && tick.Price == 0 {
continue
}
ticks = append(ticks, tick)
}
FixTickTime(ticks)
FixTickData(ticks)
for _, tick := range ticks {
p.Ticks.Add(tick)
}
return true
}
func (p *Stock) tick_get_real(line []byte) bool {
infos := byte | s.Split(line, []byte(","))
if len(infos) < 33 {
glog.Warningln("sina hq api, res format changed")
return false
}
p.Name = string(infos[0])
nul := []byte("")
tick := RealtimeTick{}
t, _ := time.Parse("2006-01-02", string(infos[30]))
tick.FromString(t, infos[31], infos[3], nul, infos[8], infos[9], nul)
tick.Buyone = ParseCent(string(infos[11]))
tick.Sellone = ParseCent(string(infos[21]))
tick.SetStatus(infos[32])
if p.last_tick.Volume == 0 {
p.last_tick = tick
if tick.Time.Before(p.lst_trade) {
p.last_tick.Volume = 0
} | identifier_body | |
auto.go | *Stocks) Chan(ch chan *Stock) {
p.ch = ch
}
func (p *Stocks) res(stock *Stock) {
if p.ch != nil {
p.ch <- stock
}
}
func (p *Stocks) update(s *Stock) {
if s.Update(p.store, p.play > minPlay) {
p.res(s)
}
}
func (p *Stocks) Insert(id string) (int, *Stock, bool) {
p.rwmutex.RLock()
i, ok := p.stocks.Search(id)
if ok {
s := p.stocks[i]
p.rwmutex.RUnlock()
if atomic.AddInt32(&s.count, 1) < 1 {
atomic.StoreInt32(&s.count, 1)
}
return i, s, false
}
s := NewStock(id, p.min_hub_height)
p.rwmutex.RUnlock()
p.rwmutex.Lock()
defer p.rwmutex.Unlock()
if i < 1 {
p.stocks = append(PStockSlice{s}, p.stocks...)
return 0, s, true
} else if i >= p.stocks.Len() {
p.stocks = append(p.stocks, s)
return p.stocks.Len() - 1, s, true
}
p.stocks = append(p.stocks, s)
copy(p.stocks[i+1:], p.stocks[i:])
p.stocks[i] = s
return i, s, true
}
func (p *Stocks) Remove(id string) {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
if i, ok := p.stocks.Search(id); ok {
atomic.AddInt32(&p.stocks[i].count, -1)
}
}
func (p *Stocks) Watch(id string) (*Stock, bool) {
i, s, isnew := p.Insert(id)
if isnew {
go p.update(s)
glog.V(LogV).Infof("watch new stock id=%s index=%d", id, i)
} else {
glog.V(LogV).Infof("watch stock id=%s index=%d count=%d", id, i, s.count)
}
return s, isnew
}
func (p *Stocks) UnWatch(id string) {
p.Remove(id)
}
func (p *Stocks) Find_need_update_tick_ids() (pstocks PStockSlice) {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
for i, l := 0, len(p.stocks); i < l; i++ {
if atomic.LoadInt32(&p.stocks[i].loaded) < 2 {
continue
}
pstocks = append(pstocks, p.stocks[i])
}
return
}
func (p *Stocks) play_next_tick() {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
for i, l := 0, len(p.stocks); i < l; i++ {
if atomic.LoadInt32(&p.stocks[i].loaded) < 2 {
continue
}
if atomic.LoadInt32(&p.stocks[i].count) < 1 {
continue
}
p.stocks[i].rw.Lock()
if p.stocks[i].Ticks.play == nil || len(p.stocks[i].Ticks.play) < 1 {
p.stocks[i].Ticks.play = p.stocks[i].Ticks.Data
p.stocks[i].Ticks.Data = []Tick{}
if len(p.stocks[i].Ticks.play) > 240 {
p.stocks[i].Ticks.Data = p.stocks[i].Ticks.play[:240]
}
}
lplay := len(p.stocks[i].Ticks.play)
ldata := len(p.stocks[i].Ticks.Data)
if ldata < lplay {
p.stocks[i].Ticks.Data = p.stocks[i].Ticks.play[:ldata+1]
p.stocks[i].Merge(false, p.store)
p.res(p.stocks[i])
}
p.stocks[i].rw.Unlock()
}
}
func (p *Stocks) Ticks_update_real() {
var wg sync.WaitGroup
stocks := p.Find_need_update_tick_ids()
l := len(stocks)
if l < 1 {
return
}
for i := 0; i < l; {
var b bytes.Buffer
var pstocks PStockSlice
step := 50
if i+step < l {
pstocks = stocks[i : i+step]
} else {
pstocks = stocks[i:l]
}
for j := 0; j < step && i < l; i, j = i+1, j+1 {
if b.Len() > 0 {
b.WriteString(",")
}
b.WriteString(stocks[i].Id)
}
if b.Len() < 1 {
continue
}
wg.Add(1)
go func(ids string, pstocks PStockSlice) {
defer wg.Done()
body := robot.Tick_download_real_from_sina(ids)
if body == nil {
return
}
for _, line := range bytes.Split(body, []byte("\";")) {
line = bytes.TrimSpace(line)
info := bytes.Split(line, []byte("=\""))
if len(info) != 2 {
continue
}
prefix := "var hq_str_"
if !bytes.HasPrefix(info[0], []byte(prefix)) {
continue
}
id := info[0][len(prefix):]
if idx, ok := pstocks.Search(string(id)); ok {
if pstocks[idx].tick_get_real(info[1]) {
pstocks[idx].Merge(false, p.store)
p.res(pstocks[idx])
}
}
}
}(b.String(), pstocks)
}
wg.Wait()
}
func StockHash(id string) int {
for i, c := range []byte(id) {
if c >= '0' && c <= '9' {
i, _ = strconv.Atoi(id[i:])
return i
}
}
return 0
}
func (p *Stock) Merge(day bool, store store.Store) {
m1_fresh_index := p.Ticks2M1s()
m5_fresh_index := p.M5s.MergeFrom(&p.M1s, false, Minute5end)
m30_fresh_index := p.M30s.MergeFrom(&p.M1s, false, Minute30end)
if day {
p.Ticks.clean()
td, _ := store.LoadMacd(p.Id, L1, p.M1s.start)
p.M1s.Macd(m1_fresh_index, td)
store.SaveMacds(p.Id, L1, p.M1s.Data)
td, _ = store.LoadMacd(p.Id, L5, p.M1s.start)
p.M5s.Macd(m5_fresh_index, td)
store.SaveMacds(p.Id, L5, p.M5s.Data)
td, _ = store.LoadMacd(p.Id, L30, p.M1s.start)
p.M30s.Macd(m30_fresh_index, td)
store.SaveMacds(p.Id, L30, p.M30s.Data)
} else {
p.M1s.Macd(m1_fresh_index, nil)
p.M5s.Macd(m5_fresh_index, nil)
p.M30s.Macd(m30_fresh_index, nil)
}
p.M1s.ParseChan()
p.M5s.ParseChan()
p.M30s.ParseChan()
if day {
p.Weeks.MergeFrom(&p.Days, true, Weekend)
p.Months.MergeFrom(&p.Days, true, Monthend)
td, _ := store.LoadMacd(p.Id, LDay, p.Days.start)
p.Days.Macd(0, td)
store.SaveMacds(p.Id, LDay, p.Days.Data)
td, _ = store.LoadMacd(p.Id, LWeek, p.Days.start)
p.Weeks.Macd(0, td)
store.SaveMacds(p.Id, LWeek, p.Weeks.Data)
td, _ = store.LoadMacd(p.Id, LMonth, p.Days.start)
p.Months.Macd(0, td)
store.SaveMacds(p.Id, LMonth, p.Months.Data)
p.Days.ParseChan()
p.Weeks.ParseChan()
p.Months.ParseChan()
}
}
func (p *Tdatas) ParseChan() {
if p.base == nil {
p.ParseTyping()
p.Typing.LinkTyping()
p.ParseSegment()
p.Segment.LinkTyping()
}
p.ParseHub()
p.LinkHub()
}
func (p *Stock) Update(store store.Store, play bool) bool {
if !atomic.CompareAndSwapInt32(&p.loaded, 0, 1) {
return false
}
p.Days_update(store)
p.Ticks_update(store)
p.Ticks_today_update()
if play {
glog.Warningln("WITH PLAY MODE")
} else {
p.Merge(true, store)
}
atomic.StoreInt32(&p.loaded, 2)
return true
}
func (p *Stock) | (t time.Time) ([]int, error) {
inds := []int | days_download | identifier_name |
auto.go | *Stocks) Chan(ch chan *Stock) {
p.ch = ch
}
func (p *Stocks) res(stock *Stock) {
if p.ch != nil {
p.ch <- stock
}
}
func (p *Stocks) update(s *Stock) {
if s.Update(p.store, p.play > minPlay) {
p.res(s)
}
}
func (p *Stocks) Insert(id string) (int, *Stock, bool) {
p.rwmutex.RLock()
i, ok := p.stocks.Search(id)
if ok {
s := p.stocks[i]
p.rwmutex.RUnlock()
if atomic.AddInt32(&s.count, 1) < 1 {
atomic.StoreInt32(&s.count, 1)
}
return i, s, false
}
s := NewStock(id, p.min_hub_height)
p.rwmutex.RUnlock()
p.rwmutex.Lock()
defer p.rwmutex.Unlock()
if i < 1 {
p.stocks = append(PStockSlice{s}, p.stocks...)
return 0, s, true
} else if i >= p.stocks.Len() {
p.stocks = append(p.stocks, s)
return p.stocks.Len() - 1, s, true
}
p.stocks = append(p.stocks, s)
copy(p.stocks[i+1:], p.stocks[i:])
p.stocks[i] = s
return i, s, true
}
func (p *Stocks) Remove(id string) {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
if i, ok := p.stocks.Search(id); ok {
atomic.AddInt32(&p.stocks[i].count, -1)
}
}
func (p *Stocks) Watch(id string) (*Stock, bool) {
i, s, isnew := p.Insert(id)
if isnew {
go p.update(s)
glog.V(LogV).Infof("watch new stock id=%s index=%d", id, i)
} else {
glog.V(LogV).Infof("watch stock id=%s index=%d count=%d", id, i, s.count)
}
return s, isnew
}
func (p *Stocks) UnWatch(id string) {
p.Remove(id)
}
func (p *Stocks) Find_need_update_tick_ids() (pstocks PStockSlice) {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
for i, l := 0, len(p.stocks); i < l; i++ {
if atomic.LoadInt32(&p.stocks[i].loaded) < 2 {
continue
}
pstocks = append(pstocks, p.stocks[i])
}
return
}
func (p *Stocks) play_next_tick() {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
for i, l := 0, len(p.stocks); i < l; i++ {
if atomic.LoadInt32(&p.stocks[i].loaded) < 2 {
continue
}
if atomic.LoadInt32(&p.stocks[i].count) < 1 {
continue
}
p.stocks[i].rw.Lock()
if p.stocks[i].Ticks.play == nil || len(p.stocks[i].Ticks.play) < 1 {
p.stocks[i].Ticks.play = p.stocks[i].Ticks.Data
p.stocks[i].Ticks.Data = []Tick{}
if len(p.stocks[i].Ticks.play) > 240 {
p.stocks[i].Ticks.Data = p.stocks[i].Ticks.play[:240]
}
}
lplay := len(p.stocks[i].Ticks.play)
ldata := len(p.stocks[i].Ticks.Data)
if ldata < lplay {
p.stocks[i].Ticks.Data = p.stocks[i].Ticks.play[:ldata+1]
p.stocks[i].Merge(false, p.store)
p.res(p.stocks[i])
}
p.stocks[i].rw.Unlock()
}
}
func (p *Stocks) Ticks_update_real() {
var wg sync.WaitGroup
stocks := p.Find_need_update_tick_ids()
l := len(stocks)
if l < 1 {
return
}
for i := 0; i < l; {
var b bytes.Buffer
var pstocks PStockSlice
step := 50
if i+step < l {
pstocks = stocks[i : i+step]
} else {
pstocks = stocks[i:l]
}
for j := 0; j < step && i < l; i, j = i+1, j+1 {
if b.Len() > 0 {
b.WriteString(",")
}
b.WriteString(stocks[i].Id)
}
if b.Len() < 1 {
continue
}
wg.Add(1)
go func(ids string, pstocks PStockSlice) {
defer wg.Done()
body := robot.Tick_download_real_from_sina(ids)
if body == nil { | for _, line := range bytes.Split(body, []byte("\";")) {
line = bytes.TrimSpace(line)
info := bytes.Split(line, []byte("=\""))
if len(info) != 2 {
continue
}
prefix := "var hq_str_"
if !bytes.HasPrefix(info[0], []byte(prefix)) {
continue
}
id := info[0][len(prefix):]
if idx, ok := pstocks.Search(string(id)); ok {
if pstocks[idx].tick_get_real(info[1]) {
pstocks[idx].Merge(false, p.store)
p.res(pstocks[idx])
}
}
}
}(b.String(), pstocks)
}
wg.Wait()
}
func StockHash(id string) int {
for i, c := range []byte(id) {
if c >= '0' && c <= '9' {
i, _ = strconv.Atoi(id[i:])
return i
}
}
return 0
}
func (p *Stock) Merge(day bool, store store.Store) {
m1_fresh_index := p.Ticks2M1s()
m5_fresh_index := p.M5s.MergeFrom(&p.M1s, false, Minute5end)
m30_fresh_index := p.M30s.MergeFrom(&p.M1s, false, Minute30end)
if day {
p.Ticks.clean()
td, _ := store.LoadMacd(p.Id, L1, p.M1s.start)
p.M1s.Macd(m1_fresh_index, td)
store.SaveMacds(p.Id, L1, p.M1s.Data)
td, _ = store.LoadMacd(p.Id, L5, p.M1s.start)
p.M5s.Macd(m5_fresh_index, td)
store.SaveMacds(p.Id, L5, p.M5s.Data)
td, _ = store.LoadMacd(p.Id, L30, p.M1s.start)
p.M30s.Macd(m30_fresh_index, td)
store.SaveMacds(p.Id, L30, p.M30s.Data)
} else {
p.M1s.Macd(m1_fresh_index, nil)
p.M5s.Macd(m5_fresh_index, nil)
p.M30s.Macd(m30_fresh_index, nil)
}
p.M1s.ParseChan()
p.M5s.ParseChan()
p.M30s.ParseChan()
if day {
p.Weeks.MergeFrom(&p.Days, true, Weekend)
p.Months.MergeFrom(&p.Days, true, Monthend)
td, _ := store.LoadMacd(p.Id, LDay, p.Days.start)
p.Days.Macd(0, td)
store.SaveMacds(p.Id, LDay, p.Days.Data)
td, _ = store.LoadMacd(p.Id, LWeek, p.Days.start)
p.Weeks.Macd(0, td)
store.SaveMacds(p.Id, LWeek, p.Weeks.Data)
td, _ = store.LoadMacd(p.Id, LMonth, p.Days.start)
p.Months.Macd(0, td)
store.SaveMacds(p.Id, LMonth, p.Months.Data)
p.Days.ParseChan()
p.Weeks.ParseChan()
p.Months.ParseChan()
}
}
func (p *Tdatas) ParseChan() {
if p.base == nil {
p.ParseTyping()
p.Typing.LinkTyping()
p.ParseSegment()
p.Segment.LinkTyping()
}
p.ParseHub()
p.LinkHub()
}
func (p *Stock) Update(store store.Store, play bool) bool {
if !atomic.CompareAndSwapInt32(&p.loaded, 0, 1) {
return false
}
p.Days_update(store)
p.Ticks_update(store)
p.Ticks_today_update()
if play {
glog.Warningln("WITH PLAY MODE")
} else {
p.Merge(true, store)
}
atomic.StoreInt32(&p.loaded, 2)
return true
}
func (p *Stock) days_download(t time.Time) ([]int, error) {
inds := []int{}
| return
} | random_line_split |
auto.go | ) Insert(id string) (int, *Stock, bool) {
p.rwmutex.RLock()
i, ok := p.stocks.Search(id)
if ok {
s := p.stocks[i]
p.rwmutex.RUnlock()
if atomic.AddInt32(&s.count, 1) < 1 {
atomic.StoreInt32(&s.count, 1)
}
return i, s, false
}
s := NewStock(id, p.min_hub_height)
p.rwmutex.RUnlock()
p.rwmutex.Lock()
defer p.rwmutex.Unlock()
if i < 1 {
p.stocks = append(PStockSlice{s}, p.stocks...)
return 0, s, true
} else if i >= p.stocks.Len() {
p.stocks = append(p.stocks, s)
return p.stocks.Len() - 1, s, true
}
p.stocks = append(p.stocks, s)
copy(p.stocks[i+1:], p.stocks[i:])
p.stocks[i] = s
return i, s, true
}
func (p *Stocks) Remove(id string) {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
if i, ok := p.stocks.Search(id); ok {
atomic.AddInt32(&p.stocks[i].count, -1)
}
}
func (p *Stocks) Watch(id string) (*Stock, bool) {
i, s, isnew := p.Insert(id)
if isnew {
go p.update(s)
glog.V(LogV).Infof("watch new stock id=%s index=%d", id, i)
} else {
glog.V(LogV).Infof("watch stock id=%s index=%d count=%d", id, i, s.count)
}
return s, isnew
}
func (p *Stocks) UnWatch(id string) {
p.Remove(id)
}
func (p *Stocks) Find_need_update_tick_ids() (pstocks PStockSlice) {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
for i, l := 0, len(p.stocks); i < l; i++ {
if atomic.LoadInt32(&p.stocks[i].loaded) < 2 {
continue
}
pstocks = append(pstocks, p.stocks[i])
}
return
}
func (p *Stocks) play_next_tick() {
p.rwmutex.RLock()
defer p.rwmutex.RUnlock()
for i, l := 0, len(p.stocks); i < l; i++ {
if atomic.LoadInt32(&p.stocks[i].loaded) < 2 {
continue
}
if atomic.LoadInt32(&p.stocks[i].count) < 1 {
continue
}
p.stocks[i].rw.Lock()
if p.stocks[i].Ticks.play == nil || len(p.stocks[i].Ticks.play) < 1 {
p.stocks[i].Ticks.play = p.stocks[i].Ticks.Data
p.stocks[i].Ticks.Data = []Tick{}
if len(p.stocks[i].Ticks.play) > 240 {
p.stocks[i].Ticks.Data = p.stocks[i].Ticks.play[:240]
}
}
lplay := len(p.stocks[i].Ticks.play)
ldata := len(p.stocks[i].Ticks.Data)
if ldata < lplay {
p.stocks[i].Ticks.Data = p.stocks[i].Ticks.play[:ldata+1]
p.stocks[i].Merge(false, p.store)
p.res(p.stocks[i])
}
p.stocks[i].rw.Unlock()
}
}
func (p *Stocks) Ticks_update_real() {
var wg sync.WaitGroup
stocks := p.Find_need_update_tick_ids()
l := len(stocks)
if l < 1 {
return
}
for i := 0; i < l; {
var b bytes.Buffer
var pstocks PStockSlice
step := 50
if i+step < l {
pstocks = stocks[i : i+step]
} else {
pstocks = stocks[i:l]
}
for j := 0; j < step && i < l; i, j = i+1, j+1 {
if b.Len() > 0 {
b.WriteString(",")
}
b.WriteString(stocks[i].Id)
}
if b.Len() < 1 {
continue
}
wg.Add(1)
go func(ids string, pstocks PStockSlice) {
defer wg.Done()
body := robot.Tick_download_real_from_sina(ids)
if body == nil {
return
}
for _, line := range bytes.Split(body, []byte("\";")) {
line = bytes.TrimSpace(line)
info := bytes.Split(line, []byte("=\""))
if len(info) != 2 {
continue
}
prefix := "var hq_str_"
if !bytes.HasPrefix(info[0], []byte(prefix)) {
continue
}
id := info[0][len(prefix):]
if idx, ok := pstocks.Search(string(id)); ok {
if pstocks[idx].tick_get_real(info[1]) {
pstocks[idx].Merge(false, p.store)
p.res(pstocks[idx])
}
}
}
}(b.String(), pstocks)
}
wg.Wait()
}
func StockHash(id string) int {
for i, c := range []byte(id) {
if c >= '0' && c <= '9' {
i, _ = strconv.Atoi(id[i:])
return i
}
}
return 0
}
func (p *Stock) Merge(day bool, store store.Store) {
m1_fresh_index := p.Ticks2M1s()
m5_fresh_index := p.M5s.MergeFrom(&p.M1s, false, Minute5end)
m30_fresh_index := p.M30s.MergeFrom(&p.M1s, false, Minute30end)
if day {
p.Ticks.clean()
td, _ := store.LoadMacd(p.Id, L1, p.M1s.start)
p.M1s.Macd(m1_fresh_index, td)
store.SaveMacds(p.Id, L1, p.M1s.Data)
td, _ = store.LoadMacd(p.Id, L5, p.M1s.start)
p.M5s.Macd(m5_fresh_index, td)
store.SaveMacds(p.Id, L5, p.M5s.Data)
td, _ = store.LoadMacd(p.Id, L30, p.M1s.start)
p.M30s.Macd(m30_fresh_index, td)
store.SaveMacds(p.Id, L30, p.M30s.Data)
} else {
p.M1s.Macd(m1_fresh_index, nil)
p.M5s.Macd(m5_fresh_index, nil)
p.M30s.Macd(m30_fresh_index, nil)
}
p.M1s.ParseChan()
p.M5s.ParseChan()
p.M30s.ParseChan()
if day {
p.Weeks.MergeFrom(&p.Days, true, Weekend)
p.Months.MergeFrom(&p.Days, true, Monthend)
td, _ := store.LoadMacd(p.Id, LDay, p.Days.start)
p.Days.Macd(0, td)
store.SaveMacds(p.Id, LDay, p.Days.Data)
td, _ = store.LoadMacd(p.Id, LWeek, p.Days.start)
p.Weeks.Macd(0, td)
store.SaveMacds(p.Id, LWeek, p.Weeks.Data)
td, _ = store.LoadMacd(p.Id, LMonth, p.Days.start)
p.Months.Macd(0, td)
store.SaveMacds(p.Id, LMonth, p.Months.Data)
p.Days.ParseChan()
p.Weeks.ParseChan()
p.Months.ParseChan()
}
}
func (p *Tdatas) ParseChan() {
if p.base == nil {
p.ParseTyping()
p.Typing.LinkTyping()
p.ParseSegment()
p.Segment.LinkTyping()
}
p.ParseHub()
p.LinkHub()
}
func (p *Stock) Update(store store.Store, play bool) bool {
if !atomic.CompareAndSwapInt32(&p.loaded, 0, 1) {
return false
}
p.Days_update(store)
p.Ticks_update(store)
p.Ticks_today_update()
if play {
glog.Warningln("WITH PLAY MODE")
} else {
p.Merge(true, store)
}
atomic.StoreInt32(&p.loaded, 2)
return true
}
func (p *Stock) days_download(t time.Time) ([]int, error) {
inds := []int{}
tds, err := robot.Days_download(p.Id, t)
if err != nil {
return inds, err
}
for i, count := 0, len(tds); i < count; i++ {
ind, isnew := p.Days.Add(tds[i])
if isnew || ind > 0 | {
inds = append(inds, ind)
} | conditional_block | |
mod.rs | //! os_queue.register(&mut stream, event::Id(0), TcpStream::INTERESTS, RegisterOption::EDGE)?;
//! # Ok(())
//! # }
//! ```
//!
//! ### Timeout granularity
//!
//! The timeout provided to [`event::Source::blocking_poll`] will be rounded
//! up to the system clock granularity (usually 1ms), and kernel scheduling
//! delays mean that the blocking interval may be overrun by a small amount.
//!
//! ### Interrupts while polling
//!
//! Interrupts (`EINTR` in C and `io::ErrorKind::Interrupted` in Rust) are
//! **not** handled, they are returned as errors. In most cases however these
//! can simply be ignored, but it's up to the user how to deal with the "error".
//!
//! # Implementation notes
//!
//! `OsQueue` is backed by a readiness event queue provided by the operating
//! system. On all platforms a call to [`Source::poll`] is mostly just a direct
//! system call. The following system implementations back `OsQueue`:
//!
//! | OS | Selector |
//! |---------|----------|
//! | FreeBSD | [kqueue](https://www.freebsd.org/cgi/man.cgi?query=kqueue) |
//! | Linux | [epoll](http://man7.org/linux/man-pages/man7/epoll.7.html) |
//! | macOS | [kqueue](https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man2/kqueue.2.html) |
//! | NetBSD | [kqueue](http://netbsd.gw.com/cgi-bin/man-cgi?kqueue) |
//! | OpenBSD | [kqueue](https://man.openbsd.org/kqueue) |
//!
//! On all supported platforms socket operations are handled by using the system
//! queue. Platform specific extensions (e.g. [`EventedFd`]) allow accessing
//! other features provided by individual system selectors.
//!
//! [`Eventedfd`]: crate::sys::unix::EventedFd
//! [`signalfd`]: http://man7.org/linux/man-pages/man2/signalfd.2.html
use std::io;
use std::time::Duration;
use log::trace;
use crate::{event, sys};
mod awakener;
mod evented;
mod interests;
mod option;
pub mod signals;
pub use self::awakener::Awakener;
pub use self::evented::Evented;
pub use self::interests::Interests;
pub use self::option::RegisterOption;
pub use self::signals::{Signal, SignalSet, Signals};
/// Readiness event queue backed by the OS. | /// e.g. read or write.
///
/// To use this queue an [`Evented`] handle must first be registered using the
/// [`register`] method, supplying an associated id, readiness interests and
/// polling option. The [associated id] is used to associate a readiness event
/// with an `Evented` handle. The readiness [interests] defines which specific
/// operations on the handle to monitor for readiness. And the final argument,
/// [`RegisterOption`], defines how to deliver the readiness events, see
/// [`RegisterOption`] for more information.
///
/// See to [module documentation] for information.
///
/// [reading]: crate::event::Ready::READABLE
/// [writing]: crate::event::Ready::WRITABLE
/// [`register`]: OsQueue::register
/// [associated id]: event::Id
/// [interests]: Interests
/// [module documentation]: crate::os
#[derive(Debug)]
pub struct OsQueue {
selector: sys::Selector,
}
impl OsQueue {
/// Create a new OS backed readiness event queue.
///
/// This function will make a syscall to the operating system to create the
/// system selector. If this syscall fails it will return the error.
///
/// # Examples
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use std::io;
/// use std::time::Duration;
///
/// use gaea::os::OsQueue;
/// use gaea::poll;
///
/// // Create a new OS backed readiness event queue.
/// let mut os_queue = OsQueue::new()?;
///
/// // Create an event sink.
/// let mut events = Vec::new();
///
/// // Poll the queue for new readiness events.
/// // But since no `Evented` handles have been registered we'll receive no
/// // events.
/// poll::<_, io::Error>(&mut [&mut os_queue], &mut events, Some(Duration::from_millis(500)))?;
/// # Ok(())
/// # }
/// ```
pub fn new() -> io::Result<OsQueue> {
sys::Selector::new().map(|selector| OsQueue { selector })
}
/// Register an [`Evented`] handle with the `OsQueue`.
///
/// Once registered, the [`Evented`] handle will be monitored for readiness
/// state changes. When it notices a state change, it will return a
/// readiness event for the handle the next time the queue is [`polled`].
///
/// [`polled`]: crate::poll
///
/// # Arguments
///
/// `handle`: This is the handle that the `OsQueue` should monitor for
/// readiness state changes.
///
/// `id`: The caller picks a id to associate with the handle. When [`poll`]
/// returns an [event] for the handle, this id is [included]. This allows
/// the caller to map the event to its handle. The id associated with the
/// `Evented` handle can be changed at any time by calling [`reregister`].
///
/// `interests`: Specifies which operations `OsQueue` should monitor for
/// readiness. `OsQueue` will only return readiness events for operations
/// specified by this argument. If a socket is registered with [readable]
/// interests and the socket becomes writable, no event will be returned
/// from [`poll`]. The readiness interests for an `Evented` handle can be
/// changed at any time by calling [`reregister`]. Most types that
/// implemented [`Evented`] have a associated constant named `INTERESTS`
/// which provide a sane interest for that type, e.g. [`TcpStream`
/// interests] are readable and writable.
///
/// `opt`: Specifies the registration option. Just like the interests and
/// id, the option can be changed for an `Evented` handle at any time by
/// calling [`reregister`].
///
/// [`poll`]: crate::poll
/// [event]: crate::event::Event
/// [included]: crate::event::Event::id
/// [`reregister`]: OsQueue::reregister
/// [readable]: Interests::READABLE
/// [`TcpStream` interests]: crate::net::TcpStream::INTERESTS
///
/// # Notes
///
/// Unless otherwise specified, the caller should assume that once an
/// `Evented` handle is registered with a `OsQueue` instance, it is bound to
/// that `OsQueue` for the lifetime of the `Evented` handle. This remains
/// true even if the `Evented` handle is [deregistered].
///
/// [deregistered]: OsQueue::deregister
///
/// # Examples
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use std::io;
///
/// use gaea::net::TcpStream;
/// use gaea::os::{OsQueue, RegisterOption};
/// use gaea::{event, poll};
///
/// // Create a new `OsQueue` as well a containers for the events.
/// let mut os_queue = OsQueue::new()?;
/// let mut events = Vec::new();
///
/// // Create a TCP connection. `TcpStream` implements the `Evented` trait.
/// let address = "216.58.193.100:80".parse()?;
/// let mut stream = TcpStream::connect(address)?;
///
/// // Register the connection with queue.
/// os_queue.register(&mut stream, event::Id(0), TcpStream::INTERESTS, RegisterOption::EDGE)?;
///
/// // Run the event loop.
/// loop {
/// poll::<_, io::Error>(&mut [&mut os_queue], &mut events, None)?;
///
/// for event in events.drain(..) {
/// if event.id() == event::Id(0) {
/// // The TCP connection is (likely) ready for use.
/// # return Ok(());
/// }
/// }
/// }
/// # }
/// ```
pub fn register<E>(&mut self, handle: &mut E, id: event::Id, interests: Interests, opt: RegisterOption) -> io::Result<()>
| ///
/// This queue allows a program to monitor a large number of [`Evented`]
/// handles, waiting until one or more become "ready" for some class of
/// operations; e.g. [reading] or [writing]. An [`Evented`] type is considered
/// ready if it is possible to immediately perform a corresponding operation; | random_line_split |
mod.rs | interest for that type, e.g. [`TcpStream`
/// interests] are readable and writable.
///
/// `opt`: Specifies the registration option. Just like the interests and
/// id, the option can be changed for an `Evented` handle at any time by
/// calling [`reregister`].
///
/// [`poll`]: crate::poll
/// [event]: crate::event::Event
/// [included]: crate::event::Event::id
/// [`reregister`]: OsQueue::reregister
/// [readable]: Interests::READABLE
/// [`TcpStream` interests]: crate::net::TcpStream::INTERESTS
///
/// # Notes
///
/// Unless otherwise specified, the caller should assume that once an
/// `Evented` handle is registered with a `OsQueue` instance, it is bound to
/// that `OsQueue` for the lifetime of the `Evented` handle. This remains
/// true even if the `Evented` handle is [deregistered].
///
/// [deregistered]: OsQueue::deregister
///
/// # Examples
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use std::io;
///
/// use gaea::net::TcpStream;
/// use gaea::os::{OsQueue, RegisterOption};
/// use gaea::{event, poll};
///
/// // Create a new `OsQueue` as well a containers for the events.
/// let mut os_queue = OsQueue::new()?;
/// let mut events = Vec::new();
///
/// // Create a TCP connection. `TcpStream` implements the `Evented` trait.
/// let address = "216.58.193.100:80".parse()?;
/// let mut stream = TcpStream::connect(address)?;
///
/// // Register the connection with queue.
/// os_queue.register(&mut stream, event::Id(0), TcpStream::INTERESTS, RegisterOption::EDGE)?;
///
/// // Run the event loop.
/// loop {
/// poll::<_, io::Error>(&mut [&mut os_queue], &mut events, None)?;
///
/// for event in events.drain(..) {
/// if event.id() == event::Id(0) {
/// // The TCP connection is (likely) ready for use.
/// # return Ok(());
/// }
/// }
/// }
/// # }
/// ```
pub fn register<E>(&mut self, handle: &mut E, id: event::Id, interests: Interests, opt: RegisterOption) -> io::Result<()>
where E: Evented + ?Sized,
{
trace!("registering handle: id={}, interests={:?}, opt={:?}", id, interests, opt);
handle.register(self, id, interests, opt)
}
/// Re-register an `Evented` handle with `OsQueue`.
///
/// Re-registering an `Evented` handle allows changing the details of the
/// registration. Specifically, it allows updating the associated `id`,
/// `interests`, and `opt` specified in previous `register` and `reregister`
/// calls.
///
/// The `reregister` arguments **fully override** the previous values. In
/// other words, if a socket is registered with [readable] interest and the
/// call to `reregister` specifies only [writable], then read interest is no
/// longer monitored for the handle.
///
/// The `Evented` handle must have previously been registered with this
/// `OsQueue` otherwise the call to `reregister` may return an error.
///
/// See the [`register`] documentation for details about the function
/// arguments.
///
/// [readable]: Interests::READABLE
/// [writable]: Interests::WRITABLE
/// [`register`]: OsQueue::register
///
/// # Examples
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use std::io;
///
/// use gaea::{event, poll};
/// use gaea::net::TcpStream;
/// use gaea::os::{Interests, RegisterOption, OsQueue};
///
/// let mut os_queue = OsQueue::new()?;
/// let mut events = Vec::new();
///
/// // Create a TCP connection. `TcpStream` implements the `Evented` trait.
/// let address = "216.58.193.100:80".parse()?;
/// let mut stream = TcpStream::connect(address)?;
///
/// // Register the connection with `OsQueue`, only with readable interest.
/// os_queue.register(&mut stream, event::Id(0), Interests::READABLE, RegisterOption::EDGE)?;
///
/// // Reregister the connection specifying a different id and write interest
/// // instead. `RegisterOption::EDGE` must be specified even though that value
/// // is not being changed.
/// os_queue.reregister(&mut stream, event::Id(2), Interests::WRITABLE, RegisterOption::EDGE)?;
///
/// // Run the event loop.
/// loop {
/// poll::<_, io::Error>(&mut [&mut os_queue], &mut events, None)?;
///
/// for event in events.drain(..) {
/// if event.id() == event::Id(2) {
/// // The TCP connection is (likely) ready for use.
/// # return Ok(());
/// } else if event.id() == event::Id(0) {
/// // We won't receive events with the old id anymore.
/// unreachable!();
/// }
/// }
/// }
/// # }
/// ```
pub fn reregister<E>(&mut self, handle: &mut E, id: event::Id, interests: Interests, opt: RegisterOption) -> io::Result<()>
where E: Evented + ?Sized,
{
trace!("reregistering handle: id={}, interests={:?}, opt={:?}", id, interests, opt);
handle.reregister(self, id, interests, opt)
}
/// Deregister an `Evented` handle from `OsQueue`.
///
/// When an `Evented` handle is deregistered, the handle will no longer be
/// monitored for readiness state changes. Unlike disabling handles with
/// [`oneshot`], deregistering clears up any internal resources needed to
/// track the handle.
///
/// A handle can be registered again using [`register`] after it has been
/// deregistered; however, it must be passed back to the **same** `OsQueue`.
///
/// # Notes
///
/// Calling [`reregister`] after `deregister` may be work on some platforms
/// but not all. To properly re-register a handle after deregistering use
/// `register`, this works on all platforms.
///
/// [`oneshot`]: RegisterOption::ONESHOT
/// [`register`]: OsQueue::register
/// [`reregister`]: OsQueue::reregister
///
/// # Examples
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use std::io;
/// use std::time::Duration;
///
/// use gaea::{event, poll};
/// use gaea::net::TcpStream;
/// use gaea::os::{OsQueue, RegisterOption};
///
/// let mut os_queue = OsQueue::new()?;
/// let mut events = Vec::new();
///
/// // Create a TCP connection. `TcpStream` implements the `Evented` trait.
/// let address = "216.58.193.100:80".parse()?;
/// let mut stream = TcpStream::connect(address)?;
///
/// // Register the connection with `OsQueue`.
/// os_queue.register(&mut stream, event::Id(0), TcpStream::INTERESTS, RegisterOption::EDGE)?;
///
/// // Do stuff with the connection etc.
///
/// // Deregister it so the resources can be cleaned up.
/// os_queue.deregister(&mut stream)?;
///
/// // Set a timeout because we shouldn't receive any events anymore.
/// poll::<_, io::Error>(&mut [&mut os_queue], &mut events, Some(Duration::from_millis(100)))?;
/// assert!(events.is_empty());
/// # Ok(())
/// # }
/// ```
pub fn deregister<E>(&mut self, handle: &mut E) -> io::Result<()>
where E: Evented + ?Sized,
{
trace!("deregistering handle");
handle.deregister(self)
}
/// Get access to the system selector. Used by platform specific code, e.g.
/// `EventedFd`.
pub(crate) fn selector(&self) -> &sys::Selector | {
&self.selector
} | identifier_body | |
mod.rs | //! os_queue.register(&mut stream, event::Id(0), TcpStream::INTERESTS, RegisterOption::EDGE)?;
//! # Ok(())
//! # }
//! ```
//!
//! ### Timeout granularity
//!
//! The timeout provided to [`event::Source::blocking_poll`] will be rounded
//! up to the system clock granularity (usually 1ms), and kernel scheduling
//! delays mean that the blocking interval may be overrun by a small amount.
//!
//! ### Interrupts while polling
//!
//! Interrupts (`EINTR` in C and `io::ErrorKind::Interrupted` in Rust) are
//! **not** handled, they are returned as errors. In most cases however these
//! can simply be ignored, but it's up to the user how to deal with the "error".
//!
//! # Implementation notes
//!
//! `OsQueue` is backed by a readiness event queue provided by the operating
//! system. On all platforms a call to [`Source::poll`] is mostly just a direct
//! system call. The following system implementations back `OsQueue`:
//!
//! | OS | Selector |
//! |---------|----------|
//! | FreeBSD | [kqueue](https://www.freebsd.org/cgi/man.cgi?query=kqueue) |
//! | Linux | [epoll](http://man7.org/linux/man-pages/man7/epoll.7.html) |
//! | macOS | [kqueue](https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man2/kqueue.2.html) |
//! | NetBSD | [kqueue](http://netbsd.gw.com/cgi-bin/man-cgi?kqueue) |
//! | OpenBSD | [kqueue](https://man.openbsd.org/kqueue) |
//!
//! On all supported platforms socket operations are handled by using the system
//! queue. Platform specific extensions (e.g. [`EventedFd`]) allow accessing
//! other features provided by individual system selectors.
//!
//! [`Eventedfd`]: crate::sys::unix::EventedFd
//! [`signalfd`]: http://man7.org/linux/man-pages/man2/signalfd.2.html
use std::io;
use std::time::Duration;
use log::trace;
use crate::{event, sys};
mod awakener;
mod evented;
mod interests;
mod option;
pub mod signals;
pub use self::awakener::Awakener;
pub use self::evented::Evented;
pub use self::interests::Interests;
pub use self::option::RegisterOption;
pub use self::signals::{Signal, SignalSet, Signals};
/// Readiness event queue backed by the OS.
///
/// This queue allows a program to monitor a large number of [`Evented`]
/// handles, waiting until one or more become "ready" for some class of
/// operations; e.g. [reading] or [writing]. An [`Evented`] type is considered
/// ready if it is possible to immediately perform a corresponding operation;
/// e.g. read or write.
///
/// To use this queue an [`Evented`] handle must first be registered using the
/// [`register`] method, supplying an associated id, readiness interests and
/// polling option. The [associated id] is used to associate a readiness event
/// with an `Evented` handle. The readiness [interests] defines which specific
/// operations on the handle to monitor for readiness. And the final argument,
/// [`RegisterOption`], defines how to deliver the readiness events, see
/// [`RegisterOption`] for more information.
///
/// See to [module documentation] for information.
///
/// [reading]: crate::event::Ready::READABLE
/// [writing]: crate::event::Ready::WRITABLE
/// [`register`]: OsQueue::register
/// [associated id]: event::Id
/// [interests]: Interests
/// [module documentation]: crate::os
#[derive(Debug)]
pub struct | {
selector: sys::Selector,
}
impl OsQueue {
/// Create a new OS backed readiness event queue.
///
/// This function will make a syscall to the operating system to create the
/// system selector. If this syscall fails it will return the error.
///
/// # Examples
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use std::io;
/// use std::time::Duration;
///
/// use gaea::os::OsQueue;
/// use gaea::poll;
///
/// // Create a new OS backed readiness event queue.
/// let mut os_queue = OsQueue::new()?;
///
/// // Create an event sink.
/// let mut events = Vec::new();
///
/// // Poll the queue for new readiness events.
/// // But since no `Evented` handles have been registered we'll receive no
/// // events.
/// poll::<_, io::Error>(&mut [&mut os_queue], &mut events, Some(Duration::from_millis(500)))?;
/// # Ok(())
/// # }
/// ```
pub fn new() -> io::Result<OsQueue> {
sys::Selector::new().map(|selector| OsQueue { selector })
}
/// Register an [`Evented`] handle with the `OsQueue`.
///
/// Once registered, the [`Evented`] handle will be monitored for readiness
/// state changes. When it notices a state change, it will return a
/// readiness event for the handle the next time the queue is [`polled`].
///
/// [`polled`]: crate::poll
///
/// # Arguments
///
/// `handle`: This is the handle that the `OsQueue` should monitor for
/// readiness state changes.
///
/// `id`: The caller picks a id to associate with the handle. When [`poll`]
/// returns an [event] for the handle, this id is [included]. This allows
/// the caller to map the event to its handle. The id associated with the
/// `Evented` handle can be changed at any time by calling [`reregister`].
///
/// `interests`: Specifies which operations `OsQueue` should monitor for
/// readiness. `OsQueue` will only return readiness events for operations
/// specified by this argument. If a socket is registered with [readable]
/// interests and the socket becomes writable, no event will be returned
/// from [`poll`]. The readiness interests for an `Evented` handle can be
/// changed at any time by calling [`reregister`]. Most types that
/// implemented [`Evented`] have a associated constant named `INTERESTS`
/// which provide a sane interest for that type, e.g. [`TcpStream`
/// interests] are readable and writable.
///
/// `opt`: Specifies the registration option. Just like the interests and
/// id, the option can be changed for an `Evented` handle at any time by
/// calling [`reregister`].
///
/// [`poll`]: crate::poll
/// [event]: crate::event::Event
/// [included]: crate::event::Event::id
/// [`reregister`]: OsQueue::reregister
/// [readable]: Interests::READABLE
/// [`TcpStream` interests]: crate::net::TcpStream::INTERESTS
///
/// # Notes
///
/// Unless otherwise specified, the caller should assume that once an
/// `Evented` handle is registered with a `OsQueue` instance, it is bound to
/// that `OsQueue` for the lifetime of the `Evented` handle. This remains
/// true even if the `Evented` handle is [deregistered].
///
/// [deregistered]: OsQueue::deregister
///
/// # Examples
///
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use std::io;
///
/// use gaea::net::TcpStream;
/// use gaea::os::{OsQueue, RegisterOption};
/// use gaea::{event, poll};
///
/// // Create a new `OsQueue` as well a containers for the events.
/// let mut os_queue = OsQueue::new()?;
/// let mut events = Vec::new();
///
/// // Create a TCP connection. `TcpStream` implements the `Evented` trait.
/// let address = "216.58.193.100:80".parse()?;
/// let mut stream = TcpStream::connect(address)?;
///
/// // Register the connection with queue.
/// os_queue.register(&mut stream, event::Id(0), TcpStream::INTERESTS, RegisterOption::EDGE)?;
///
/// // Run the event loop.
/// loop {
/// poll::<_, io::Error>(&mut [&mut os_queue], &mut events, None)?;
///
/// for event in events.drain(..) {
/// if event.id() == event::Id(0) {
/// // The TCP connection is (likely) ready for use.
/// # return Ok(());
/// }
/// }
/// }
/// # }
/// ```
pub fn register<E>(&mut self, handle: &mut E, id: event::Id, interests: Interests, opt: RegisterOption) -> io::Result< | OsQueue | identifier_name |
data-enums.ts | auna',
}
export enum CharacterDetail {
Age = 'age',
Aliases = 'aliases',
Background = 'background',
Career = 'career',
Faction = 'faction',
Gender = 'gender',
Interest = 'interest',
Languages = 'languages',
}
export enum AptitudeType {
Cognition = 'cog',
Intuition = 'int',
Reflexes = 'ref',
Savvy = 'sav',
Somatics = 'som',
Willpower = 'wil',
}
export enum PoolType {
Insight = 'insight',
Moxie = 'moxie',
Vigor = 'vigor',
Flex = 'flex',
Threat = 'threat',
}
export enum MorphType {
Biomorph = 'biomorph',
Synthmorph = 'synthmorph',
Pod = 'pod',
// Vehicle = "vehicle",
// Bot = "bot",
// Swarm = "swarm",
// Infomorph = "infomorph"
}
export enum BiologicalType {
Biomorph = 'biomorph',
Pod = 'pod',
Create = 'creature',
}
export enum MorphCost {
GearPoints = 'gearPoints',
MorphPoints = 'morphPoints',
}
export enum Frame {
Biological = 'biological',
Robotic = 'robotic',
}
export enum Brain {
Organic = 'organic',
Synthetic = 'synthetic',
}
export enum Complexity {
Minor = 'minor',
Moderate = 'moderate',
Major = 'major',
Rare = 'rare',
}
export enum RechargeType {
Short = 'shortRecharge',
Long = 'longRecharge',
}
export enum TraitSource {
Ego = 'ego',
Morph = 'morph',
}
export enum TraitType {
Negative = 'negative',
Positive = 'positive',
}
export enum Refresh {
Daily = 'daily',
Weekly = 'weekly',
Arc = 'arc',
}
export enum PsiPush {
ExtraTarget = 'extraTarget',
IncreasedDuration = 'increasedDuration',
IncreasedEffect = 'increasedEffect',
IncreasedPenetration = 'increasedPenetration',
IncreasedPower = 'increasedPower',
IncreasedRange = 'increasedRange',
}
export enum SleightDuration {
ActionTurns = 'actionTurns',
Constant = 'constant',
Hours = 'hours',
Instant = 'instant',
Minutes = 'minutes',
Sustained = 'sustained',
}
export enum SleightType {
Chi = 'chi',
Gamma = 'gamma',
Epsilon = 'epsilon',
}
export enum SleightTarget {
Self = 'self',
BiologicalLife = 'biologicalLife',
PsiUser = 'psiUser',
}
export enum SleightSpecial {
Attack = 'attack',
Heal = 'heal',
MentalArmor = 'mentalArmor',
}
export enum SurpriseState {
None = 'none',
Alerted = 'alerted',
Surprised = 'surprised',
}
export enum PhysicalWare {
Bio = 'bioware',
Cyber = 'cyberware',
Hard = 'hardware',
Nano = 'nanoware',
}
export enum GearQuality {
TopOfTheLine = 'topOfTheLine',
StateOfTheArt = 'stateOfTheArt',
WellCrafted = 'wellCrafted',
Average = 'average',
Outdated = 'outdated',
Shoddy = 'shoddy',
InDisrepair = 'inDisrepair',
}
export enum BlueprintType {
SingleUse = 'singleUse',
LimitedUse = 'limitedUse',
MultiUse = 'multiUse',
OpenSource = 'openSource',
}
export enum DeviceType {
Mote = 'mote',
Host = 'host',
Server = 'server',
}
export enum SoftwareType {
App = 'app',
AppAsService = 'appAsService',
AppAsWare = 'appAsWare',
MeshService = 'meshService',
Meshware = 'meshware',
}
export enum Activation {
None = 'none',
Toggle = 'toggle',
Use = 'use',
}
export enum GearTrait {
Concealable = 'concealable',
Fragile = 'fragile',
SingleUse = 'singleUse',
TwoHanded = 'twoHanded',
}
export enum RangedWeaponTrait {
Fixed = 'fixed',
Long = 'long',
NoPointBlank = 'noPointBlank',
NoClose = 'noClose',
}
export enum RangeRating {
PointBlank = 'pointBlank',
Close = 'close',
Range = 'withinRange',
BeyondRange = 'beyondRange',
}
export enum RangedWeaponAccessory {
ArmSlide = 'armSlide',
ExtendedMagazine = 'extendedMagazine',
Gyromount = 'gyromount',
ImagingScope = 'imagingScope',
FlashSuppressor = 'flashSuppressor',
LaserSight = 'laserSight',
SafetySystem = 'safetySystem',
ShockSafety = 'shockSafety',
Silencer = 'silencer',
Smartlink = 'smartlink',
SmartMagazine = 'smartMagazine',
}
export enum AttackTrait {
Blinding = 'blinding',
Entangling = 'entangling',
Knockdown = 'knockdown',
Pain = 'pain',
Shock = 'shock',
Stun = 'stun',
}
export enum CharacterPoint {
Rez = 'rez',
Customization = 'customization',
Morph = 'morph',
Gear = 'gear',
Credits = 'credits',
}
export enum EgoSetting {
CanDefault = 'canDefault',
TrackMentalHealth = 'trackMentalHealth',
TrackPoints = 'trackPoints',
TrackReputations = 'trackReputations',
CharacterDetails = 'characterDetails',
ThreatDetails = 'threatDetails',
UseThreat = 'useThreat',
IgnoreOverburdened = 'ignoreOverburdened',
}
export enum ShellType {
SynthMorph = 'synthmorph',
Vehicle = 'vehicle',
Bot = 'bot',
}
export enum VehicleType {
Aircraft = 'aircraft',
Exoskeleton = 'exoskeleton',
GroundCraft = 'groundcraft',
Hardsuit = 'hardsuit',
Hybrid = 'hybrid',
NauticalCraft = 'nauticalCraft',
PersonalTransportDevice = 'personalTransportDevice',
Spacecraft = 'spacecraft',
}
export enum BotType {
Combat = 'combat',
Exploration = 'exploration',
Medical = 'medical',
Personal = 'personal',
Recon = 'recon',
Utility = 'utility',
}
export enum ShellHostType {
ALI = 'aliOnly',
Cyberbrain = 'cyberbrain',
}
export enum SubstanceType {
Chemical = 'chemical',
Drug = 'drug',
Toxin = 'toxin',
}
export enum SubstanceClassification {
Biochem = 'biochem',
Nano = 'nano',
Electronic = 'electronic',
}
export enum SubstanceApplicationMethod {
Dermal = 'dermal',
Inhalation = 'inhalation',
Injected = 'injection',
Oral = 'oral',
}
export enum DrugAddiction {
Mental = 'mental',
Physical = 'physical',
Both = 'mental/physical',
}
export enum DrugCategory {
Cognitive = 'cognitive',
Combat = 'combat',
Health = 'health',
Nano = 'nanodrug',
Narco = 'narcoalgorithm',
Petal = 'petal',
Psi = 'psi',
Recreational = 'recreational',
Social = 'social',
}
export enum ExplosiveSize {
Micro = 'micro',
Mini = 'mini', |
export enum ExplosiveType {
Grenade = 'grenade',
Missile = 'missile',
Generic = 'generic',
}
export enum AreaEffectType {
Uniform = 'uniform',
Centered = 'centered',
Cone = 'cone',
}
export enum CalledShot {
BypassArmor = 'bypassArmor',
Disarm = 'disarm',
Knockdown = 'knockdown',
Redirect = 'redirect',
SpecificTarget = 'specificTarget',
}
export enum WeaponAttackType {
Primary = 'primaryAttack',
Secondary = 'secondaryAttack',
}
export enum PoolEffectUsability {
UsableTwice = 'usableTwice',
Disable = 'disable',
}
export enum PhysicalServiceType {
Generic = 'generic',
FakeId = 'fakeEgoId',
}
export enum KineticWeaponClass {
HoldoutPistol = 'holdoutPistol',
MediumPistol = 'mediumPistol',
HeavyPistol = 'heavyPistol',
MachinePistol = 'machinePistol',
SubmachineGun = 'submachineGun',
AssaultRifle = 'assaultRifle',
BattleRifle = 'battleRifle',
MachineGun = 'machineGun',
SniperRifle = 'sniperRifle',
}
export enum FirearmAmmoModifierType {
Formula = 'formula',
Halve = 'halve',
NoDamage = 'noDamage',
}
export enum SprayPayload {
CoatAmmunition = 'coatAmmunition',
FirePayload = 'firePayload',
}
export enum ExplosiveTrigger {
Airburst = 'airburst',
Impact = 'impact',
Proximity = 'proximity',
Signal = 'signal',
| Standard = 'standard',
} | random_line_split |
data-enums.ts |
return existing;
};
export enum Fork {
Alpha = 'alpha',
Beta = 'beta',
Gamma = 'gamma',
}
export enum ThreatInfo {
Classification = 'classification',
Niche = 'niche',
Numbers = 'numbers',
StressValue = 'stressValue',
MinStressValue = 'minStressValue',
ThreatLevel = 'threatLevel',
}
export enum ThreatLevel {
Yellow = 'yellow',
Orange = 'orange',
Red = 'red',
Ultraviolet = 'ultraviolet',
}
export enum MinStressOption {
None = 'none',
Half = 'half',
Value = 'value',
}
export enum EgoType {
AGI = 'agi',
ALI = 'ali',
ASI = 'asi',
Alien = 'alien',
Exhuman = 'exhuman',
Exsurgent = 'exsurgent',
Neogenetic = 'neogenetic',
Titan = 'titan',
Transhuman = 'transhuman',
Uplift = 'uplift',
Xenofauna = 'xenofauna',
}
export enum CharacterDetail {
Age = 'age',
Aliases = 'aliases',
Background = 'background',
Career = 'career',
Faction = 'faction',
Gender = 'gender',
Interest = 'interest',
Languages = 'languages',
}
export enum AptitudeType {
Cognition = 'cog',
Intuition = 'int',
Reflexes = 'ref',
Savvy = 'sav',
Somatics = 'som',
Willpower = 'wil',
}
export enum PoolType {
Insight = 'insight',
Moxie = 'moxie',
Vigor = 'vigor',
Flex = 'flex',
Threat = 'threat',
}
export enum MorphType {
Biomorph = 'biomorph',
Synthmorph = 'synthmorph',
Pod = 'pod',
// Vehicle = "vehicle",
// Bot = "bot",
// Swarm = "swarm",
// Infomorph = "infomorph"
}
export enum BiologicalType {
Biomorph = 'biomorph',
Pod = 'pod',
Create = 'creature',
}
export enum MorphCost {
GearPoints = 'gearPoints',
MorphPoints = 'morphPoints',
}
export enum Frame {
Biological = 'biological',
Robotic = 'robotic',
}
export enum Brain {
Organic = 'organic',
Synthetic = 'synthetic',
}
export enum Complexity {
Minor = 'minor',
Moderate = 'moderate',
Major = 'major',
Rare = 'rare',
}
export enum RechargeType {
Short = 'shortRecharge',
Long = 'longRecharge',
}
export enum TraitSource {
Ego = 'ego',
Morph = 'morph',
}
export enum TraitType {
Negative = 'negative',
Positive = 'positive',
}
export enum Refresh {
Daily = 'daily',
Weekly = 'weekly',
Arc = 'arc',
}
export enum PsiPush {
ExtraTarget = 'extraTarget',
IncreasedDuration = 'increasedDuration',
IncreasedEffect = 'increasedEffect',
IncreasedPenetration = 'increasedPenetration',
IncreasedPower = 'increasedPower',
IncreasedRange = 'increasedRange',
}
export enum SleightDuration {
ActionTurns = 'actionTurns',
Constant = 'constant',
Hours = 'hours',
Instant = 'instant',
Minutes = 'minutes',
Sustained = 'sustained',
}
export enum SleightType {
Chi = 'chi',
Gamma = 'gamma',
Epsilon = 'epsilon',
}
export enum SleightTarget {
Self = 'self',
BiologicalLife = 'biologicalLife',
PsiUser = 'psiUser',
}
export enum SleightSpecial {
Attack = 'attack',
Heal = 'heal',
MentalArmor = 'mentalArmor',
}
export enum SurpriseState {
None = 'none',
Alerted = 'alerted',
Surprised = 'surprised',
}
export enum PhysicalWare {
Bio = 'bioware',
Cyber = 'cyberware',
Hard = 'hardware',
Nano = 'nanoware',
}
export enum GearQuality {
TopOfTheLine = 'topOfTheLine',
StateOfTheArt = 'stateOfTheArt',
WellCrafted = 'wellCrafted',
Average = 'average',
Outdated = 'outdated',
Shoddy = 'shoddy',
InDisrepair = 'inDisrepair',
}
export enum BlueprintType {
SingleUse = 'singleUse',
LimitedUse = 'limitedUse',
MultiUse = 'multiUse',
OpenSource = 'openSource',
}
export enum DeviceType {
Mote = 'mote',
Host = 'host',
Server = 'server',
}
export enum SoftwareType {
App = 'app',
AppAsService = 'appAsService',
AppAsWare = 'appAsWare',
MeshService = 'meshService',
Meshware = 'meshware',
}
export enum Activation {
None = 'none',
Toggle = 'toggle',
Use = 'use',
}
export enum GearTrait {
Concealable = 'concealable',
Fragile = 'fragile',
SingleUse = 'singleUse',
TwoHanded = 'twoHanded',
}
export enum RangedWeaponTrait {
Fixed = 'fixed',
Long = 'long',
NoPointBlank = 'noPointBlank',
NoClose = 'noClose',
}
export enum RangeRating {
PointBlank = 'pointBlank',
Close = 'close',
Range = 'withinRange',
BeyondRange = 'beyondRange',
}
export enum RangedWeaponAccessory {
ArmSlide = 'armSlide',
ExtendedMagazine = 'extendedMagazine',
Gyromount = 'gyromount',
ImagingScope = 'imagingScope',
FlashSuppressor = 'flashSuppressor',
LaserSight = 'laserSight',
SafetySystem = 'safetySystem',
ShockSafety = 'shockSafety',
Silencer = 'silencer',
Smartlink = 'smartlink',
SmartMagazine = 'smartMagazine',
}
export enum AttackTrait {
Blinding = 'blinding',
Entangling = 'entangling',
Knockdown = 'knockdown',
Pain = 'pain',
Shock = 'shock',
Stun = 'stun',
}
export enum CharacterPoint {
Rez = 'rez',
Customization = 'customization',
Morph = 'morph',
Gear = 'gear',
Credits = 'credits',
}
export enum EgoSetting {
CanDefault = 'canDefault',
TrackMentalHealth = 'trackMentalHealth',
TrackPoints = 'trackPoints',
TrackReputations = 'trackReputations',
CharacterDetails = 'characterDetails',
ThreatDetails = 'threatDetails',
UseThreat = 'useThreat',
IgnoreOverburdened = 'ignoreOverburdened',
}
export enum ShellType {
SynthMorph = 'synthmorph',
Vehicle = 'vehicle',
Bot = 'bot',
}
export enum VehicleType {
Aircraft = 'aircraft',
Exoskeleton = 'exoskeleton',
GroundCraft = 'groundcraft',
Hardsuit = 'hardsuit',
Hybrid = 'hybrid',
NauticalCraft = 'nauticalCraft',
PersonalTransportDevice = 'personalTransportDevice',
Spacecraft = 'spacecraft',
}
export enum BotType {
Combat = 'combat',
Exploration = 'exploration',
Medical = 'medical',
Personal = 'personal',
Recon = 'recon',
Utility = 'utility',
}
export enum ShellHostType {
ALI = 'aliOnly',
Cyberbrain = 'cyberbrain',
}
export enum SubstanceType {
Chemical = 'chemical',
Drug = 'drug',
Toxin = 'toxin',
}
export enum SubstanceClassification {
Biochem = 'biochem',
Nano = 'nano',
Electronic = 'electronic',
}
export enum SubstanceApplicationMethod {
Dermal = 'dermal',
Inhalation = 'inhalation',
Injected = 'injection',
Oral = 'oral',
}
export enum DrugAddiction {
Mental = 'mental',
Physical = 'physical',
Both = 'mental/physical',
}
export enum DrugCategory {
Cognitive = 'cognitive',
Combat = 'combat',
Health = 'health',
Nano = 'nanodrug',
Narco = 'narcoalgorithm',
Petal = 'petal',
Psi = 'psi',
Recreational = 'recreational',
Social = 'social',
}
export enum ExplosiveSize {
Micro = 'micro',
Mini = 'mini',
Standard = 'standard',
}
export enum ExplosiveType {
Grenade = 'grenade',
Missile = 'missile',
Generic = 'generic',
}
export enum AreaEffectType {
Uniform = 'uniform',
Centered = 'centered',
Cone = 'cone',
}
export enum CalledShot {
BypassArmor = 'bypassArmor',
Disarm = 'disarm',
Knockdown = 'knockdown',
Redirect = 'redirect',
SpecificTarget = 'specificTarget',
}
export enum WeaponAttackType {
| {
existing = Object.freeze(Object.values(o));
valuedEnums.set(o, existing);
} | conditional_block | |
config.go | "
configRootKubernetes = "kubernetes"
configRootManifest = "manifest"
configRootGo = "go"
configRootGenerate = "generate"
configRootResources = "resources"
configRootAssemblies = "assemblies"
configRootBinaries = "artifactory"
// bootstrap.yml
configRootAppInfo = "info.app"
configRootServer = "server"
// Output directories
configOutputRootPath = "dist/root"
configAssemblyPath = "dist/assembly"
configTestPath = "test"
)
var (
defaultConfigs = map[string]string{
"spring.application.name": "build",
"msx.platform.includegroups": "com.cisco.**",
"msx.platform.swaggerartifact": "com.cisco.nfv:nfv-swagger",
"msx.platform.swaggerwebjar": "org.webjars:swagger-ui:3.23.11",
"msx.deploymentGroup": "${spring.application.name}",
"build.number": "SNAPSHOT",
"build.group": "com.cisco.msx",
"manifest.folder": "Build-Stable",
"kubernetes.group": "platformms",
"docker.dockerfile": "docker/Dockerfile", // TODO: v1.0.0: switch to default 'build/package/Dockerfile'
"docker.baseimage": "msx-base-buster:3.9.0-70",
"docker.repository": "dockerhub.cisco.com/vms-platform-dev-docker",
"docker.username": "",
"docker.password": "",
"go.env.all.GOPRIVATE": "cto-github.cisco.com/NFV-BU",
"go.env.all.GOPROXY": "https://engci-maven.cisco.com/artifactory/go/,https://proxy.golang.org,direct",
"go.env.linux.GOFLAGS": `-buildmode=pie -i -ldflags="-extldflags=-Wl,-z,now,-z,relro" -ldflags=-s -ldflags=-w`,
"go.env.darwin.GOFLAGS": `-i`,
"library.name": "",
"assemblies.root": "platform-common",
"artifactory.assemblies": "true",
"artifactory.repository": "https://engci-maven-master.cisco.com/artifactory/symphony-group/vms-3.0-binaries",
"artifactory.installer": "deployments/kubernetes",
"artifactory.username": "",
"artifactory.password": "",
}
)
type AppInfo struct {
Name string
Attributes struct {
DisplayName string
}
}
type Server struct {
Port int
ContextPath string
StaticPath string
}
func (p Server) PortString() string {
return strconv.Itoa(p.Port)
}
type Executable struct {
Cmd string // refers to `cmd/<name>/main.go`
ConfigFiles []string
}
type Library struct {
Name string
}
type Go struct {
Env struct {
All map[string]string
Linux map[string]string
Darwin map[string]string
}
}
func (g Go) Environment() map[string]string {
result := make(map[string]string)
copyMap := func(source map[string]string) {
for k, v := range source {
result[k] = v
}
}
copyMap(g.Env.All)
switch runtime.GOOS {
case "linux":
copyMap(g.Env.Linux)
case "darwin":
copyMap(g.Env.Darwin)
}
return result
}
type MsxParams struct {
Release string
Platform struct {
ParentArtifacts []string
SwaggerArtifact string
SwaggerWebJar string
Version string
IncludeGroups string
}
DeploymentGroup string
}
type Build struct {
Number string
Group string
}
type Manifest struct {
Folder string
}
type Docker struct {
Dockerfile string
BaseImage string
Repository string
Username string
Password string
}
type Kubernetes struct {
Group string
}
type Generate struct {
Path string
Command string `config:"default="`
VfsGen *GenerateVfs
}
type GenerateVfs struct {
Root string `config:"default="`
Filename string `config:"default=assets.go"`
VariableName string `config:"default=assets"`
Includes []string
Excludes []string `config:"default="`
}
// TODO: 1.0 : Move to format similar to Generate
type Resources struct {
Includes []string
Excludes []string
Mappings []PathMapping
}
type PathMapping struct {
From string
To string
}
type Assemblies struct {
Root string
Custom []Assembly
}
type Assembly struct {
Path string // Source path of files
PathPrefix string // Add leading path in archive
ManifestPrefix string // Leading name of archive
ManifestKey string // Output path in json manifest
Includes []string `config:"default=/**/*"`
Excludes []string
}
func (a Assembly) filename() string {
return fmt.Sprintf("%s-%s.tar", a.ManifestPrefix, BuildConfig.FullBuildNumber())
}
func (a Assembly) OutputFile() string {
return filepath.Join(BuildConfig.AssemblyPath(), a.filename())
}
func (a Assembly) PublishUrl() string {
return path.Join(BuildConfig.BinariesUrl(), a.filename())
}
type Binaries struct {
Assemblies bool // Include all assemblies in binaries publishing
Installer string // Folder with more installer binaries
Repository string // Root URL of artifactory binaries repository
Username string // Injected from Jenkins credentials store via ARTIFACTORY_USERNAME
Password string // Injected from Jenkins credentials store via ARTIFACTORY_PASSWORD
}
func (b Binaries) Authorization() string {
return "Basic " + base64.StdEncoding.EncodeToString([]byte(b.Username+":"+b.Password))
}
type Config struct {
Timestamp time.Time
Library Library
Msx MsxParams
Go Go
Executable Executable
Build Build
App AppInfo
Server Server
Docker Docker
Kubernetes Kubernetes
Manifest Manifest
Generate []Generate
Resources Resources
Assemblies Assemblies
Binaries Binaries
Fs *fs.FileSystemConfig
Cfg *config.Config
}
func (p Config) FullBuildNumber() string {
return fmt.Sprintf("%s-%s", p.Msx.Release, p.Build.Number)
}
func (p Config) OutputRoot() string {
return configOutputRootPath
}
func (p Config) TestPath() string {
return configTestPath
}
func (p Config) AssemblyPath() string {
return configAssemblyPath
}
func (p Config) InputCommandRoot() string {
return path.Join("cmd", p.Executable.Cmd)
}
func (p Config) | () string {
return strconv.Itoa(p.Server.Port)
}
func (p Config) OutputConfigPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Configs)
}
func (p Config) OutputResourcesPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Resources)
}
func (p Config) OutputBinaryPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Binaries)
}
func (p Config) OutputStaticPath() string {
return path.Join(p.OutputResourcesPath(), "www")
}
func (p Config) BinariesUrl() string {
return path.Join(
BuildConfig.Binaries.Repository,
BuildConfig.Msx.DeploymentGroup,
BuildConfig.FullBuildNumber())
}
var BuildConfig = new(Config)
func LoadAppBuildConfig(ctx context.Context, cfg *config.Config, providers []config.Provider) (finalConfig *config.Config, err error) {
if err = cfg.Populate(&BuildConfig.Msx, configRootMsx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Executable, configRootExecutable); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Build, configRootBuild); err != nil {
return
}
for _, v := range BuildConfig.Executable.ConfigFiles {
filePath := path.Join(BuildConfig.InputCommandRoot(), v)
fileProvider := config.NewFileProvider(v, filePath)
providers = append(providers, fileProvider)
}
cfg = config.NewConfig(providers...)
if err = cfg.Load(ctx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.App, configRootAppInfo); err != nil {
return
}
// Set the spring app name if it is not set
springAppName, _ := cfg.StringOr("spring.application.name", "build")
if springAppName == "build" {
defaultConfigs["spring.application.name"] = BuildConfig.App.Name
_ = cfg.Load(ctx)
}
if err = cfg.Populate(&BuildConfig.Server, configRootServer); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Docker, configRootDocker); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Kubernetes, config | Port | identifier_name |
config.go | "
configRootKubernetes = "kubernetes"
configRootManifest = "manifest"
configRootGo = "go"
configRootGenerate = "generate"
configRootResources = "resources"
configRootAssemblies = "assemblies"
configRootBinaries = "artifactory"
// bootstrap.yml
configRootAppInfo = "info.app"
configRootServer = "server"
// Output directories
configOutputRootPath = "dist/root"
configAssemblyPath = "dist/assembly"
configTestPath = "test"
)
var (
defaultConfigs = map[string]string{
"spring.application.name": "build",
"msx.platform.includegroups": "com.cisco.**",
"msx.platform.swaggerartifact": "com.cisco.nfv:nfv-swagger",
"msx.platform.swaggerwebjar": "org.webjars:swagger-ui:3.23.11",
"msx.deploymentGroup": "${spring.application.name}",
"build.number": "SNAPSHOT",
"build.group": "com.cisco.msx",
"manifest.folder": "Build-Stable",
"kubernetes.group": "platformms",
"docker.dockerfile": "docker/Dockerfile", // TODO: v1.0.0: switch to default 'build/package/Dockerfile'
"docker.baseimage": "msx-base-buster:3.9.0-70",
"docker.repository": "dockerhub.cisco.com/vms-platform-dev-docker",
"docker.username": "",
"docker.password": "",
"go.env.all.GOPRIVATE": "cto-github.cisco.com/NFV-BU",
"go.env.all.GOPROXY": "https://engci-maven.cisco.com/artifactory/go/,https://proxy.golang.org,direct",
"go.env.linux.GOFLAGS": `-buildmode=pie -i -ldflags="-extldflags=-Wl,-z,now,-z,relro" -ldflags=-s -ldflags=-w`,
"go.env.darwin.GOFLAGS": `-i`,
"library.name": "",
"assemblies.root": "platform-common",
"artifactory.assemblies": "true",
"artifactory.repository": "https://engci-maven-master.cisco.com/artifactory/symphony-group/vms-3.0-binaries",
"artifactory.installer": "deployments/kubernetes",
"artifactory.username": "",
"artifactory.password": "",
}
)
type AppInfo struct {
Name string
Attributes struct {
DisplayName string
}
}
type Server struct {
Port int
ContextPath string
StaticPath string
}
func (p Server) PortString() string {
return strconv.Itoa(p.Port)
}
type Executable struct {
Cmd string // refers to `cmd/<name>/main.go`
ConfigFiles []string
}
type Library struct {
Name string
}
type Go struct {
Env struct {
All map[string]string
Linux map[string]string
Darwin map[string]string
}
}
func (g Go) Environment() map[string]string {
result := make(map[string]string)
copyMap := func(source map[string]string) {
for k, v := range source {
result[k] = v
}
}
copyMap(g.Env.All)
switch runtime.GOOS {
case "linux":
copyMap(g.Env.Linux)
case "darwin":
copyMap(g.Env.Darwin)
}
return result
}
type MsxParams struct {
Release string
Platform struct {
ParentArtifacts []string
SwaggerArtifact string
SwaggerWebJar string
Version string
IncludeGroups string
}
DeploymentGroup string
}
type Build struct {
Number string
Group string
}
type Manifest struct {
Folder string
}
type Docker struct {
Dockerfile string
BaseImage string
Repository string
Username string
Password string
}
type Kubernetes struct {
Group string
}
type Generate struct {
Path string
Command string `config:"default="`
VfsGen *GenerateVfs
}
type GenerateVfs struct {
Root string `config:"default="`
Filename string `config:"default=assets.go"`
VariableName string `config:"default=assets"`
Includes []string
Excludes []string `config:"default="`
}
// TODO: 1.0 : Move to format similar to Generate
type Resources struct {
Includes []string
Excludes []string
Mappings []PathMapping
}
type PathMapping struct {
From string
To string
}
type Assemblies struct {
Root string
Custom []Assembly
}
type Assembly struct {
Path string // Source path of files
PathPrefix string // Add leading path in archive
ManifestPrefix string // Leading name of archive
ManifestKey string // Output path in json manifest
Includes []string `config:"default=/**/*"`
Excludes []string
}
func (a Assembly) filename() string {
return fmt.Sprintf("%s-%s.tar", a.ManifestPrefix, BuildConfig.FullBuildNumber())
}
func (a Assembly) OutputFile() string {
return filepath.Join(BuildConfig.AssemblyPath(), a.filename())
}
func (a Assembly) PublishUrl() string {
return path.Join(BuildConfig.BinariesUrl(), a.filename())
}
type Binaries struct {
Assemblies bool // Include all assemblies in binaries publishing
Installer string // Folder with more installer binaries
Repository string // Root URL of artifactory binaries repository
Username string // Injected from Jenkins credentials store via ARTIFACTORY_USERNAME
Password string // Injected from Jenkins credentials store via ARTIFACTORY_PASSWORD
}
func (b Binaries) Authorization() string {
return "Basic " + base64.StdEncoding.EncodeToString([]byte(b.Username+":"+b.Password))
}
type Config struct {
Timestamp time.Time
Library Library
Msx MsxParams
Go Go
Executable Executable
Build Build
App AppInfo
Server Server
Docker Docker
Kubernetes Kubernetes
Manifest Manifest
Generate []Generate
Resources Resources
Assemblies Assemblies
Binaries Binaries
Fs *fs.FileSystemConfig
Cfg *config.Config
}
func (p Config) FullBuildNumber() string |
func (p Config) OutputRoot() string {
return configOutputRootPath
}
func (p Config) TestPath() string {
return configTestPath
}
func (p Config) AssemblyPath() string {
return configAssemblyPath
}
func (p Config) InputCommandRoot() string {
return path.Join("cmd", p.Executable.Cmd)
}
func (p Config) Port() string {
return strconv.Itoa(p.Server.Port)
}
func (p Config) OutputConfigPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Configs)
}
func (p Config) OutputResourcesPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Resources)
}
func (p Config) OutputBinaryPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Binaries)
}
func (p Config) OutputStaticPath() string {
return path.Join(p.OutputResourcesPath(), "www")
}
func (p Config) BinariesUrl() string {
return path.Join(
BuildConfig.Binaries.Repository,
BuildConfig.Msx.DeploymentGroup,
BuildConfig.FullBuildNumber())
}
var BuildConfig = new(Config)
func LoadAppBuildConfig(ctx context.Context, cfg *config.Config, providers []config.Provider) (finalConfig *config.Config, err error) {
if err = cfg.Populate(&BuildConfig.Msx, configRootMsx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Executable, configRootExecutable); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Build, configRootBuild); err != nil {
return
}
for _, v := range BuildConfig.Executable.ConfigFiles {
filePath := path.Join(BuildConfig.InputCommandRoot(), v)
fileProvider := config.NewFileProvider(v, filePath)
providers = append(providers, fileProvider)
}
cfg = config.NewConfig(providers...)
if err = cfg.Load(ctx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.App, configRootAppInfo); err != nil {
return
}
// Set the spring app name if it is not set
springAppName, _ := cfg.StringOr("spring.application.name", "build")
if springAppName == "build" {
defaultConfigs["spring.application.name"] = BuildConfig.App.Name
_ = cfg.Load(ctx)
}
if err = cfg.Populate(&BuildConfig.Server, configRootServer); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Docker, configRootDocker); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Kubernetes, | {
return fmt.Sprintf("%s-%s", p.Msx.Release, p.Build.Number)
} | identifier_body |
config.go | docker"
configRootKubernetes = "kubernetes"
configRootManifest = "manifest"
configRootGo = "go"
configRootGenerate = "generate"
configRootResources = "resources"
configRootAssemblies = "assemblies"
configRootBinaries = "artifactory"
// bootstrap.yml
configRootAppInfo = "info.app"
configRootServer = "server"
// Output directories
configOutputRootPath = "dist/root"
configAssemblyPath = "dist/assembly"
configTestPath = "test"
)
var (
defaultConfigs = map[string]string{
"spring.application.name": "build",
"msx.platform.includegroups": "com.cisco.**",
"msx.platform.swaggerartifact": "com.cisco.nfv:nfv-swagger",
"msx.platform.swaggerwebjar": "org.webjars:swagger-ui:3.23.11",
"msx.deploymentGroup": "${spring.application.name}",
"build.number": "SNAPSHOT",
"build.group": "com.cisco.msx",
"manifest.folder": "Build-Stable",
"kubernetes.group": "platformms",
"docker.dockerfile": "docker/Dockerfile", // TODO: v1.0.0: switch to default 'build/package/Dockerfile'
"docker.baseimage": "msx-base-buster:3.9.0-70",
"docker.repository": "dockerhub.cisco.com/vms-platform-dev-docker",
"docker.username": "",
"docker.password": "",
"go.env.all.GOPRIVATE": "cto-github.cisco.com/NFV-BU",
"go.env.all.GOPROXY": "https://engci-maven.cisco.com/artifactory/go/,https://proxy.golang.org,direct",
"go.env.linux.GOFLAGS": `-buildmode=pie -i -ldflags="-extldflags=-Wl,-z,now,-z,relro" -ldflags=-s -ldflags=-w`,
"go.env.darwin.GOFLAGS": `-i`,
"library.name": "",
"assemblies.root": "platform-common",
"artifactory.assemblies": "true",
"artifactory.repository": "https://engci-maven-master.cisco.com/artifactory/symphony-group/vms-3.0-binaries",
"artifactory.installer": "deployments/kubernetes",
"artifactory.username": "",
"artifactory.password": "",
}
)
type AppInfo struct {
Name string
Attributes struct {
DisplayName string
}
}
type Server struct {
Port int
ContextPath string
StaticPath string
}
func (p Server) PortString() string {
return strconv.Itoa(p.Port)
}
type Executable struct {
Cmd string // refers to `cmd/<name>/main.go`
ConfigFiles []string
}
type Library struct {
Name string
}
type Go struct {
Env struct {
All map[string]string
Linux map[string]string
Darwin map[string]string
}
}
func (g Go) Environment() map[string]string {
result := make(map[string]string)
copyMap := func(source map[string]string) {
for k, v := range source {
result[k] = v
}
}
copyMap(g.Env.All)
switch runtime.GOOS {
case "linux":
copyMap(g.Env.Linux)
case "darwin":
copyMap(g.Env.Darwin)
}
return result
}
type MsxParams struct {
Release string
Platform struct {
ParentArtifacts []string
SwaggerArtifact string
SwaggerWebJar string
Version string
IncludeGroups string
}
DeploymentGroup string
}
type Build struct {
Number string
Group string
}
type Manifest struct {
Folder string
}
type Docker struct {
Dockerfile string
BaseImage string
Repository string
Username string
Password string
}
type Kubernetes struct {
Group string
}
type Generate struct {
Path string
Command string `config:"default="`
VfsGen *GenerateVfs
}
type GenerateVfs struct {
Root string `config:"default="`
Filename string `config:"default=assets.go"`
VariableName string `config:"default=assets"`
Includes []string
Excludes []string `config:"default="`
}
// TODO: 1.0 : Move to format similar to Generate
type Resources struct {
Includes []string
Excludes []string
Mappings []PathMapping
}
type PathMapping struct {
From string
To string
}
type Assemblies struct {
Root string
Custom []Assembly
}
type Assembly struct {
Path string // Source path of files
PathPrefix string // Add leading path in archive
ManifestPrefix string // Leading name of archive
ManifestKey string // Output path in json manifest
Includes []string `config:"default=/**/*"`
Excludes []string
}
func (a Assembly) filename() string {
return fmt.Sprintf("%s-%s.tar", a.ManifestPrefix, BuildConfig.FullBuildNumber())
}
func (a Assembly) OutputFile() string {
return filepath.Join(BuildConfig.AssemblyPath(), a.filename())
}
func (a Assembly) PublishUrl() string {
return path.Join(BuildConfig.BinariesUrl(), a.filename())
}
type Binaries struct {
Assemblies bool // Include all assemblies in binaries publishing
Installer string // Folder with more installer binaries
Repository string // Root URL of artifactory binaries repository
Username string // Injected from Jenkins credentials store via ARTIFACTORY_USERNAME
Password string // Injected from Jenkins credentials store via ARTIFACTORY_PASSWORD
}
func (b Binaries) Authorization() string {
return "Basic " + base64.StdEncoding.EncodeToString([]byte(b.Username+":"+b.Password))
}
type Config struct {
Timestamp time.Time
Library Library
Msx MsxParams
Go Go
Executable Executable
Build Build
App AppInfo
Server Server
Docker Docker
Kubernetes Kubernetes
Manifest Manifest
Generate []Generate
Resources Resources
Assemblies Assemblies
Binaries Binaries
Fs *fs.FileSystemConfig
Cfg *config.Config
}
func (p Config) FullBuildNumber() string {
return fmt.Sprintf("%s-%s", p.Msx.Release, p.Build.Number)
}
func (p Config) OutputRoot() string {
return configOutputRootPath
}
func (p Config) TestPath() string {
return configTestPath
}
func (p Config) AssemblyPath() string {
return configAssemblyPath
}
func (p Config) InputCommandRoot() string {
return path.Join("cmd", p.Executable.Cmd)
}
func (p Config) Port() string {
return strconv.Itoa(p.Server.Port)
}
func (p Config) OutputConfigPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Configs)
}
func (p Config) OutputResourcesPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Resources)
}
func (p Config) OutputBinaryPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Binaries)
}
func (p Config) OutputStaticPath() string {
return path.Join(p.OutputResourcesPath(), "www")
}
func (p Config) BinariesUrl() string {
return path.Join(
BuildConfig.Binaries.Repository,
BuildConfig.Msx.DeploymentGroup,
BuildConfig.FullBuildNumber())
}
var BuildConfig = new(Config)
func LoadAppBuildConfig(ctx context.Context, cfg *config.Config, providers []config.Provider) (finalConfig *config.Config, err error) {
if err = cfg.Populate(&BuildConfig.Msx, configRootMsx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Executable, configRootExecutable); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Build, configRootBuild); err != nil {
return
}
for _, v := range BuildConfig.Executable.ConfigFiles {
filePath := path.Join(BuildConfig.InputCommandRoot(), v)
fileProvider := config.NewFileProvider(v, filePath)
providers = append(providers, fileProvider)
}
cfg = config.NewConfig(providers...)
if err = cfg.Load(ctx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.App, configRootAppInfo); err != nil {
return
}
// Set the spring app name if it is not set
springAppName, _ := cfg.StringOr("spring.application.name", "build") | _ = cfg.Load(ctx)
}
if err = cfg.Populate(&BuildConfig.Server, configRootServer); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Docker, configRootDocker); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Kubernetes, configRoot | if springAppName == "build" {
defaultConfigs["spring.application.name"] = BuildConfig.App.Name | random_line_split |
config.go | "
configRootKubernetes = "kubernetes"
configRootManifest = "manifest"
configRootGo = "go"
configRootGenerate = "generate"
configRootResources = "resources"
configRootAssemblies = "assemblies"
configRootBinaries = "artifactory"
// bootstrap.yml
configRootAppInfo = "info.app"
configRootServer = "server"
// Output directories
configOutputRootPath = "dist/root"
configAssemblyPath = "dist/assembly"
configTestPath = "test"
)
var (
defaultConfigs = map[string]string{
"spring.application.name": "build",
"msx.platform.includegroups": "com.cisco.**",
"msx.platform.swaggerartifact": "com.cisco.nfv:nfv-swagger",
"msx.platform.swaggerwebjar": "org.webjars:swagger-ui:3.23.11",
"msx.deploymentGroup": "${spring.application.name}",
"build.number": "SNAPSHOT",
"build.group": "com.cisco.msx",
"manifest.folder": "Build-Stable",
"kubernetes.group": "platformms",
"docker.dockerfile": "docker/Dockerfile", // TODO: v1.0.0: switch to default 'build/package/Dockerfile'
"docker.baseimage": "msx-base-buster:3.9.0-70",
"docker.repository": "dockerhub.cisco.com/vms-platform-dev-docker",
"docker.username": "",
"docker.password": "",
"go.env.all.GOPRIVATE": "cto-github.cisco.com/NFV-BU",
"go.env.all.GOPROXY": "https://engci-maven.cisco.com/artifactory/go/,https://proxy.golang.org,direct",
"go.env.linux.GOFLAGS": `-buildmode=pie -i -ldflags="-extldflags=-Wl,-z,now,-z,relro" -ldflags=-s -ldflags=-w`,
"go.env.darwin.GOFLAGS": `-i`,
"library.name": "",
"assemblies.root": "platform-common",
"artifactory.assemblies": "true",
"artifactory.repository": "https://engci-maven-master.cisco.com/artifactory/symphony-group/vms-3.0-binaries",
"artifactory.installer": "deployments/kubernetes",
"artifactory.username": "",
"artifactory.password": "",
}
)
type AppInfo struct {
Name string
Attributes struct {
DisplayName string
}
}
type Server struct {
Port int
ContextPath string
StaticPath string
}
func (p Server) PortString() string {
return strconv.Itoa(p.Port)
}
type Executable struct {
Cmd string // refers to `cmd/<name>/main.go`
ConfigFiles []string
}
type Library struct {
Name string
}
type Go struct {
Env struct {
All map[string]string
Linux map[string]string
Darwin map[string]string
}
}
func (g Go) Environment() map[string]string {
result := make(map[string]string)
copyMap := func(source map[string]string) {
for k, v := range source {
result[k] = v
}
}
copyMap(g.Env.All)
switch runtime.GOOS {
case "linux":
copyMap(g.Env.Linux)
case "darwin":
copyMap(g.Env.Darwin)
}
return result
}
type MsxParams struct {
Release string
Platform struct {
ParentArtifacts []string
SwaggerArtifact string
SwaggerWebJar string
Version string
IncludeGroups string
}
DeploymentGroup string
}
type Build struct {
Number string
Group string
}
type Manifest struct {
Folder string
}
type Docker struct {
Dockerfile string
BaseImage string
Repository string
Username string
Password string
}
type Kubernetes struct {
Group string
}
type Generate struct {
Path string
Command string `config:"default="`
VfsGen *GenerateVfs
}
type GenerateVfs struct {
Root string `config:"default="`
Filename string `config:"default=assets.go"`
VariableName string `config:"default=assets"`
Includes []string
Excludes []string `config:"default="`
}
// TODO: 1.0 : Move to format similar to Generate
type Resources struct {
Includes []string
Excludes []string
Mappings []PathMapping
}
type PathMapping struct {
From string
To string
}
type Assemblies struct {
Root string
Custom []Assembly
}
type Assembly struct {
Path string // Source path of files
PathPrefix string // Add leading path in archive
ManifestPrefix string // Leading name of archive
ManifestKey string // Output path in json manifest
Includes []string `config:"default=/**/*"`
Excludes []string
}
func (a Assembly) filename() string {
return fmt.Sprintf("%s-%s.tar", a.ManifestPrefix, BuildConfig.FullBuildNumber())
}
func (a Assembly) OutputFile() string {
return filepath.Join(BuildConfig.AssemblyPath(), a.filename())
}
func (a Assembly) PublishUrl() string {
return path.Join(BuildConfig.BinariesUrl(), a.filename())
}
type Binaries struct {
Assemblies bool // Include all assemblies in binaries publishing
Installer string // Folder with more installer binaries
Repository string // Root URL of artifactory binaries repository
Username string // Injected from Jenkins credentials store via ARTIFACTORY_USERNAME
Password string // Injected from Jenkins credentials store via ARTIFACTORY_PASSWORD
}
func (b Binaries) Authorization() string {
return "Basic " + base64.StdEncoding.EncodeToString([]byte(b.Username+":"+b.Password))
}
type Config struct {
Timestamp time.Time
Library Library
Msx MsxParams
Go Go
Executable Executable
Build Build
App AppInfo
Server Server
Docker Docker
Kubernetes Kubernetes
Manifest Manifest
Generate []Generate
Resources Resources
Assemblies Assemblies
Binaries Binaries
Fs *fs.FileSystemConfig
Cfg *config.Config
}
func (p Config) FullBuildNumber() string {
return fmt.Sprintf("%s-%s", p.Msx.Release, p.Build.Number)
}
func (p Config) OutputRoot() string {
return configOutputRootPath
}
func (p Config) TestPath() string {
return configTestPath
}
func (p Config) AssemblyPath() string {
return configAssemblyPath
}
func (p Config) InputCommandRoot() string {
return path.Join("cmd", p.Executable.Cmd)
}
func (p Config) Port() string {
return strconv.Itoa(p.Server.Port)
}
func (p Config) OutputConfigPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Configs)
}
func (p Config) OutputResourcesPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Resources)
}
func (p Config) OutputBinaryPath() string {
return path.Join(configOutputRootPath, p.Fs.Root, p.Fs.Binaries)
}
func (p Config) OutputStaticPath() string {
return path.Join(p.OutputResourcesPath(), "www")
}
func (p Config) BinariesUrl() string {
return path.Join(
BuildConfig.Binaries.Repository,
BuildConfig.Msx.DeploymentGroup,
BuildConfig.FullBuildNumber())
}
var BuildConfig = new(Config)
func LoadAppBuildConfig(ctx context.Context, cfg *config.Config, providers []config.Provider) (finalConfig *config.Config, err error) {
if err = cfg.Populate(&BuildConfig.Msx, configRootMsx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Executable, configRootExecutable); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Build, configRootBuild); err != nil {
return
}
for _, v := range BuildConfig.Executable.ConfigFiles {
filePath := path.Join(BuildConfig.InputCommandRoot(), v)
fileProvider := config.NewFileProvider(v, filePath)
providers = append(providers, fileProvider)
}
cfg = config.NewConfig(providers...)
if err = cfg.Load(ctx); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.App, configRootAppInfo); err != nil |
// Set the spring app name if it is not set
springAppName, _ := cfg.StringOr("spring.application.name", "build")
if springAppName == "build" {
defaultConfigs["spring.application.name"] = BuildConfig.App.Name
_ = cfg.Load(ctx)
}
if err = cfg.Populate(&BuildConfig.Server, configRootServer); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Docker, configRootDocker); err != nil {
return
}
if err = cfg.Populate(&BuildConfig.Kubernetes, | {
return
} | conditional_block |
scan.go | repo is empty", repo.Name)
}
// load up alternative config if possible, if not use manager's config
if repo.Manager.Opts.RepoConfig |
scanTimeStart := time.Now()
// See https://github.com/zricethezav/gitleaks/issues/326
// Scan commit patches, all files at a commit, or a range of commits
if repo.Manager.Opts.Commit != "" {
return scanCommit(repo.Manager.Opts.Commit, repo, scanCommitPatches)
} else if repo.Manager.Opts.FilesAtCommit != "" {
return scanCommit(repo.Manager.Opts.FilesAtCommit, repo, scanFilesAtCommit)
} else if repo.Manager.Opts.Commits != "" {
commits := strings.Split(repo.Manager.Opts.Commits, ",")
for _, c := range commits {
err := scanCommit(c, repo, scanCommitPatches)
if err != nil {
return err
}
}
return nil
} else if repo.Manager.Opts.CommitsFile != "" {
file, err := os.Open(repo.Manager.Opts.CommitsFile)
if err != nil {
return err
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
err := scanCommit(scanner.Text(), repo, scanCommitPatches)
if err != nil {
return err
}
}
return nil
}
logOpts, err := getLogOptions(repo)
if err != nil {
return err
}
cIter, err := repo.Log(logOpts)
if err != nil {
return err
}
cc := 0
semaphore := make(chan bool, howManyThreads(repo.Manager.Opts.Threads))
wg := sync.WaitGroup{}
err = cIter.ForEach(func(c *object.Commit) error {
if c == nil || repo.timeoutReached() || repo.depthReached(cc) {
return storer.ErrStop
}
// Check if Commit is allowlisted
if isCommitAllowListed(c.Hash.String(), repo.config.Allowlist.Commits) {
return nil
}
// Check if at root
if len(c.ParentHashes) == 0 {
cc++
err = scanFilesAtCommit(c, repo)
if err != nil {
return err
}
return nil
}
// increase Commit counter
cc++
// inspect first parent only as all other parents will be eventually reached
// (they exist as the tip of other branches, etc)
// See https://github.com/zricethezav/gitleaks/issues/413 for details
parent, err := c.Parent(0)
if err != nil {
return err
}
defer func() {
if err := recover(); err != nil {
// sometimes the Patch generation will fail due to a known bug in
// sergi's go-diff: https://github.com/sergi/go-diff/issues/89.
// Once a fix has been merged I will remove this recover.
return
}
}()
if repo.timeoutReached() {
return nil
}
if parent == nil {
// shouldn't reach this point but just in case
return nil
}
start := time.Now()
patch, err := parent.Patch(c)
if err != nil {
log.Errorf("could not generate Patch")
}
repo.Manager.RecordTime(manager.PatchTime(howLong(start)))
wg.Add(1)
semaphore <- true
go func(c *object.Commit, patch *object.Patch) {
defer func() {
<-semaphore
wg.Done()
}()
scanPatch(patch, c, repo)
}(c, patch)
if c.Hash.String() == repo.Manager.Opts.CommitTo {
return storer.ErrStop
}
return nil
})
wg.Wait()
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
repo.Manager.IncrementCommits(cc)
return nil
}
// scanEmpty scans an empty repo without any commits. See https://github.com/zricethezav/gitleaks/issues/352
func (repo *Repo) scanEmpty() error {
scanTimeStart := time.Now()
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
if err != nil {
return err
}
for fn := range status {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
repo.CheckRules(&Bundle{
Content: workTreeBuf.String(),
FilePath: workTreeFile.Name(),
Commit: emptyCommit(),
scanType: uncommittedScan,
})
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scanUncommitted will do a `git diff` and scan changed files that are being tracked. This is useful functionality
// for a pre-Commit hook so you can make sure your code does not have any leaks before committing.
func (repo *Repo) scanUncommitted() error {
// load up alternative config if possible, if not use manager's config
if repo.Manager.Opts.RepoConfig {
cfg, err := repo.loadRepoConfig()
if err != nil {
return err
}
repo.config = cfg
}
if err := repo.setupTimeout(); err != nil {
return err
}
r, err := repo.Head()
if err == plumbing.ErrReferenceNotFound {
// possibly an empty repo, or maybe its not, either way lets scan all the files in the directory
return repo.scanEmpty()
} else if err != nil {
return err
}
scanTimeStart := time.Now()
c, err := repo.CommitObject(r.Hash())
if err != nil {
return err
}
// Staged change so the Commit details do not yet exist. Insert empty defaults.
c.Hash = plumbing.Hash{}
c.Message = "***STAGED CHANGES***"
c.Author.Name = ""
c.Author.Email = ""
c.Author.When = time.Unix(0, 0).UTC()
prevTree, err := c.Tree()
if err != nil {
return err
}
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
for fn, state := range status {
var (
prevFileContents string
currFileContents string
filename string
)
if state.Staging != git.Untracked {
if state.Staging == git.Deleted {
// file in staging has been deleted, aka it is not on the filesystem
// so the contents of the file are ""
currFileContents = ""
} else {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
currFileContents = workTreeBuf.String()
filename = workTreeFile.Name()
}
// get files at HEAD state
prevFile, err := prevTree.File(fn)
if err != nil {
prevFileContents = ""
} else {
prevFileContents, err = prevFile.Contents()
if err != nil {
return err
}
if filename == "" {
filename = prevFile.Name
}
}
dmp := diffmatchpatch.New()
diffs := dmp.DiffCleanupSemantic(dmp.DiffMain(prevFileContents, currFileContents, false))
var diffContents string
for _, d := range diffs {
if d.Type == diffmatchpatch.DiffInsert {
diffContents += fmt.Sprintf("%s\n", d.Text)
}
}
repo.CheckRules(&Bundle{
Content: diffContents,
FilePath: filename,
Commit: c,
scanType: uncommittedScan,
})
}
}
if err != nil {
return err
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scan accepts a Patch, Commit, and repo. If the patches contains files that are
// binary, then gitleaks will skip scanning that file OR if a file is matched on
// allowlisted files set in the configuration. If a global rule for files is defined and a filename
// matches said global rule, then a leak is sent to the manager.
// After that, file chunks are created which are then inspected by InspectString()
func scanPatch(patch *object.Patch, c *object.Commit, repo *Repo) {
bundle := Bundle{
Commit: c,
Patch: patch.String(),
scanType: patchScan,
}
for _, f := range patch.FilePatches() {
if repo.timeoutReached() {
return
}
if f.Is | {
cfg, err := repo.loadRepoConfig()
if err != nil {
return err
}
repo.config = cfg
} | conditional_block |
scan.go | }()
if repo.timeoutReached() {
return nil
}
if parent == nil {
// shouldn't reach this point but just in case
return nil
}
start := time.Now()
patch, err := parent.Patch(c)
if err != nil {
log.Errorf("could not generate Patch")
}
repo.Manager.RecordTime(manager.PatchTime(howLong(start)))
wg.Add(1)
semaphore <- true
go func(c *object.Commit, patch *object.Patch) {
defer func() {
<-semaphore
wg.Done()
}()
scanPatch(patch, c, repo)
}(c, patch)
if c.Hash.String() == repo.Manager.Opts.CommitTo {
return storer.ErrStop
}
return nil
})
wg.Wait()
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
repo.Manager.IncrementCommits(cc)
return nil
}
// scanEmpty scans an empty repo without any commits. See https://github.com/zricethezav/gitleaks/issues/352
func (repo *Repo) scanEmpty() error {
scanTimeStart := time.Now()
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
if err != nil {
return err
}
for fn := range status {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
repo.CheckRules(&Bundle{
Content: workTreeBuf.String(),
FilePath: workTreeFile.Name(),
Commit: emptyCommit(),
scanType: uncommittedScan,
})
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scanUncommitted will do a `git diff` and scan changed files that are being tracked. This is useful functionality
// for a pre-Commit hook so you can make sure your code does not have any leaks before committing.
func (repo *Repo) scanUncommitted() error {
// load up alternative config if possible, if not use manager's config
if repo.Manager.Opts.RepoConfig {
cfg, err := repo.loadRepoConfig()
if err != nil {
return err
}
repo.config = cfg
}
if err := repo.setupTimeout(); err != nil {
return err
}
r, err := repo.Head()
if err == plumbing.ErrReferenceNotFound {
// possibly an empty repo, or maybe its not, either way lets scan all the files in the directory
return repo.scanEmpty()
} else if err != nil {
return err
}
scanTimeStart := time.Now()
c, err := repo.CommitObject(r.Hash())
if err != nil {
return err
}
// Staged change so the Commit details do not yet exist. Insert empty defaults.
c.Hash = plumbing.Hash{}
c.Message = "***STAGED CHANGES***"
c.Author.Name = ""
c.Author.Email = ""
c.Author.When = time.Unix(0, 0).UTC()
prevTree, err := c.Tree()
if err != nil {
return err
}
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
for fn, state := range status {
var (
prevFileContents string
currFileContents string
filename string
)
if state.Staging != git.Untracked {
if state.Staging == git.Deleted {
// file in staging has been deleted, aka it is not on the filesystem
// so the contents of the file are ""
currFileContents = ""
} else {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
currFileContents = workTreeBuf.String()
filename = workTreeFile.Name()
}
// get files at HEAD state
prevFile, err := prevTree.File(fn)
if err != nil {
prevFileContents = ""
} else {
prevFileContents, err = prevFile.Contents()
if err != nil {
return err
}
if filename == "" {
filename = prevFile.Name
}
}
dmp := diffmatchpatch.New()
diffs := dmp.DiffCleanupSemantic(dmp.DiffMain(prevFileContents, currFileContents, false))
var diffContents string
for _, d := range diffs {
if d.Type == diffmatchpatch.DiffInsert {
diffContents += fmt.Sprintf("%s\n", d.Text)
}
}
repo.CheckRules(&Bundle{
Content: diffContents,
FilePath: filename,
Commit: c,
scanType: uncommittedScan,
})
}
}
if err != nil {
return err
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scan accepts a Patch, Commit, and repo. If the patches contains files that are
// binary, then gitleaks will skip scanning that file OR if a file is matched on
// allowlisted files set in the configuration. If a global rule for files is defined and a filename
// matches said global rule, then a leak is sent to the manager.
// After that, file chunks are created which are then inspected by InspectString()
func scanPatch(patch *object.Patch, c *object.Commit, repo *Repo) {
bundle := Bundle{
Commit: c,
Patch: patch.String(),
scanType: patchScan,
}
for _, f := range patch.FilePatches() {
if repo.timeoutReached() {
return
}
if f.IsBinary() {
continue
}
for _, chunk := range f.Chunks() {
if chunk.Type() == fdiff.Add || (repo.Manager.Opts.Deletion && chunk.Type() == fdiff.Delete) {
bundle.Content = chunk.Content()
bundle.Operation = chunk.Type()
// get filepath
from, to := f.Files()
if from != nil {
bundle.FilePath = from.Path()
} else if to != nil {
bundle.FilePath = to.Path()
} else {
bundle.FilePath = "???"
}
repo.CheckRules(&bundle)
}
}
}
}
// scanCommit accepts a Commit hash, repo, and commit scanning function. A new Commit
// object will be created from the hash which will be passed into either scanCommitPatches
// or scanFilesAtCommit depending on the options set.
func scanCommit(commit string, repo *Repo, f commitScanner) error {
if commit == "latest" {
ref, err := repo.Repository.Head()
if err != nil {
return err
}
commit = ref.Hash().String()
}
repo.Manager.IncrementCommits(1)
h := plumbing.NewHash(commit)
c, err := repo.CommitObject(h)
if err != nil {
return err
}
return f(c, repo)
}
// scanCommitPatches accepts a Commit object and a repo. This function is only called when the --Commit=
// option has been set. That option tells gitleaks to look only at a single Commit and check the contents
// of said Commit. Similar to scan(), if the files contained in the Commit are a binaries or if they are
// allowlisted then those files will be skipped.
func scanCommitPatches(c *object.Commit, repo *Repo) error {
if len(c.ParentHashes) == 0 {
err := scanFilesAtCommit(c, repo)
if err != nil {
return err
}
}
return c.Parents().ForEach(func(parent *object.Commit) error {
defer func() {
if err := recover(); err != nil {
// sometimes the Patch generation will fail due to a known bug in
// sergi's go-diff: https://github.com/sergi/go-diff/issues/89.
// Once a fix has been merged I will remove this recover.
return
}
}()
if repo.timeoutReached() {
return nil
}
if parent == nil {
return nil
}
start := time.Now()
patch, err := parent.Patch(c)
if err != nil {
return fmt.Errorf("could not generate Patch")
}
repo.Manager.RecordTime(manager.PatchTime(howLong(start)))
scanPatch(patch, c, repo)
return nil
})
}
// scanFilesAtCommit accepts a Commit object and a repo. This function is only called when the --files-at-Commit=
// option has been set. That option tells gitleaks to look only at ALL the files at a Commit and check the contents
// of said Commit. Similar to scan(), if the files contained in the Commit are a binaries or if they are
// allowlisted then those files will be skipped.
func | scanFilesAtCommit | identifier_name | |
scan.go |
scanTimeStart := time.Now()
// See https://github.com/zricethezav/gitleaks/issues/326
// Scan commit patches, all files at a commit, or a range of commits
if repo.Manager.Opts.Commit != "" {
return scanCommit(repo.Manager.Opts.Commit, repo, scanCommitPatches)
} else if repo.Manager.Opts.FilesAtCommit != "" {
return scanCommit(repo.Manager.Opts.FilesAtCommit, repo, scanFilesAtCommit)
} else if repo.Manager.Opts.Commits != "" {
commits := strings.Split(repo.Manager.Opts.Commits, ",")
for _, c := range commits {
err := scanCommit(c, repo, scanCommitPatches)
if err != nil {
return err
}
}
return nil
} else if repo.Manager.Opts.CommitsFile != "" {
file, err := os.Open(repo.Manager.Opts.CommitsFile)
if err != nil {
return err
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
err := scanCommit(scanner.Text(), repo, scanCommitPatches)
if err != nil {
return err
}
}
return nil
}
logOpts, err := getLogOptions(repo)
if err != nil {
return err
}
cIter, err := repo.Log(logOpts)
if err != nil {
return err
}
cc := 0
semaphore := make(chan bool, howManyThreads(repo.Manager.Opts.Threads))
wg := sync.WaitGroup{}
err = cIter.ForEach(func(c *object.Commit) error {
if c == nil || repo.timeoutReached() || repo.depthReached(cc) {
return storer.ErrStop
}
// Check if Commit is allowlisted
if isCommitAllowListed(c.Hash.String(), repo.config.Allowlist.Commits) {
return nil
}
// Check if at root
if len(c.ParentHashes) == 0 {
cc++
err = scanFilesAtCommit(c, repo)
if err != nil {
return err
}
return nil
}
// increase Commit counter
cc++
// inspect first parent only as all other parents will be eventually reached
// (they exist as the tip of other branches, etc)
// See https://github.com/zricethezav/gitleaks/issues/413 for details
parent, err := c.Parent(0)
if err != nil {
return err
}
defer func() {
if err := recover(); err != nil {
// sometimes the Patch generation will fail due to a known bug in
// sergi's go-diff: https://github.com/sergi/go-diff/issues/89.
// Once a fix has been merged I will remove this recover.
return
}
}()
if repo.timeoutReached() {
return nil
}
if parent == nil {
// shouldn't reach this point but just in case
return nil
}
start := time.Now()
patch, err := parent.Patch(c)
if err != nil {
log.Errorf("could not generate Patch")
}
repo.Manager.RecordTime(manager.PatchTime(howLong(start)))
wg.Add(1)
semaphore <- true
go func(c *object.Commit, patch *object.Patch) {
defer func() {
<-semaphore
wg.Done()
}()
scanPatch(patch, c, repo)
}(c, patch)
if c.Hash.String() == repo.Manager.Opts.CommitTo {
return storer.ErrStop
}
return nil
})
wg.Wait()
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
repo.Manager.IncrementCommits(cc)
return nil
}
// scanEmpty scans an empty repo without any commits. See https://github.com/zricethezav/gitleaks/issues/352
func (repo *Repo) scanEmpty() error {
scanTimeStart := time.Now()
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
if err != nil {
return err
}
for fn := range status {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
repo.CheckRules(&Bundle{
Content: workTreeBuf.String(),
FilePath: workTreeFile.Name(),
Commit: emptyCommit(),
scanType: uncommittedScan,
})
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scanUncommitted will do a `git diff` and scan changed files that are being tracked. This is useful functionality
// for a pre-Commit hook so you can make sure your code does not have any leaks before committing.
func (repo *Repo) scanUncommitted() error {
// load up alternative config if possible, if not use manager's config
if repo.Manager.Opts.RepoConfig {
cfg, err := repo.loadRepoConfig()
if err != nil {
return err
}
repo.config = cfg
}
if err := repo.setupTimeout(); err != nil {
return err
}
r, err := repo.Head()
if err == plumbing.ErrReferenceNotFound {
// possibly an empty repo, or maybe its not, either way lets scan all the files in the directory
return repo.scanEmpty()
} else if err != nil {
return err
}
scanTimeStart := time.Now()
c, err := repo.CommitObject(r.Hash())
if err != nil {
return err
}
// Staged change so the Commit details do not yet exist. Insert empty defaults.
c.Hash = plumbing.Hash{}
c.Message = "***STAGED CHANGES***"
c.Author.Name = ""
c.Author.Email = ""
c.Author.When = time.Unix(0, 0).UTC()
prevTree, err := c.Tree()
if err != nil {
return err
}
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
for fn, state := range status {
var (
prevFileContents string
currFileContents string
filename string
)
if state.Staging != git.Untracked {
if state.Staging == git.Deleted {
// file in staging has been deleted, aka it is not on the filesystem
// so the contents of the file are ""
currFileContents = ""
} else {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
currFileContents = workTreeBuf.String()
filename = workTreeFile.Name()
}
// get files at HEAD state
prevFile, err := prevTree.File(fn)
if err != nil {
prevFileContents = ""
} else {
prevFileContents, err = prevFile.Contents()
if err != nil {
return err
}
if filename == "" {
filename = prevFile.Name
}
}
dmp := diffmatchpatch.New()
diffs := dmp.DiffCleanupSemantic(dmp.DiffMain(prevFileContents, currFileContents, false))
var diffContents string
for _, d := range diffs {
if d.Type == diffmatchpatch.DiffInsert {
diffContents += fmt.Sprintf("%s\n", d.Text)
}
}
repo.CheckRules(&Bundle{
Content: diffContents,
FilePath: filename,
Commit: c,
scanType: uncommittedScan,
})
}
}
if err != nil {
return err
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scan accepts a Patch, Commit, and repo. If the patches contains files that are
// binary, then gitleaks will skip scanning that file OR if a file is matched on
// allowlisted files set in the configuration. If a global rule for files is defined and a filename
// matches said global rule, then a leak is sent to the manager.
// After that, file chunks are created which are then inspected by InspectString()
func scanPatch(patch *object.Patch, c *object.Commit, repo *Repo) {
bundle := Bundle{
Commit: c,
Patch: | {
if err := repo.setupTimeout(); err != nil {
return err
}
if repo.cancel != nil {
defer repo.cancel()
}
if repo.Repository == nil {
return fmt.Errorf("%s repo is empty", repo.Name)
}
// load up alternative config if possible, if not use manager's config
if repo.Manager.Opts.RepoConfig {
cfg, err := repo.loadRepoConfig()
if err != nil {
return err
}
repo.config = cfg
} | identifier_body | |
scan.go | s repo is empty", repo.Name)
}
// load up alternative config if possible, if not use manager's config
if repo.Manager.Opts.RepoConfig {
cfg, err := repo.loadRepoConfig()
if err != nil {
return err
}
repo.config = cfg
}
scanTimeStart := time.Now()
// See https://github.com/zricethezav/gitleaks/issues/326
// Scan commit patches, all files at a commit, or a range of commits
if repo.Manager.Opts.Commit != "" {
return scanCommit(repo.Manager.Opts.Commit, repo, scanCommitPatches)
} else if repo.Manager.Opts.FilesAtCommit != "" {
return scanCommit(repo.Manager.Opts.FilesAtCommit, repo, scanFilesAtCommit)
} else if repo.Manager.Opts.Commits != "" {
commits := strings.Split(repo.Manager.Opts.Commits, ",")
for _, c := range commits {
err := scanCommit(c, repo, scanCommitPatches)
if err != nil {
return err
}
}
return nil
} else if repo.Manager.Opts.CommitsFile != "" {
file, err := os.Open(repo.Manager.Opts.CommitsFile)
if err != nil {
return err
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
err := scanCommit(scanner.Text(), repo, scanCommitPatches)
if err != nil {
return err
}
}
return nil
}
logOpts, err := getLogOptions(repo)
if err != nil {
return err
}
cIter, err := repo.Log(logOpts)
if err != nil {
return err
}
cc := 0
semaphore := make(chan bool, howManyThreads(repo.Manager.Opts.Threads))
wg := sync.WaitGroup{}
err = cIter.ForEach(func(c *object.Commit) error {
if c == nil || repo.timeoutReached() || repo.depthReached(cc) {
return storer.ErrStop
}
// Check if Commit is allowlisted
if isCommitAllowListed(c.Hash.String(), repo.config.Allowlist.Commits) {
return nil
}
// Check if at root
if len(c.ParentHashes) == 0 {
cc++
err = scanFilesAtCommit(c, repo)
if err != nil {
return err
}
return nil
}
// increase Commit counter
cc++
// inspect first parent only as all other parents will be eventually reached
// (they exist as the tip of other branches, etc)
// See https://github.com/zricethezav/gitleaks/issues/413 for details
parent, err := c.Parent(0)
if err != nil {
return err
}
defer func() {
if err := recover(); err != nil {
// sometimes the Patch generation will fail due to a known bug in
// sergi's go-diff: https://github.com/sergi/go-diff/issues/89.
// Once a fix has been merged I will remove this recover.
return
}
}()
if repo.timeoutReached() {
return nil
}
if parent == nil {
// shouldn't reach this point but just in case
return nil
}
start := time.Now()
patch, err := parent.Patch(c)
if err != nil {
log.Errorf("could not generate Patch")
}
repo.Manager.RecordTime(manager.PatchTime(howLong(start)))
wg.Add(1)
semaphore <- true | wg.Done()
}()
scanPatch(patch, c, repo)
}(c, patch)
if c.Hash.String() == repo.Manager.Opts.CommitTo {
return storer.ErrStop
}
return nil
})
wg.Wait()
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
repo.Manager.IncrementCommits(cc)
return nil
}
// scanEmpty scans an empty repo without any commits. See https://github.com/zricethezav/gitleaks/issues/352
func (repo *Repo) scanEmpty() error {
scanTimeStart := time.Now()
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
if err != nil {
return err
}
for fn := range status {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
repo.CheckRules(&Bundle{
Content: workTreeBuf.String(),
FilePath: workTreeFile.Name(),
Commit: emptyCommit(),
scanType: uncommittedScan,
})
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scanUncommitted will do a `git diff` and scan changed files that are being tracked. This is useful functionality
// for a pre-Commit hook so you can make sure your code does not have any leaks before committing.
func (repo *Repo) scanUncommitted() error {
// load up alternative config if possible, if not use manager's config
if repo.Manager.Opts.RepoConfig {
cfg, err := repo.loadRepoConfig()
if err != nil {
return err
}
repo.config = cfg
}
if err := repo.setupTimeout(); err != nil {
return err
}
r, err := repo.Head()
if err == plumbing.ErrReferenceNotFound {
// possibly an empty repo, or maybe its not, either way lets scan all the files in the directory
return repo.scanEmpty()
} else if err != nil {
return err
}
scanTimeStart := time.Now()
c, err := repo.CommitObject(r.Hash())
if err != nil {
return err
}
// Staged change so the Commit details do not yet exist. Insert empty defaults.
c.Hash = plumbing.Hash{}
c.Message = "***STAGED CHANGES***"
c.Author.Name = ""
c.Author.Email = ""
c.Author.When = time.Unix(0, 0).UTC()
prevTree, err := c.Tree()
if err != nil {
return err
}
wt, err := repo.Worktree()
if err != nil {
return err
}
status, err := wt.Status()
for fn, state := range status {
var (
prevFileContents string
currFileContents string
filename string
)
if state.Staging != git.Untracked {
if state.Staging == git.Deleted {
// file in staging has been deleted, aka it is not on the filesystem
// so the contents of the file are ""
currFileContents = ""
} else {
workTreeBuf := bytes.NewBuffer(nil)
workTreeFile, err := wt.Filesystem.Open(fn)
if err != nil {
continue
}
if _, err := io.Copy(workTreeBuf, workTreeFile); err != nil {
return err
}
currFileContents = workTreeBuf.String()
filename = workTreeFile.Name()
}
// get files at HEAD state
prevFile, err := prevTree.File(fn)
if err != nil {
prevFileContents = ""
} else {
prevFileContents, err = prevFile.Contents()
if err != nil {
return err
}
if filename == "" {
filename = prevFile.Name
}
}
dmp := diffmatchpatch.New()
diffs := dmp.DiffCleanupSemantic(dmp.DiffMain(prevFileContents, currFileContents, false))
var diffContents string
for _, d := range diffs {
if d.Type == diffmatchpatch.DiffInsert {
diffContents += fmt.Sprintf("%s\n", d.Text)
}
}
repo.CheckRules(&Bundle{
Content: diffContents,
FilePath: filename,
Commit: c,
scanType: uncommittedScan,
})
}
}
if err != nil {
return err
}
repo.Manager.RecordTime(manager.ScanTime(howLong(scanTimeStart)))
return nil
}
// scan accepts a Patch, Commit, and repo. If the patches contains files that are
// binary, then gitleaks will skip scanning that file OR if a file is matched on
// allowlisted files set in the configuration. If a global rule for files is defined and a filename
// matches said global rule, then a leak is sent to the manager.
// After that, file chunks are created which are then inspected by InspectString()
func scanPatch(patch *object.Patch, c *object.Commit, repo *Repo) {
bundle := Bundle{
Commit: c,
Patch: patch.String(),
scanType: patchScan,
}
for _, f := range patch.FilePatches() {
if repo.timeoutReached() {
return
}
if f.IsBinary() {
| go func(c *object.Commit, patch *object.Patch) {
defer func() {
<-semaphore | random_line_split |
main.go | },
})
// Initialize twitch notification listener
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyListener,
Build: func(ctn di.Container) (interface{}, error) {
return listeners.NewListenerTwitchNotify(ctn), nil
},
Close: func(obj interface{}) error {
listener := obj.(*listeners.ListenerTwitchNotify)
logrus.Info("Shutting down twitch notify listener...")
listener.TearDown()
return nil
},
})
// Initialize twitch notification worker
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyWorker,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitTwitchNotifyWorker(ctn), nil
},
})
// Initialize life cycle timer
diBuilder.Add(di.Def{
Name: static.DiLifecycleTimer,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitLTCTimer(ctn), nil
},
})
// Initialize storage middleware
diBuilder.Add(di.Def{
Name: static.DiObjectStorage,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitStorage(ctn), nil
},
})
// Initialize permissions command handler middleware
diBuilder.Add(di.Def{
Name: static.DiPermissionMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewPermissionMiddleware(ctn), nil
},
})
// Initialize ghost ping ignore command handler middleware
diBuilder.Add(di.Def{
Name: static.DiGhostpingIgnoreMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewGhostPingIgnoreMiddleware(), nil
},
})
// Initialize discord bot session and shutdown routine
diBuilder.Add(di.Def{
Name: static.DiDiscordSession,
Build: func(ctn di.Container) (interface{}, error) {
return discordgo.New()
},
Close: func(obj interface{}) error {
session := obj.(*discordgo.Session)
logrus.Info("Shutting down bot session...")
session.Close()
return nil
},
})
// Initialize Discord OAuth Module
diBuilder.Add(di.Def{
Name: static.DiDiscordOAuthModule,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitDiscordOAuth(ctn), nil
},
})
// Initialize auth refresh token handler
diBuilder.Add(di.Def{
Name: static.DiAuthRefreshTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseRefreshTokenHandler(ctn), nil
},
})
// Initialize auth access token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAccessTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewJWTAccessTokenHandler(ctn)
},
})
// Initialize auth API token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAPITokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseAPITokenHandler(ctn)
},
})
// Initialize OAuth API handler implementation
diBuilder.Add(di.Def{
Name: static.DiOAuthHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewRefreshTokenRequestHandler(ctn), nil
},
})
// Initialize access token authorization middleware
diBuilder.Add(di.Def{
Name: static.DiAuthMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewAccessTokenMiddleware(ctn), nil
},
})
// Initialize OTA generator
diBuilder.Add(di.Def{
Name: static.DiOneTimeAuth,
Build: func(ctn di.Container) (interface{}, error) {
return onetimeauth.NewJwt(&onetimeauth.JwtOptions{
Issuer: "shinpuru v." + embedded.AppVersion,
})
},
})
// Initialize backup handler
diBuilder.Add(di.Def{
Name: static.DiBackupHandler,
Build: func(ctn di.Container) (interface{}, error) {
return backup.New(ctn), nil
},
})
// Initialize command handler
diBuilder.Add(di.Def{
Name: static.DiCommandHandler,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCommandHandler(ctn), nil
},
})
// Initialize web server
diBuilder.Add(di.Def{
Name: static.DiWebserver,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitWebServer(ctn), nil
},
})
// Initialize code execution factroy
diBuilder.Add(di.Def{
Name: static.DiCodeExecFactory,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCodeExec(ctn), nil
},
})
// Initialize karma service
diBuilder.Add(di.Def{
Name: static.DiKarma,
Build: func(ctn di.Container) (interface{}, error) {
return karma.NewKarmaService(ctn), nil
},
})
// Initialize report service
diBuilder.Add(di.Def{
Name: static.DiReport,
Build: func(ctn di.Container) (interface{}, error) {
return report.New(ctn), nil
},
})
// Initialize guild logger
diBuilder.Add(di.Def{
Name: static.DiGuildLog,
Build: func(ctn di.Container) (interface{}, error) {
return guildlog.New(ctn), nil
},
})
// Initialize KV cache
diBuilder.Add(di.Def{
Name: static.DiKVCache,
Build: func(ctn di.Container) (interface{}, error) {
return kvcache.NewTimedmapCache(10 * time.Minute), nil
},
})
diBuilder.Add(di.Def{
Name: static.DiState,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitState(ctn)
},
})
// Build dependency injection container
ctn := diBuilder.Build()
// Setting log level from config
cfg := ctn.Get(static.DiConfig).(*config.Config)
logrus.SetLevel(logrus.Level(cfg.Logging.LogLevel))
logrus.SetFormatter(&logrus.TextFormatter{
ForceColors: true,
FullTimestamp: true,
TimestampFormat: "2006/01/02 15:04:05 MST",
})
// Initial log output
logrus.Info("Starting up...")
if profLoc := util.GetEnv(envKeyProfile, *flagProfile); profLoc != "" {
setupProfiler(profLoc)
}
if *flagDevMode {
setupDevMode()
}
// Initialize discord session and event
// handlers
inits.InitDiscordBotSession(ctn)
// This is currently the really hacky workaround
// to bypass the di.Container when trying to get
// the Command handler instance inside a command
// context, because the handler can not resolve
// itself on build, so it is bypassed here using
// shireikans object map. Maybe I find a better
// solution for that at some time.
handler := ctn.Get(static.DiCommandHandler).(shireikan.Handler)
handler.SetObject(static.DiCommandHandler, handler)
// Get Web WebServer instance to start web
// server listener
ctn.Get(static.DiWebserver)
// Get Backup Handler to ensure backup
// timer is running.
ctn.Get(static.DiBackupHandler)
// Get Metrics Server to start metrics
// endpoint.
ctn.Get(static.DiMetrics)
// Block main go routine until one of the following
// specified exit syscalls occure.
logrus.Info("Started event loop. Stop with CTRL-C...")
logrus.WithField("took", startuptime.Took().String()).Info("Initialization finished")
sc := make(chan os.Signal, 1)
signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
<-sc
// Tear down dependency instances
ctn.DeleteWithSubContainers()
}
func setupDevMode() {
if embedded.IsRelease() {
logrus.Fatal("development mode is not available in production builds")
}
util.DevModeEnabled = true
// Angular dev server
angServ := angularservice.New(angularservice.Options{
Stdout: os.Stdout,
Stderr: os.Stderr,
Cd: "web",
Port: 8081,
})
logrus.Info("Starting Angular dev server...")
if err := angServ.Start(); err != nil {
logrus.WithError(err).Fatal("Failed starting Angular dev server")
}
defer func() {
logrus.Info("Shutting down Angular dev server...")
angServ.Stop()
}()
}
func setupProfiler(profLoc string) | {
f, err := os.Create(profLoc)
if err != nil {
logrus.WithError(err).Fatal("failed starting profiler")
}
pprof.StartCPUProfile(f)
logrus.WithField("location", profLoc).Warning("CPU profiling is active")
defer pprof.StopCPUProfile()
} | identifier_body | |
main.go | .com/zekroTJA/shinpuru/pkg/startuptime"
"github.com/zekroTJA/shireikan"
"github.com/zekroTJA/shinpuru/pkg/angularservice"
)
var (
flagConfig = flag.String("c", "config.yml", "The location of the main config file")
flagDocker = flag.Bool("docker", false, "wether shinpuru is running in a docker container or not")
flagDevMode = flag.Bool("devmode", false, "start in development mode")
flagForceColor = flag.Bool("forcecolor", false, "force log color")
flagProfile = flag.String("cpuprofile", "", "Records a CPU profile to the desired location")
flagQuiet = flag.Bool("quiet", false, "Dont print startup message")
)
const (
envKeyProfile = "CPUPROFILE"
)
//////////////////////////////////////////////////////////////////////
//
// SHINPURU
// --------
// This is the main initialization for shinpuru which initializes
// all instances like the database middleware, the twitch notify
// listener service, life cycle timer, storage middleware,
// permission middleware, command handler and - finally -
// initializes the discord session event loop.
// shinpuru is configured via a configuration file which location
// can be passed via the '-c' parameter.
// When shinpuru is run in a Docker container, the '-docker' flag
// should be passed to fix configuration values like the location
// of the sqlite3 database (when the sqlite3 driver is used) or
// the web server exposure port.
//
//////////////////////////////////////////////////////////////////////
func main() {
// Parse command line flags
flag.Parse()
if !*flagQuiet {
startupmsg.Output(os.Stdout)
}
// Initialize dependency injection builder
diBuilder, _ := di.NewBuilder()
// Setup config parser
diBuilder.Add(di.Def{
Name: static.DiConfigParser,
Build: func(ctn di.Container) (p interface{}, err error) {
ext := strings.ToLower(filepath.Ext(*flagConfig))
switch ext {
case ".yml", ".yaml":
p = new(config.YAMLConfigParser)
case ".json":
p = new(config.JSONConfigParser)
default:
err = errors.New("unsupported configuration file")
}
return
},
})
// Initialize config
diBuilder.Add(di.Def{
Name: static.DiConfig,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitConfig(*flagConfig, ctn), nil
},
})
// Initialize metrics server
diBuilder.Add(di.Def{
Name: static.DiMetrics,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitMetrics(ctn), nil
},
})
// Initialize redis client
diBuilder.Add(di.Def{
Name: static.DiRedis,
Build: func(ctn di.Container) (interface{}, error) {
config := ctn.Get(static.DiConfig).(*config.Config)
return redis.NewClient(&redis.Options{
Addr: config.Database.Redis.Addr,
Password: config.Database.Redis.Password,
DB: config.Database.Redis.Type,
}), nil
},
})
// Initialize database middleware and shutdown routine
diBuilder.Add(di.Def{
Name: static.DiDatabase,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitDatabase(ctn), nil
},
Close: func(obj interface{}) error {
database := obj.(database.Database)
logrus.Info("Shutting down database connection...")
database.Close()
return nil
},
})
// Initialize twitch notification listener
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyListener,
Build: func(ctn di.Container) (interface{}, error) {
return listeners.NewListenerTwitchNotify(ctn), nil
},
Close: func(obj interface{}) error {
listener := obj.(*listeners.ListenerTwitchNotify)
logrus.Info("Shutting down twitch notify listener...")
listener.TearDown()
return nil
},
})
// Initialize twitch notification worker
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyWorker,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitTwitchNotifyWorker(ctn), nil
},
})
// Initialize life cycle timer
diBuilder.Add(di.Def{
Name: static.DiLifecycleTimer,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitLTCTimer(ctn), nil
},
})
// Initialize storage middleware
diBuilder.Add(di.Def{
Name: static.DiObjectStorage,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitStorage(ctn), nil
},
})
// Initialize permissions command handler middleware
diBuilder.Add(di.Def{
Name: static.DiPermissionMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewPermissionMiddleware(ctn), nil
},
})
// Initialize ghost ping ignore command handler middleware
diBuilder.Add(di.Def{
Name: static.DiGhostpingIgnoreMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewGhostPingIgnoreMiddleware(), nil
},
})
// Initialize discord bot session and shutdown routine
diBuilder.Add(di.Def{
Name: static.DiDiscordSession,
Build: func(ctn di.Container) (interface{}, error) {
return discordgo.New()
},
Close: func(obj interface{}) error {
session := obj.(*discordgo.Session)
logrus.Info("Shutting down bot session...")
session.Close()
return nil
},
})
// Initialize Discord OAuth Module
diBuilder.Add(di.Def{
Name: static.DiDiscordOAuthModule,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitDiscordOAuth(ctn), nil
}, | })
// Initialize auth refresh token handler
diBuilder.Add(di.Def{
Name: static.DiAuthRefreshTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseRefreshTokenHandler(ctn), nil
},
})
// Initialize auth access token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAccessTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewJWTAccessTokenHandler(ctn)
},
})
// Initialize auth API token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAPITokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseAPITokenHandler(ctn)
},
})
// Initialize OAuth API handler implementation
diBuilder.Add(di.Def{
Name: static.DiOAuthHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewRefreshTokenRequestHandler(ctn), nil
},
})
// Initialize access token authorization middleware
diBuilder.Add(di.Def{
Name: static.DiAuthMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewAccessTokenMiddleware(ctn), nil
},
})
// Initialize OTA generator
diBuilder.Add(di.Def{
Name: static.DiOneTimeAuth,
Build: func(ctn di.Container) (interface{}, error) {
return onetimeauth.NewJwt(&onetimeauth.JwtOptions{
Issuer: "shinpuru v." + embedded.AppVersion,
})
},
})
// Initialize backup handler
diBuilder.Add(di.Def{
Name: static.DiBackupHandler,
Build: func(ctn di.Container) (interface{}, error) {
return backup.New(ctn), nil
},
})
// Initialize command handler
diBuilder.Add(di.Def{
Name: static.DiCommandHandler,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCommandHandler(ctn), nil
},
})
// Initialize web server
diBuilder.Add(di.Def{
Name: static.DiWebserver,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitWebServer(ctn), nil
},
})
// Initialize code execution factroy
diBuilder.Add(di.Def{
Name: static.DiCodeExecFactory,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCodeExec(ctn), nil
},
})
// Initialize karma service
diBuilder.Add(di.Def{
Name: static.DiKarma,
Build: func(ctn di.Container) (interface{}, error) {
return karma.NewKarmaService(ctn), nil
},
})
// Initialize report service
diBuilder.Add(di.Def{
Name: static.DiReport,
Build: func(ctn di.Container) (interface{}, error) {
return report.New(ctn), nil
},
})
// Initialize guild logger
diBuilder.Add(di.Def{
Name: static.DiGuildLog,
Build: func(ctn di.Container) ( | random_line_split | |
main.go | .com/zekroTJA/shinpuru/pkg/startuptime"
"github.com/zekroTJA/shireikan"
"github.com/zekroTJA/shinpuru/pkg/angularservice"
)
var (
flagConfig = flag.String("c", "config.yml", "The location of the main config file")
flagDocker = flag.Bool("docker", false, "wether shinpuru is running in a docker container or not")
flagDevMode = flag.Bool("devmode", false, "start in development mode")
flagForceColor = flag.Bool("forcecolor", false, "force log color")
flagProfile = flag.String("cpuprofile", "", "Records a CPU profile to the desired location")
flagQuiet = flag.Bool("quiet", false, "Dont print startup message")
)
const (
envKeyProfile = "CPUPROFILE"
)
//////////////////////////////////////////////////////////////////////
//
// SHINPURU
// --------
// This is the main initialization for shinpuru which initializes
// all instances like the database middleware, the twitch notify
// listener service, life cycle timer, storage middleware,
// permission middleware, command handler and - finally -
// initializes the discord session event loop.
// shinpuru is configured via a configuration file which location
// can be passed via the '-c' parameter.
// When shinpuru is run in a Docker container, the '-docker' flag
// should be passed to fix configuration values like the location
// of the sqlite3 database (when the sqlite3 driver is used) or
// the web server exposure port.
//
//////////////////////////////////////////////////////////////////////
func | () {
// Parse command line flags
flag.Parse()
if !*flagQuiet {
startupmsg.Output(os.Stdout)
}
// Initialize dependency injection builder
diBuilder, _ := di.NewBuilder()
// Setup config parser
diBuilder.Add(di.Def{
Name: static.DiConfigParser,
Build: func(ctn di.Container) (p interface{}, err error) {
ext := strings.ToLower(filepath.Ext(*flagConfig))
switch ext {
case ".yml", ".yaml":
p = new(config.YAMLConfigParser)
case ".json":
p = new(config.JSONConfigParser)
default:
err = errors.New("unsupported configuration file")
}
return
},
})
// Initialize config
diBuilder.Add(di.Def{
Name: static.DiConfig,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitConfig(*flagConfig, ctn), nil
},
})
// Initialize metrics server
diBuilder.Add(di.Def{
Name: static.DiMetrics,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitMetrics(ctn), nil
},
})
// Initialize redis client
diBuilder.Add(di.Def{
Name: static.DiRedis,
Build: func(ctn di.Container) (interface{}, error) {
config := ctn.Get(static.DiConfig).(*config.Config)
return redis.NewClient(&redis.Options{
Addr: config.Database.Redis.Addr,
Password: config.Database.Redis.Password,
DB: config.Database.Redis.Type,
}), nil
},
})
// Initialize database middleware and shutdown routine
diBuilder.Add(di.Def{
Name: static.DiDatabase,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitDatabase(ctn), nil
},
Close: func(obj interface{}) error {
database := obj.(database.Database)
logrus.Info("Shutting down database connection...")
database.Close()
return nil
},
})
// Initialize twitch notification listener
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyListener,
Build: func(ctn di.Container) (interface{}, error) {
return listeners.NewListenerTwitchNotify(ctn), nil
},
Close: func(obj interface{}) error {
listener := obj.(*listeners.ListenerTwitchNotify)
logrus.Info("Shutting down twitch notify listener...")
listener.TearDown()
return nil
},
})
// Initialize twitch notification worker
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyWorker,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitTwitchNotifyWorker(ctn), nil
},
})
// Initialize life cycle timer
diBuilder.Add(di.Def{
Name: static.DiLifecycleTimer,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitLTCTimer(ctn), nil
},
})
// Initialize storage middleware
diBuilder.Add(di.Def{
Name: static.DiObjectStorage,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitStorage(ctn), nil
},
})
// Initialize permissions command handler middleware
diBuilder.Add(di.Def{
Name: static.DiPermissionMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewPermissionMiddleware(ctn), nil
},
})
// Initialize ghost ping ignore command handler middleware
diBuilder.Add(di.Def{
Name: static.DiGhostpingIgnoreMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewGhostPingIgnoreMiddleware(), nil
},
})
// Initialize discord bot session and shutdown routine
diBuilder.Add(di.Def{
Name: static.DiDiscordSession,
Build: func(ctn di.Container) (interface{}, error) {
return discordgo.New()
},
Close: func(obj interface{}) error {
session := obj.(*discordgo.Session)
logrus.Info("Shutting down bot session...")
session.Close()
return nil
},
})
// Initialize Discord OAuth Module
diBuilder.Add(di.Def{
Name: static.DiDiscordOAuthModule,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitDiscordOAuth(ctn), nil
},
})
// Initialize auth refresh token handler
diBuilder.Add(di.Def{
Name: static.DiAuthRefreshTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseRefreshTokenHandler(ctn), nil
},
})
// Initialize auth access token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAccessTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewJWTAccessTokenHandler(ctn)
},
})
// Initialize auth API token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAPITokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseAPITokenHandler(ctn)
},
})
// Initialize OAuth API handler implementation
diBuilder.Add(di.Def{
Name: static.DiOAuthHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewRefreshTokenRequestHandler(ctn), nil
},
})
// Initialize access token authorization middleware
diBuilder.Add(di.Def{
Name: static.DiAuthMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewAccessTokenMiddleware(ctn), nil
},
})
// Initialize OTA generator
diBuilder.Add(di.Def{
Name: static.DiOneTimeAuth,
Build: func(ctn di.Container) (interface{}, error) {
return onetimeauth.NewJwt(&onetimeauth.JwtOptions{
Issuer: "shinpuru v." + embedded.AppVersion,
})
},
})
// Initialize backup handler
diBuilder.Add(di.Def{
Name: static.DiBackupHandler,
Build: func(ctn di.Container) (interface{}, error) {
return backup.New(ctn), nil
},
})
// Initialize command handler
diBuilder.Add(di.Def{
Name: static.DiCommandHandler,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCommandHandler(ctn), nil
},
})
// Initialize web server
diBuilder.Add(di.Def{
Name: static.DiWebserver,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitWebServer(ctn), nil
},
})
// Initialize code execution factroy
diBuilder.Add(di.Def{
Name: static.DiCodeExecFactory,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCodeExec(ctn), nil
},
})
// Initialize karma service
diBuilder.Add(di.Def{
Name: static.DiKarma,
Build: func(ctn di.Container) (interface{}, error) {
return karma.NewKarmaService(ctn), nil
},
})
// Initialize report service
diBuilder.Add(di.Def{
Name: static.DiReport,
Build: func(ctn di.Container) (interface{}, error) {
return report.New(ctn), nil
},
})
// Initialize guild logger
diBuilder.Add(di.Def{
Name: static.DiGuildLog,
Build: func(ctn di.Container) | main | identifier_name |
main.go | /zekroTJA/shinpuru/pkg/startuptime"
"github.com/zekroTJA/shireikan"
"github.com/zekroTJA/shinpuru/pkg/angularservice"
)
var (
flagConfig = flag.String("c", "config.yml", "The location of the main config file")
flagDocker = flag.Bool("docker", false, "wether shinpuru is running in a docker container or not")
flagDevMode = flag.Bool("devmode", false, "start in development mode")
flagForceColor = flag.Bool("forcecolor", false, "force log color")
flagProfile = flag.String("cpuprofile", "", "Records a CPU profile to the desired location")
flagQuiet = flag.Bool("quiet", false, "Dont print startup message")
)
const (
envKeyProfile = "CPUPROFILE"
)
//////////////////////////////////////////////////////////////////////
//
// SHINPURU
// --------
// This is the main initialization for shinpuru which initializes
// all instances like the database middleware, the twitch notify
// listener service, life cycle timer, storage middleware,
// permission middleware, command handler and - finally -
// initializes the discord session event loop.
// shinpuru is configured via a configuration file which location
// can be passed via the '-c' parameter.
// When shinpuru is run in a Docker container, the '-docker' flag
// should be passed to fix configuration values like the location
// of the sqlite3 database (when the sqlite3 driver is used) or
// the web server exposure port.
//
//////////////////////////////////////////////////////////////////////
func main() {
// Parse command line flags
flag.Parse()
if !*flagQuiet |
// Initialize dependency injection builder
diBuilder, _ := di.NewBuilder()
// Setup config parser
diBuilder.Add(di.Def{
Name: static.DiConfigParser,
Build: func(ctn di.Container) (p interface{}, err error) {
ext := strings.ToLower(filepath.Ext(*flagConfig))
switch ext {
case ".yml", ".yaml":
p = new(config.YAMLConfigParser)
case ".json":
p = new(config.JSONConfigParser)
default:
err = errors.New("unsupported configuration file")
}
return
},
})
// Initialize config
diBuilder.Add(di.Def{
Name: static.DiConfig,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitConfig(*flagConfig, ctn), nil
},
})
// Initialize metrics server
diBuilder.Add(di.Def{
Name: static.DiMetrics,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitMetrics(ctn), nil
},
})
// Initialize redis client
diBuilder.Add(di.Def{
Name: static.DiRedis,
Build: func(ctn di.Container) (interface{}, error) {
config := ctn.Get(static.DiConfig).(*config.Config)
return redis.NewClient(&redis.Options{
Addr: config.Database.Redis.Addr,
Password: config.Database.Redis.Password,
DB: config.Database.Redis.Type,
}), nil
},
})
// Initialize database middleware and shutdown routine
diBuilder.Add(di.Def{
Name: static.DiDatabase,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitDatabase(ctn), nil
},
Close: func(obj interface{}) error {
database := obj.(database.Database)
logrus.Info("Shutting down database connection...")
database.Close()
return nil
},
})
// Initialize twitch notification listener
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyListener,
Build: func(ctn di.Container) (interface{}, error) {
return listeners.NewListenerTwitchNotify(ctn), nil
},
Close: func(obj interface{}) error {
listener := obj.(*listeners.ListenerTwitchNotify)
logrus.Info("Shutting down twitch notify listener...")
listener.TearDown()
return nil
},
})
// Initialize twitch notification worker
diBuilder.Add(di.Def{
Name: static.DiTwitchNotifyWorker,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitTwitchNotifyWorker(ctn), nil
},
})
// Initialize life cycle timer
diBuilder.Add(di.Def{
Name: static.DiLifecycleTimer,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitLTCTimer(ctn), nil
},
})
// Initialize storage middleware
diBuilder.Add(di.Def{
Name: static.DiObjectStorage,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitStorage(ctn), nil
},
})
// Initialize permissions command handler middleware
diBuilder.Add(di.Def{
Name: static.DiPermissionMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewPermissionMiddleware(ctn), nil
},
})
// Initialize ghost ping ignore command handler middleware
diBuilder.Add(di.Def{
Name: static.DiGhostpingIgnoreMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return middleware.NewGhostPingIgnoreMiddleware(), nil
},
})
// Initialize discord bot session and shutdown routine
diBuilder.Add(di.Def{
Name: static.DiDiscordSession,
Build: func(ctn di.Container) (interface{}, error) {
return discordgo.New()
},
Close: func(obj interface{}) error {
session := obj.(*discordgo.Session)
logrus.Info("Shutting down bot session...")
session.Close()
return nil
},
})
// Initialize Discord OAuth Module
diBuilder.Add(di.Def{
Name: static.DiDiscordOAuthModule,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitDiscordOAuth(ctn), nil
},
})
// Initialize auth refresh token handler
diBuilder.Add(di.Def{
Name: static.DiAuthRefreshTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseRefreshTokenHandler(ctn), nil
},
})
// Initialize auth access token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAccessTokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewJWTAccessTokenHandler(ctn)
},
})
// Initialize auth API token handler
diBuilder.Add(di.Def{
Name: static.DiAuthAPITokenHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewDatabaseAPITokenHandler(ctn)
},
})
// Initialize OAuth API handler implementation
diBuilder.Add(di.Def{
Name: static.DiOAuthHandler,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewRefreshTokenRequestHandler(ctn), nil
},
})
// Initialize access token authorization middleware
diBuilder.Add(di.Def{
Name: static.DiAuthMiddleware,
Build: func(ctn di.Container) (interface{}, error) {
return auth.NewAccessTokenMiddleware(ctn), nil
},
})
// Initialize OTA generator
diBuilder.Add(di.Def{
Name: static.DiOneTimeAuth,
Build: func(ctn di.Container) (interface{}, error) {
return onetimeauth.NewJwt(&onetimeauth.JwtOptions{
Issuer: "shinpuru v." + embedded.AppVersion,
})
},
})
// Initialize backup handler
diBuilder.Add(di.Def{
Name: static.DiBackupHandler,
Build: func(ctn di.Container) (interface{}, error) {
return backup.New(ctn), nil
},
})
// Initialize command handler
diBuilder.Add(di.Def{
Name: static.DiCommandHandler,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCommandHandler(ctn), nil
},
})
// Initialize web server
diBuilder.Add(di.Def{
Name: static.DiWebserver,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitWebServer(ctn), nil
},
})
// Initialize code execution factroy
diBuilder.Add(di.Def{
Name: static.DiCodeExecFactory,
Build: func(ctn di.Container) (interface{}, error) {
return inits.InitCodeExec(ctn), nil
},
})
// Initialize karma service
diBuilder.Add(di.Def{
Name: static.DiKarma,
Build: func(ctn di.Container) (interface{}, error) {
return karma.NewKarmaService(ctn), nil
},
})
// Initialize report service
diBuilder.Add(di.Def{
Name: static.DiReport,
Build: func(ctn di.Container) (interface{}, error) {
return report.New(ctn), nil
},
})
// Initialize guild logger
diBuilder.Add(di.Def{
Name: static.DiGuildLog,
Build: func(ctn di.Container) | {
startupmsg.Output(os.Stdout)
} | conditional_block |
server_http_response.go | copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
package zanzibar
import (
"context"
"fmt"
"net/http"
"strconv"
"strings"
"time"
"github.com/buger/jsonparser"
"github.com/pkg/errors"
"github.com/uber-go/tally"
"github.com/uber/zanzibar/runtime/jsonwrapper"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
// ServerHTTPResponse struct manages server http response
type ServerHTTPResponse struct {
Request *ServerHTTPRequest
StatusCode int
responseWriter http.ResponseWriter
flushed bool
finished bool
finishTime time.Time
DownstreamFinishTime time.Duration
ClientType string
pendingBodyBytes []byte
pendingBodyObj interface{}
pendingStatusCode int
contextLogger ContextLogger
scope tally.Scope
jsonWrapper jsonwrapper.JSONWrapper
Err error
}
// NewServerHTTPResponse is helper function to alloc ServerHTTPResponse
func NewServerHTTPResponse(
w http.ResponseWriter,
req *ServerHTTPRequest,
) *ServerHTTPResponse {
return &ServerHTTPResponse{
Request: req,
StatusCode: 200,
responseWriter: w,
contextLogger: req.contextLogger,
scope: req.scope,
jsonWrapper: req.jsonWrapper,
}
}
// finish will handle final logic, like metrics
func (res *ServerHTTPResponse) finish(ctx context.Context) {
logFields := GetLogFieldsFromCtx(ctx)
if !res.Request.started {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Forgot to start server response",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
if res.finished {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Finished a server response multiple times",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
res.finished = true
res.finishTime = time.Now()
_, known := knownStatusCodes[res.StatusCode]
tagged := res.scope.Tagged(map[string]string{
scopeTagStatus: fmt.Sprintf("%d", res.StatusCode), // no need to put this tag on the context because this is the end of response life cycle
scopeTagClientType: res.ClientType,
})
delta := res.finishTime.Sub(res.Request.startTime)
tagged.Timer(endpointLatency).Record(delta)
tagged.Histogram(endpointLatencyHist, tally.DefaultBuckets).RecordDuration(delta)
if res.DownstreamFinishTime != 0 {
overhead := delta - res.DownstreamFinishTime
overheadRatio := overhead.Seconds() / delta.Seconds()
tagged.Timer(endpointOverheadLatency).Record(overhead)
tagged.Histogram(endpointOverheadLatencyHist, tally.DefaultBuckets).RecordDuration(overhead)
tagged.Gauge(endpointOverheadRatio).Update(overheadRatio)
}
if !known {
res.contextLogger.Error(ctx,
"Unknown status code",
append(logFields, zap.Int("UnknownStatusCode", res.StatusCode))...,
)
} else {
tagged.Counter(endpointStatus).Inc(1)
}
logFn := res.contextLogger.Debug
if !known || res.StatusCode >= 400 && res.StatusCode < 600 {
tagged.Counter(endpointAppErrors).Inc(1)
logFn = res.contextLogger.WarnZ
}
span := res.Request.GetSpan()
if span != nil {
span.Finish()
}
logFn(ctx,
fmt.Sprintf("Finished an incoming server HTTP request with %d status code", res.StatusCode),
append(logFields, serverHTTPLogFields(res.Request, res)...)...,
)
}
func serverHTTPLogFields(req *ServerHTTPRequest, res *ServerHTTPResponse) []zapcore.Field {
fields := []zapcore.Field{
zap.Int(logFieldResponseStatusCode, res.StatusCode),
}
for k, v := range res.Headers() {
if len(v) > 0 {
fields = append(fields, zap.String(
fmt.Sprintf("%s-%s", logFieldEndpointResponseHeaderPrefix, k),
strings.Join(v, ", "),
))
}
}
if res.Err != nil {
fields = append(fields, zap.Error(res.Err))
cause := errors.Cause(res.Err)
if cause != nil && cause != res.Err {
fields = append(fields, zap.NamedError("errorCause", cause))
}
}
return fields
}
// SendErrorString helper to send an error string
func (res *ServerHTTPResponse) SendErrorString(
statusCode int, errMsg string,
) {
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// SendError helper to send an server error message, propagates underlying cause to logs etc.
func (res *ServerHTTPResponse) SendError(
statusCode int, errMsg string, errCause error,
) {
res.Err = errCause
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// WriteBytes writes a byte[] slice that is valid Response
func (res *ServerHTTPResponse) WriteBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
res.responseWriter.Header().Set(k, v)
}
}
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
}
// WriteJSONBytes writes a byte[] slice that is valid json to Response
func (res *ServerHTTPResponse) WriteJSONBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers == nil {
headers = ServerHTTPHeader{}
}
headers.Add("content-type", "application/json")
res.WriteBytes(statusCode, headers, bytes)
}
// MarshalResponseJSON serializes a json serializable into bytes
func (res *ServerHTTPResponse) MarshalResponseJSON(body interface{}) []byte {
ctx := res.Request.Context()
if body == nil {
res.SendError(500, "Could not serialize json response", errors.New("No Body JSON"))
res.contextLogger.Error(ctx, "Could not serialize nil pointer body")
return nil
}
bytes, err := res.jsonWrapper.Marshal(body)
if err != nil {
res.SendError(500, "Could not serialize json response", err)
res.contextLogger.Error(ctx, "Could not serialize json response", zap.Error(err))
return nil
}
return bytes
}
// SendResponse sets content-type if not present and fills Response
func (res *ServerHTTPResponse) | (statusCode int, headers Header, body interface{}, bytes []byte) {
contentTypePresent := false
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
if k == "Content-Type" {
contentTypePresent = true
}
res.responseWriter.Header().Set(k, v)
}
}
}
// Set the content-type to application/json if not already available
if !contentTypePresent {
res.responseWriter.Header().
Set("content-type", "application/json")
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
res.pendingBodyObj = body
}
// WriteJSON writes a json serializable struct to Response
func (res *ServerHTTPResponse) WriteJSON(
statusCode int, headers Header, body interface{},
) {
bytes := res.MarshalResponseJSON(body)
if bytes == nil {
return
}
res.SendResponse(statusCode, headers, body, bytes)
}
// PeekBody allows for inspecting a key path inside the body
// that is not flushed yet. This is useful for response middlewares
// that want to inspect the response body.
func (res *ServerHTTPResponse) PeekBody(
keys ...string,
) ([]byte, jsonparser.ValueType, error) {
value, valueType, _, err := jsonparser.Get(
res.pendingBodyBytes, keys...,
)
if err != nil {
return nil, -1, err
}
return value, valueType, nil
}
// Flush will write the body to the response. Before flush is called
// the body is pending. A pending body allows a response middleware to
// write a different body.
func (res *ServerHTTPResponse) flush(ctx context.Context) {
if res.flushed {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Flushed a server response multiple times",
zap.String("path", res.Request.URL.Path),
)
/* coverage ignore next line */
return
}
res.flushed = true
res.writeHeader(res.pendingStatusCode)
if _, noContent := noContentStatusCodes[res.pendingStatusCode]; | SendResponse | identifier_name |
server_http_response.go | copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
package zanzibar
import (
"context"
"fmt"
"net/http"
"strconv"
"strings"
"time"
"github.com/buger/jsonparser"
"github.com/pkg/errors"
"github.com/uber-go/tally"
"github.com/uber/zanzibar/runtime/jsonwrapper"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
// ServerHTTPResponse struct manages server http response
type ServerHTTPResponse struct {
Request *ServerHTTPRequest
StatusCode int
responseWriter http.ResponseWriter
flushed bool
finished bool
finishTime time.Time
DownstreamFinishTime time.Duration
ClientType string
pendingBodyBytes []byte
pendingBodyObj interface{}
pendingStatusCode int
contextLogger ContextLogger
scope tally.Scope
jsonWrapper jsonwrapper.JSONWrapper
Err error
}
// NewServerHTTPResponse is helper function to alloc ServerHTTPResponse
func NewServerHTTPResponse(
w http.ResponseWriter,
req *ServerHTTPRequest,
) *ServerHTTPResponse {
return &ServerHTTPResponse{
Request: req,
StatusCode: 200,
responseWriter: w,
contextLogger: req.contextLogger,
scope: req.scope,
jsonWrapper: req.jsonWrapper,
}
}
// finish will handle final logic, like metrics
func (res *ServerHTTPResponse) finish(ctx context.Context) {
logFields := GetLogFieldsFromCtx(ctx)
if !res.Request.started {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Forgot to start server response",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
if res.finished {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Finished a server response multiple times",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
res.finished = true
res.finishTime = time.Now()
_, known := knownStatusCodes[res.StatusCode]
tagged := res.scope.Tagged(map[string]string{
scopeTagStatus: fmt.Sprintf("%d", res.StatusCode), // no need to put this tag on the context because this is the end of response life cycle
scopeTagClientType: res.ClientType,
})
delta := res.finishTime.Sub(res.Request.startTime)
tagged.Timer(endpointLatency).Record(delta)
tagged.Histogram(endpointLatencyHist, tally.DefaultBuckets).RecordDuration(delta)
if res.DownstreamFinishTime != 0 {
overhead := delta - res.DownstreamFinishTime
overheadRatio := overhead.Seconds() / delta.Seconds()
tagged.Timer(endpointOverheadLatency).Record(overhead)
tagged.Histogram(endpointOverheadLatencyHist, tally.DefaultBuckets).RecordDuration(overhead)
tagged.Gauge(endpointOverheadRatio).Update(overheadRatio)
}
if !known {
res.contextLogger.Error(ctx,
"Unknown status code",
append(logFields, zap.Int("UnknownStatusCode", res.StatusCode))...,
)
} else {
tagged.Counter(endpointStatus).Inc(1)
}
logFn := res.contextLogger.Debug
if !known || res.StatusCode >= 400 && res.StatusCode < 600 {
tagged.Counter(endpointAppErrors).Inc(1)
logFn = res.contextLogger.WarnZ
}
span := res.Request.GetSpan()
if span != nil {
span.Finish()
}
logFn(ctx,
fmt.Sprintf("Finished an incoming server HTTP request with %d status code", res.StatusCode),
append(logFields, serverHTTPLogFields(res.Request, res)...)...,
)
}
func serverHTTPLogFields(req *ServerHTTPRequest, res *ServerHTTPResponse) []zapcore.Field {
fields := []zapcore.Field{
zap.Int(logFieldResponseStatusCode, res.StatusCode),
}
for k, v := range res.Headers() {
if len(v) > 0 {
fields = append(fields, zap.String(
fmt.Sprintf("%s-%s", logFieldEndpointResponseHeaderPrefix, k),
strings.Join(v, ", "),
))
}
}
if res.Err != nil {
fields = append(fields, zap.Error(res.Err))
cause := errors.Cause(res.Err)
if cause != nil && cause != res.Err {
fields = append(fields, zap.NamedError("errorCause", cause))
}
}
return fields
}
// SendErrorString helper to send an error string
func (res *ServerHTTPResponse) SendErrorString(
statusCode int, errMsg string,
) {
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// SendError helper to send an server error message, propagates underlying cause to logs etc.
func (res *ServerHTTPResponse) SendError(
statusCode int, errMsg string, errCause error,
) {
res.Err = errCause
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// WriteBytes writes a byte[] slice that is valid Response
func (res *ServerHTTPResponse) WriteBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
res.responseWriter.Header().Set(k, v)
}
}
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
}
// WriteJSONBytes writes a byte[] slice that is valid json to Response
func (res *ServerHTTPResponse) WriteJSONBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers == nil {
headers = ServerHTTPHeader{}
}
headers.Add("content-type", "application/json")
res.WriteBytes(statusCode, headers, bytes)
}
// MarshalResponseJSON serializes a json serializable into bytes
func (res *ServerHTTPResponse) MarshalResponseJSON(body interface{}) []byte {
ctx := res.Request.Context()
if body == nil {
res.SendError(500, "Could not serialize json response", errors.New("No Body JSON"))
res.contextLogger.Error(ctx, "Could not serialize nil pointer body")
return nil
}
bytes, err := res.jsonWrapper.Marshal(body)
if err != nil {
res.SendError(500, "Could not serialize json response", err)
res.contextLogger.Error(ctx, "Could not serialize json response", zap.Error(err))
return nil
}
return bytes
}
// SendResponse sets content-type if not present and fills Response
func (res *ServerHTTPResponse) SendResponse(statusCode int, headers Header, body interface{}, bytes []byte) {
contentTypePresent := false
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
if k == "Content-Type" {
contentTypePresent = true
}
res.responseWriter.Header().Set(k, v)
}
}
}
// Set the content-type to application/json if not already available
if !contentTypePresent {
res.responseWriter.Header().
Set("content-type", "application/json")
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
res.pendingBodyObj = body
}
// WriteJSON writes a json serializable struct to Response
func (res *ServerHTTPResponse) WriteJSON(
statusCode int, headers Header, body interface{},
) {
bytes := res.MarshalResponseJSON(body)
if bytes == nil {
return
}
res.SendResponse(statusCode, headers, body, bytes)
}
// PeekBody allows for inspecting a key path inside the body
// that is not flushed yet. This is useful for response middlewares
// that want to inspect the response body.
func (res *ServerHTTPResponse) PeekBody(
keys ...string,
) ([]byte, jsonparser.ValueType, error) {
value, valueType, _, err := jsonparser.Get(
res.pendingBodyBytes, keys...,
)
if err != nil |
return value, valueType, nil
}
// Flush will write the body to the response. Before flush is called
// the body is pending. A pending body allows a response middleware to
// write a different body.
func (res *ServerHTTPResponse) flush(ctx context.Context) {
if res.flushed {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Flushed a server response multiple times",
zap.String("path", res.Request.URL.Path),
)
/* coverage ignore next line */
return
}
res.flushed = true
res.writeHeader(res.pendingStatusCode)
if _, noContent := noContentStatusCodes[res.pendingStatusCode | {
return nil, -1, err
} | conditional_block |
server_http_response.go | flushed bool
finished bool
finishTime time.Time
DownstreamFinishTime time.Duration
ClientType string
pendingBodyBytes []byte
pendingBodyObj interface{}
pendingStatusCode int
contextLogger ContextLogger
scope tally.Scope
jsonWrapper jsonwrapper.JSONWrapper
Err error
}
// NewServerHTTPResponse is helper function to alloc ServerHTTPResponse
func NewServerHTTPResponse(
w http.ResponseWriter,
req *ServerHTTPRequest,
) *ServerHTTPResponse {
return &ServerHTTPResponse{
Request: req,
StatusCode: 200,
responseWriter: w,
contextLogger: req.contextLogger,
scope: req.scope,
jsonWrapper: req.jsonWrapper,
}
}
// finish will handle final logic, like metrics
func (res *ServerHTTPResponse) finish(ctx context.Context) {
logFields := GetLogFieldsFromCtx(ctx)
if !res.Request.started {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Forgot to start server response",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
if res.finished {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Finished a server response multiple times",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
res.finished = true
res.finishTime = time.Now()
_, known := knownStatusCodes[res.StatusCode]
tagged := res.scope.Tagged(map[string]string{
scopeTagStatus: fmt.Sprintf("%d", res.StatusCode), // no need to put this tag on the context because this is the end of response life cycle
scopeTagClientType: res.ClientType,
})
delta := res.finishTime.Sub(res.Request.startTime)
tagged.Timer(endpointLatency).Record(delta)
tagged.Histogram(endpointLatencyHist, tally.DefaultBuckets).RecordDuration(delta)
if res.DownstreamFinishTime != 0 {
overhead := delta - res.DownstreamFinishTime
overheadRatio := overhead.Seconds() / delta.Seconds()
tagged.Timer(endpointOverheadLatency).Record(overhead)
tagged.Histogram(endpointOverheadLatencyHist, tally.DefaultBuckets).RecordDuration(overhead)
tagged.Gauge(endpointOverheadRatio).Update(overheadRatio)
}
if !known {
res.contextLogger.Error(ctx,
"Unknown status code",
append(logFields, zap.Int("UnknownStatusCode", res.StatusCode))...,
)
} else {
tagged.Counter(endpointStatus).Inc(1)
}
logFn := res.contextLogger.Debug
if !known || res.StatusCode >= 400 && res.StatusCode < 600 {
tagged.Counter(endpointAppErrors).Inc(1)
logFn = res.contextLogger.WarnZ
}
span := res.Request.GetSpan()
if span != nil {
span.Finish()
}
logFn(ctx,
fmt.Sprintf("Finished an incoming server HTTP request with %d status code", res.StatusCode),
append(logFields, serverHTTPLogFields(res.Request, res)...)...,
)
}
func serverHTTPLogFields(req *ServerHTTPRequest, res *ServerHTTPResponse) []zapcore.Field {
fields := []zapcore.Field{
zap.Int(logFieldResponseStatusCode, res.StatusCode),
}
for k, v := range res.Headers() {
if len(v) > 0 {
fields = append(fields, zap.String(
fmt.Sprintf("%s-%s", logFieldEndpointResponseHeaderPrefix, k),
strings.Join(v, ", "),
))
}
}
if res.Err != nil {
fields = append(fields, zap.Error(res.Err))
cause := errors.Cause(res.Err)
if cause != nil && cause != res.Err {
fields = append(fields, zap.NamedError("errorCause", cause))
}
}
return fields
}
// SendErrorString helper to send an error string
func (res *ServerHTTPResponse) SendErrorString(
statusCode int, errMsg string,
) {
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// SendError helper to send an server error message, propagates underlying cause to logs etc.
func (res *ServerHTTPResponse) SendError(
statusCode int, errMsg string, errCause error,
) {
res.Err = errCause
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// WriteBytes writes a byte[] slice that is valid Response
func (res *ServerHTTPResponse) WriteBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
res.responseWriter.Header().Set(k, v)
}
}
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
}
// WriteJSONBytes writes a byte[] slice that is valid json to Response
func (res *ServerHTTPResponse) WriteJSONBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers == nil {
headers = ServerHTTPHeader{}
}
headers.Add("content-type", "application/json")
res.WriteBytes(statusCode, headers, bytes)
}
// MarshalResponseJSON serializes a json serializable into bytes
func (res *ServerHTTPResponse) MarshalResponseJSON(body interface{}) []byte {
ctx := res.Request.Context()
if body == nil {
res.SendError(500, "Could not serialize json response", errors.New("No Body JSON"))
res.contextLogger.Error(ctx, "Could not serialize nil pointer body")
return nil
}
bytes, err := res.jsonWrapper.Marshal(body)
if err != nil {
res.SendError(500, "Could not serialize json response", err)
res.contextLogger.Error(ctx, "Could not serialize json response", zap.Error(err))
return nil
}
return bytes
}
// SendResponse sets content-type if not present and fills Response
func (res *ServerHTTPResponse) SendResponse(statusCode int, headers Header, body interface{}, bytes []byte) {
contentTypePresent := false
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
if k == "Content-Type" {
contentTypePresent = true
}
res.responseWriter.Header().Set(k, v)
}
}
}
// Set the content-type to application/json if not already available
if !contentTypePresent {
res.responseWriter.Header().
Set("content-type", "application/json")
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
res.pendingBodyObj = body
}
// WriteJSON writes a json serializable struct to Response
func (res *ServerHTTPResponse) WriteJSON(
statusCode int, headers Header, body interface{},
) {
bytes := res.MarshalResponseJSON(body)
if bytes == nil {
return
}
res.SendResponse(statusCode, headers, body, bytes)
}
// PeekBody allows for inspecting a key path inside the body
// that is not flushed yet. This is useful for response middlewares
// that want to inspect the response body.
func (res *ServerHTTPResponse) PeekBody(
keys ...string,
) ([]byte, jsonparser.ValueType, error) {
value, valueType, _, err := jsonparser.Get(
res.pendingBodyBytes, keys...,
)
if err != nil {
return nil, -1, err
}
return value, valueType, nil
}
// Flush will write the body to the response. Before flush is called
// the body is pending. A pending body allows a response middleware to
// write a different body.
func (res *ServerHTTPResponse) flush(ctx context.Context) {
if res.flushed {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Flushed a server response multiple times",
zap.String("path", res.Request.URL.Path),
)
/* coverage ignore next line */
return
}
res.flushed = true
res.writeHeader(res.pendingStatusCode)
if _, noContent := noContentStatusCodes[res.pendingStatusCode]; !noContent {
res.writeBytes(res.pendingBodyBytes)
}
res.finish(ctx)
}
func (res *ServerHTTPResponse) writeHeader(statusCode int) {
res.StatusCode = statusCode
res.responseWriter.WriteHeader(statusCode)
}
// WriteBytes writes raw bytes to output
func (res *ServerHTTPResponse) writeBytes(bytes []byte) {
_, err := res.responseWriter.Write(bytes)
if err != nil {
/* coverage ignore next line */
res.contextLogger.Error(res.Request.Context(),
"Could not write string to resp body",
zap.Error(err),
zap.String("bytesLength", strconv.Itoa(len(bytes))),
)
}
}
// GetPendingResponse lets you read the pending body bytes, obj and status code
// which isn't sent back yet.
func (res *ServerHTTPResponse) GetPendingResponse() ([]byte, int) {
return res.pendingBodyBytes, res.pendingStatusCode
}
// GetPendingResponseObject lets you read the pending body object
// which isn't sent back yet.
func (res *ServerHTTPResponse) GetPendingResponseObject() interface{} | {
return res.pendingBodyObj
} | identifier_body | |
server_http_response.go | "
"go.uber.org/zap/zapcore"
)
// ServerHTTPResponse struct manages server http response
type ServerHTTPResponse struct {
Request *ServerHTTPRequest
StatusCode int
responseWriter http.ResponseWriter
flushed bool
finished bool
finishTime time.Time
DownstreamFinishTime time.Duration
ClientType string
pendingBodyBytes []byte
pendingBodyObj interface{}
pendingStatusCode int
contextLogger ContextLogger
scope tally.Scope
jsonWrapper jsonwrapper.JSONWrapper
Err error
}
// NewServerHTTPResponse is helper function to alloc ServerHTTPResponse
func NewServerHTTPResponse(
w http.ResponseWriter,
req *ServerHTTPRequest,
) *ServerHTTPResponse {
return &ServerHTTPResponse{
Request: req,
StatusCode: 200,
responseWriter: w,
contextLogger: req.contextLogger,
scope: req.scope,
jsonWrapper: req.jsonWrapper,
}
}
// finish will handle final logic, like metrics
func (res *ServerHTTPResponse) finish(ctx context.Context) {
logFields := GetLogFieldsFromCtx(ctx)
if !res.Request.started {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Forgot to start server response",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
if res.finished {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Finished a server response multiple times",
append(logFields, zap.String("path", res.Request.URL.Path))...,
)
/* coverage ignore next line */
return
}
res.finished = true
res.finishTime = time.Now()
_, known := knownStatusCodes[res.StatusCode]
tagged := res.scope.Tagged(map[string]string{
scopeTagStatus: fmt.Sprintf("%d", res.StatusCode), // no need to put this tag on the context because this is the end of response life cycle
scopeTagClientType: res.ClientType,
})
delta := res.finishTime.Sub(res.Request.startTime)
tagged.Timer(endpointLatency).Record(delta)
tagged.Histogram(endpointLatencyHist, tally.DefaultBuckets).RecordDuration(delta)
if res.DownstreamFinishTime != 0 {
overhead := delta - res.DownstreamFinishTime
overheadRatio := overhead.Seconds() / delta.Seconds()
tagged.Timer(endpointOverheadLatency).Record(overhead)
tagged.Histogram(endpointOverheadLatencyHist, tally.DefaultBuckets).RecordDuration(overhead)
tagged.Gauge(endpointOverheadRatio).Update(overheadRatio)
}
if !known {
res.contextLogger.Error(ctx,
"Unknown status code",
append(logFields, zap.Int("UnknownStatusCode", res.StatusCode))...,
)
} else {
tagged.Counter(endpointStatus).Inc(1)
}
logFn := res.contextLogger.Debug
if !known || res.StatusCode >= 400 && res.StatusCode < 600 {
tagged.Counter(endpointAppErrors).Inc(1)
logFn = res.contextLogger.WarnZ
}
span := res.Request.GetSpan()
if span != nil {
span.Finish()
}
logFn(ctx,
fmt.Sprintf("Finished an incoming server HTTP request with %d status code", res.StatusCode),
append(logFields, serverHTTPLogFields(res.Request, res)...)...,
)
}
func serverHTTPLogFields(req *ServerHTTPRequest, res *ServerHTTPResponse) []zapcore.Field {
fields := []zapcore.Field{
zap.Int(logFieldResponseStatusCode, res.StatusCode),
}
for k, v := range res.Headers() {
if len(v) > 0 {
fields = append(fields, zap.String(
fmt.Sprintf("%s-%s", logFieldEndpointResponseHeaderPrefix, k),
strings.Join(v, ", "),
))
}
}
if res.Err != nil {
fields = append(fields, zap.Error(res.Err))
cause := errors.Cause(res.Err)
if cause != nil && cause != res.Err {
fields = append(fields, zap.NamedError("errorCause", cause))
}
}
return fields
}
// SendErrorString helper to send an error string
func (res *ServerHTTPResponse) SendErrorString(
statusCode int, errMsg string,
) {
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// SendError helper to send an server error message, propagates underlying cause to logs etc.
func (res *ServerHTTPResponse) SendError(
statusCode int, errMsg string, errCause error,
) {
res.Err = errCause
res.WriteJSONBytes(statusCode, nil,
[]byte(`{"error":"`+errMsg+`"}`),
)
}
// WriteBytes writes a byte[] slice that is valid Response
func (res *ServerHTTPResponse) WriteBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
res.responseWriter.Header().Set(k, v)
}
}
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
}
// WriteJSONBytes writes a byte[] slice that is valid json to Response
func (res *ServerHTTPResponse) WriteJSONBytes(
statusCode int, headers Header, bytes []byte,
) {
if headers == nil {
headers = ServerHTTPHeader{}
}
headers.Add("content-type", "application/json")
res.WriteBytes(statusCode, headers, bytes)
}
// MarshalResponseJSON serializes a json serializable into bytes
func (res *ServerHTTPResponse) MarshalResponseJSON(body interface{}) []byte {
ctx := res.Request.Context()
if body == nil {
res.SendError(500, "Could not serialize json response", errors.New("No Body JSON"))
res.contextLogger.Error(ctx, "Could not serialize nil pointer body")
return nil
}
bytes, err := res.jsonWrapper.Marshal(body)
if err != nil {
res.SendError(500, "Could not serialize json response", err)
res.contextLogger.Error(ctx, "Could not serialize json response", zap.Error(err))
return nil
}
return bytes
}
// SendResponse sets content-type if not present and fills Response
func (res *ServerHTTPResponse) SendResponse(statusCode int, headers Header, body interface{}, bytes []byte) {
contentTypePresent := false
if headers != nil {
for _, k := range headers.Keys() {
v, ok := headers.Get(k)
if ok {
if k == "Content-Type" {
contentTypePresent = true
}
res.responseWriter.Header().Set(k, v)
}
}
}
// Set the content-type to application/json if not already available
if !contentTypePresent {
res.responseWriter.Header().
Set("content-type", "application/json")
}
res.pendingStatusCode = statusCode
res.pendingBodyBytes = bytes
res.pendingBodyObj = body
}
// WriteJSON writes a json serializable struct to Response
func (res *ServerHTTPResponse) WriteJSON(
statusCode int, headers Header, body interface{},
) {
bytes := res.MarshalResponseJSON(body)
if bytes == nil {
return
}
res.SendResponse(statusCode, headers, body, bytes)
}
// PeekBody allows for inspecting a key path inside the body
// that is not flushed yet. This is useful for response middlewares
// that want to inspect the response body.
func (res *ServerHTTPResponse) PeekBody(
keys ...string,
) ([]byte, jsonparser.ValueType, error) {
value, valueType, _, err := jsonparser.Get(
res.pendingBodyBytes, keys...,
)
if err != nil {
return nil, -1, err
}
return value, valueType, nil
}
// Flush will write the body to the response. Before flush is called
// the body is pending. A pending body allows a response middleware to
// write a different body.
func (res *ServerHTTPResponse) flush(ctx context.Context) {
if res.flushed {
/* coverage ignore next line */
res.contextLogger.Error(ctx,
"Flushed a server response multiple times",
zap.String("path", res.Request.URL.Path),
)
/* coverage ignore next line */
return
}
res.flushed = true
res.writeHeader(res.pendingStatusCode)
if _, noContent := noContentStatusCodes[res.pendingStatusCode]; !noContent {
res.writeBytes(res.pendingBodyBytes)
}
res.finish(ctx)
}
func (res *ServerHTTPResponse) writeHeader(statusCode int) {
res.StatusCode = statusCode
res.responseWriter.WriteHeader(statusCode)
}
// WriteBytes writes raw bytes to output
func (res *ServerHTTPResponse) writeBytes(bytes []byte) {
_, err := res.responseWriter.Write(bytes)
if err != nil {
/* coverage ignore next line */
res.contextLogger.Error(res.Request.Context(),
"Could not write string to resp body",
zap.Error(err),
zap.String("bytesLength", strconv.Itoa(len(bytes))),
)
}
}
// GetPendingResponse lets you read the pending body bytes, obj and status code | // which isn't sent back yet.
func (res *ServerHTTPResponse) GetPendingResponse() ([]byte, int) {
return res.pendingBodyBytes, res.pendingStatusCode
}
| random_line_split | |
push_service.go | ps.doSenderClose:
close(ps.sentQueue)
return
case messages := <-mainSendingMessage:
logdebug("Sending new message: %d to %s", messages.id, messages.DeviceToken)
data, err := createBinaryNotification(messages, messages.id, messages.DeviceToken)
if err != nil {
messages.SetStatus(err, true)
break
}
_, err = ps.conn.Write(data)
if err != nil {
ps.lastError = nil
pushPool.releasedServices <- ps
close(ps.sentQueue)
return
}
logdebug("Message id: %d sent", messages.id)
ps.sentQueue <- messages
pushPool.reportQueue <- ¬ifReport{sent: 1}
}
}
}
func (ps *pushService) monitorReply() {
defer func() {
ps.waitClose.Done()
logdebug("Message reply stopped %p", ps)
}()
logdebug("Message reply started %p", ps)
readb := [6]byte{}
for {
n, err := ps.conn.Read(readb[:])
if err != nil {
logerr("APNS read channel is closed %s", err)
//when the read socket channel is closed the last payload i think isn't sent ok
//i don't know the last message id so we consider id 0 as last message and don't use this socket
ps.lastError = err
ps.confirmedQueue <- &apnsReceiveMessage{lastMessage: true}
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
if n == 6 {
// if status 0 (this i think isn't going to happen as apple says)
// if status 2 to 8 it's device token or payload error, don't try to resend
// if status 1 it's a proccessing error, we should retry sending the payload
// if status 10 the payload was sent but we must not send anything else on this socket (is shutdown)
// if status 255 it's unknown error (let's retry to send the payload) - close socket
// if status number unknown ???? (ok, let's retry to send the payload) - close socket
status := readb[1]
id := binary.BigEndian.Uint32(readb[2:])
ps.confirmedQueue <- &apnsReceiveMessage{status: status, id: id}
logdebug("Received confirmation for id: %d with status: %d", id, status)
if status != 0 {
ps.lastError = fmt.Errorf("APNs server reply with status %d (%s), closing", status, statusToError(status))
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
} else {
//unknow data sent from apple
// let's close the socket and mark all the messagess with error
logerr("Unknow apple message (%s) socket will be closed", hex.EncodeToString(readb[:n]))
//we consinder that max uint32 means to delete all the messages from the queue
ps.lastError = fmt.Errorf("Unknow apple message (%s) socket will be closed", hex.EncodeToString(readb[:n]))
ps.confirmedQueue <- &apnsReceiveMessage{unknownMessage: true}
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
}
}
func (ps *pushService) monitorMessages() {
defer func() {
ps.waitClose.Done()
logdebug("Message monitor stopped %p", ps)
}()
logdebug("Message monitor started %p", ps)
check := time.Tick(time.Millisecond * 50)
messageList := newMessageQueue()
readerStopped := false
writerStopped := false
//make sure that we don't have messages in the list
//what we have on exit we mark as error
defer func() {
messageList.SetAllFailed(fmt.Errorf("Message in the remained queue on close"))
logdebug("Push service is stopping, all the messages from the queue will be reposted")
if ps.lastError != nil { //anounnce the pool master that we had an error
pushPool.releasedServices <- ps
}
}()
for {
select {
case <-check: // check if we have messages older then SuccessTimeout so we can mark them
// logdebug("Check to mark message too old as success: %p", ps)
messageList.SetSuccessOlder(defaultConfig.SuccessTimeout)
case message, is_open := <-ps.sentQueue:
if !is_open {
//writer has exited we return only if the reader is stopped too
//we are going to clean the message list on exit
logdebug("Sent queue channel closed for %p", ps)
writerStopped = true
if readerStopped {
logdebug("Confirm channel closed too for: %p", ps)
return
}
ps.sentQueue = nil
break
}
logdebug("New message %d in the confirmation queue %p", message.id, ps)
messageList.PushBack(message)
case finishMessage, is_open := <-ps.confirmedQueue:
if !is_open {
//reader has exited we return only if the writer is stopped too
//we are going to clean the message list on exit
logdebug("Confirm queue channel closed for %p", ps)
readerStopped = true
if writerStopped {
logdebug("Sent channel closed too for: %p", ps)
return
}
ps.confirmedQueue = nil
break
}
//mark all excluding last one as success, we are going to close
if finishMessage.lastMessage |
//mark all as failed
if finishMessage.unknownMessage {
messageList.SetAllFailed(fmt.Errorf("Unknown error response from apple, all failed"))
logdebug("All messages are marked as error :%p", ps)
break
}
//mark all from front to the id as success
if finishMessage.status == 0 {
messageList.SetSuccess(finishMessage.id)
logdebug("Mark message %d as success: %p", finishMessage.id, ps)
break
}
//mark all until this one as success and this one mark it as temporar error
if finishMessage.status == 1 || finishMessage.status == 255 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), false)
logdebug("Mark message %d with temporar error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
} //success until excluding id, id failed
//mark all until this one as success and this one mark as permanent error
if finishMessage.status >= 2 && finishMessage.status <= 8 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), true)
logdebug("Mark message %d with permanend error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
}
//mark all including this one as success
if finishMessage.status == 10 {
messageList.SetSuccess(finishMessage.id)
messageList.SetAllFailed(fmt.Errorf("Apple it's in mantainance mode, socket shutdown"))
logdebug("Mark message %d with success and the rest with temp error %p", finishMessage.id, ps)
break
} //success until including id
//the rest of status codes we don't know, we consider that it's another problem
//from apple so mark the message as temporar error and the front as success
messageList.SetAllFailed(statusToError(finishMessage.status))
logdebug("Mark all messages with error: %s - %p", statusToError(finishMessage.status), ps)
}
}
}
type apnsReceiveMessage struct {
unknownMessage bool
lastMessage bool
status uint8
id uint32
}
type ApnsMessage struct {
PayloadInterface
DeviceToken string
Error error
id uint32
lastSentTime time.Time
receivedTime time.Time
sentTimes uint
}
func (a *ApnsMessage) SetStatus(err error, permanentError bool) {
a.Error = err
shouldConfirm := false
if err == nil || permanentError {
shouldConfirm = true
}
a.sentTimes++
if a.sentTimes >= defaultConfig.MaxMessageRetry {
shouldConfirm = true
}
if shouldConfirm {
nr := ¬ifReport{confirmTime: time.Since(a.lastSentTime), sendingTime: time.Since(a.receivedTime)}
if a.Error != nil {
nr.failed = 1
} else {
nr.success = 1
}
pushPool.reportQueue <- nr
confirmMessage(a)
} else {
pushPool.reportQueue <- ¬ifReport{failed: 1, resent: 1, confirmTime: time.Since(a.lastSentTime)}
res | {
messageList.SetLastFailed(fmt.Errorf("Unknow error after last message sent"))
logdebug("Going to remove last message from queue with error: %p", ps)
break
} | conditional_block |
push_service.go | from the queue
ps.lastError = fmt.Errorf("Unknow apple message (%s) socket will be closed", hex.EncodeToString(readb[:n]))
ps.confirmedQueue <- &apnsReceiveMessage{unknownMessage: true}
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
}
}
func (ps *pushService) monitorMessages() {
defer func() {
ps.waitClose.Done()
logdebug("Message monitor stopped %p", ps)
}()
logdebug("Message monitor started %p", ps)
check := time.Tick(time.Millisecond * 50)
messageList := newMessageQueue()
readerStopped := false
writerStopped := false
//make sure that we don't have messages in the list
//what we have on exit we mark as error
defer func() {
messageList.SetAllFailed(fmt.Errorf("Message in the remained queue on close"))
logdebug("Push service is stopping, all the messages from the queue will be reposted")
if ps.lastError != nil { //anounnce the pool master that we had an error
pushPool.releasedServices <- ps
}
}()
for {
select {
case <-check: // check if we have messages older then SuccessTimeout so we can mark them
// logdebug("Check to mark message too old as success: %p", ps)
messageList.SetSuccessOlder(defaultConfig.SuccessTimeout)
case message, is_open := <-ps.sentQueue:
if !is_open {
//writer has exited we return only if the reader is stopped too
//we are going to clean the message list on exit
logdebug("Sent queue channel closed for %p", ps)
writerStopped = true
if readerStopped {
logdebug("Confirm channel closed too for: %p", ps)
return
}
ps.sentQueue = nil
break
}
logdebug("New message %d in the confirmation queue %p", message.id, ps)
messageList.PushBack(message)
case finishMessage, is_open := <-ps.confirmedQueue:
if !is_open {
//reader has exited we return only if the writer is stopped too
//we are going to clean the message list on exit
logdebug("Confirm queue channel closed for %p", ps)
readerStopped = true
if writerStopped {
logdebug("Sent channel closed too for: %p", ps)
return
}
ps.confirmedQueue = nil
break
}
//mark all excluding last one as success, we are going to close
if finishMessage.lastMessage {
messageList.SetLastFailed(fmt.Errorf("Unknow error after last message sent"))
logdebug("Going to remove last message from queue with error: %p", ps)
break
}
//mark all as failed
if finishMessage.unknownMessage {
messageList.SetAllFailed(fmt.Errorf("Unknown error response from apple, all failed"))
logdebug("All messages are marked as error :%p", ps)
break
}
//mark all from front to the id as success
if finishMessage.status == 0 {
messageList.SetSuccess(finishMessage.id)
logdebug("Mark message %d as success: %p", finishMessage.id, ps)
break
}
//mark all until this one as success and this one mark it as temporar error
if finishMessage.status == 1 || finishMessage.status == 255 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), false)
logdebug("Mark message %d with temporar error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
} //success until excluding id, id failed
//mark all until this one as success and this one mark as permanent error
if finishMessage.status >= 2 && finishMessage.status <= 8 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), true)
logdebug("Mark message %d with permanend error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
}
//mark all including this one as success
if finishMessage.status == 10 {
messageList.SetSuccess(finishMessage.id)
messageList.SetAllFailed(fmt.Errorf("Apple it's in mantainance mode, socket shutdown"))
logdebug("Mark message %d with success and the rest with temp error %p", finishMessage.id, ps)
break
} //success until including id
//the rest of status codes we don't know, we consider that it's another problem
//from apple so mark the message as temporar error and the front as success
messageList.SetAllFailed(statusToError(finishMessage.status))
logdebug("Mark all messages with error: %s - %p", statusToError(finishMessage.status), ps)
}
}
}
type apnsReceiveMessage struct {
unknownMessage bool
lastMessage bool
status uint8
id uint32
}
type ApnsMessage struct {
PayloadInterface
DeviceToken string
Error error
id uint32
lastSentTime time.Time
receivedTime time.Time
sentTimes uint
}
func (a *ApnsMessage) SetStatus(err error, permanentError bool) {
a.Error = err
shouldConfirm := false
if err == nil || permanentError {
shouldConfirm = true
}
a.sentTimes++
if a.sentTimes >= defaultConfig.MaxMessageRetry {
shouldConfirm = true
}
if shouldConfirm {
nr := ¬ifReport{confirmTime: time.Since(a.lastSentTime), sendingTime: time.Since(a.receivedTime)}
if a.Error != nil {
nr.failed = 1
} else {
nr.success = 1
}
pushPool.reportQueue <- nr
confirmMessage(a)
} else {
pushPool.reportQueue <- ¬ifReport{failed: 1, resent: 1, confirmTime: time.Since(a.lastSentTime)}
resendMessage(a)
}
}
func newMessageQueue() *apnsMessageQueue {
return &apnsMessageQueue{list.New()}
}
type apnsMessageQueue struct {
mList *list.List
}
func (amq *apnsMessageQueue) PushBack(m *ApnsMessage) {
m.lastSentTime = time.Now()
amq.mList.PushBack(m)
}
func (amq *apnsMessageQueue) SetSuccessOlder(older time.Duration) {
var next *list.Element
for e := amq.mList.Front(); e != nil; e = next {
next = e.Next()
message := e.Value.(*ApnsMessage)
if time.Since(message.lastSentTime) > older {
logdebug("Mark message %d as success after timeout", message.id)
message.SetStatus(nil, false)
amq.mList.Remove(e)
}
}
}
func (amq *apnsMessageQueue) SetSuccess(id uint32) {
var next *list.Element
for e := amq.mList.Front(); e != nil; e = next {
next = e.Next()
message := e.Value.(*ApnsMessage)
message.SetStatus(nil, false)
amq.mList.Remove(e)
if message.id == id {
return
}
}
logwarn("I didn't found message %d to set it as success", id)
}
func (amq *apnsMessageQueue) SetFailed(id uint32, err error, permanentError bool) {
var next *list.Element
logdebug("Set message %d to status failed permanent: %t (%s)", id, permanentError, err)
for e := amq.mList.Front(); e != nil; e = next {
next = e.Next()
message := e.Value.(*ApnsMessage)
amq.mList.Remove(e)
if message.id == id {
message.SetStatus(err, permanentError)
return
} else {
message.SetStatus(nil, false)
}
}
logwarn("I didn't found message %d to set it as failed, permanent: %t (%s)", id, permanentError, err)
}
func (amq *apnsMessageQueue) SetLastFailed(err error) {
last := amq.mList.Back()
if last == nil {
logdebug("No message found in the queue when i wanted to delete the last one")
return
}
message := last.Value.(*ApnsMessage)
logdebug("Set LAST message %d to status failed", message.id)
amq.SetFailed(message.id, err, true)
}
func (amq *apnsMessageQueue) SetAllFailed(err error) {
logdebug("Set all messages to failed: %s", err)
var next *list.Element
for e := amq.mList.Front(); e != nil; e = next {
next = e.Next()
message := e.Value.(*ApnsMessage)
message.SetStatus(err, false)
amq.mList.Remove(e)
}
}
type PayloadInterface interface {
ToJson() ([]byte, error) | Config() (expiration uint32, priority uint8)
}
func statusToError(status uint8) error {
e, ok := appleErrorMap[status] | random_line_split | |
push_service.go | if err != nil {
ps.lastError = nil
pushPool.releasedServices <- ps
close(ps.sentQueue)
return
}
logdebug("Message id: %d sent", messages.id)
ps.sentQueue <- messages
pushPool.reportQueue <- ¬ifReport{sent: 1}
}
}
}
func (ps *pushService) monitorReply() {
defer func() {
ps.waitClose.Done()
logdebug("Message reply stopped %p", ps)
}()
logdebug("Message reply started %p", ps)
readb := [6]byte{}
for {
n, err := ps.conn.Read(readb[:])
if err != nil {
logerr("APNS read channel is closed %s", err)
//when the read socket channel is closed the last payload i think isn't sent ok
//i don't know the last message id so we consider id 0 as last message and don't use this socket
ps.lastError = err
ps.confirmedQueue <- &apnsReceiveMessage{lastMessage: true}
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
if n == 6 {
// if status 0 (this i think isn't going to happen as apple says)
// if status 2 to 8 it's device token or payload error, don't try to resend
// if status 1 it's a proccessing error, we should retry sending the payload
// if status 10 the payload was sent but we must not send anything else on this socket (is shutdown)
// if status 255 it's unknown error (let's retry to send the payload) - close socket
// if status number unknown ???? (ok, let's retry to send the payload) - close socket
status := readb[1]
id := binary.BigEndian.Uint32(readb[2:])
ps.confirmedQueue <- &apnsReceiveMessage{status: status, id: id}
logdebug("Received confirmation for id: %d with status: %d", id, status)
if status != 0 {
ps.lastError = fmt.Errorf("APNs server reply with status %d (%s), closing", status, statusToError(status))
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
} else {
//unknow data sent from apple
// let's close the socket and mark all the messagess with error
logerr("Unknow apple message (%s) socket will be closed", hex.EncodeToString(readb[:n]))
//we consinder that max uint32 means to delete all the messages from the queue
ps.lastError = fmt.Errorf("Unknow apple message (%s) socket will be closed", hex.EncodeToString(readb[:n]))
ps.confirmedQueue <- &apnsReceiveMessage{unknownMessage: true}
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
}
}
func (ps *pushService) monitorMessages() {
defer func() {
ps.waitClose.Done()
logdebug("Message monitor stopped %p", ps)
}()
logdebug("Message monitor started %p", ps)
check := time.Tick(time.Millisecond * 50)
messageList := newMessageQueue()
readerStopped := false
writerStopped := false
//make sure that we don't have messages in the list
//what we have on exit we mark as error
defer func() {
messageList.SetAllFailed(fmt.Errorf("Message in the remained queue on close"))
logdebug("Push service is stopping, all the messages from the queue will be reposted")
if ps.lastError != nil { //anounnce the pool master that we had an error
pushPool.releasedServices <- ps
}
}()
for {
select {
case <-check: // check if we have messages older then SuccessTimeout so we can mark them
// logdebug("Check to mark message too old as success: %p", ps)
messageList.SetSuccessOlder(defaultConfig.SuccessTimeout)
case message, is_open := <-ps.sentQueue:
if !is_open {
//writer has exited we return only if the reader is stopped too
//we are going to clean the message list on exit
logdebug("Sent queue channel closed for %p", ps)
writerStopped = true
if readerStopped {
logdebug("Confirm channel closed too for: %p", ps)
return
}
ps.sentQueue = nil
break
}
logdebug("New message %d in the confirmation queue %p", message.id, ps)
messageList.PushBack(message)
case finishMessage, is_open := <-ps.confirmedQueue:
if !is_open {
//reader has exited we return only if the writer is stopped too
//we are going to clean the message list on exit
logdebug("Confirm queue channel closed for %p", ps)
readerStopped = true
if writerStopped {
logdebug("Sent channel closed too for: %p", ps)
return
}
ps.confirmedQueue = nil
break
}
//mark all excluding last one as success, we are going to close
if finishMessage.lastMessage {
messageList.SetLastFailed(fmt.Errorf("Unknow error after last message sent"))
logdebug("Going to remove last message from queue with error: %p", ps)
break
}
//mark all as failed
if finishMessage.unknownMessage {
messageList.SetAllFailed(fmt.Errorf("Unknown error response from apple, all failed"))
logdebug("All messages are marked as error :%p", ps)
break
}
//mark all from front to the id as success
if finishMessage.status == 0 {
messageList.SetSuccess(finishMessage.id)
logdebug("Mark message %d as success: %p", finishMessage.id, ps)
break
}
//mark all until this one as success and this one mark it as temporar error
if finishMessage.status == 1 || finishMessage.status == 255 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), false)
logdebug("Mark message %d with temporar error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
} //success until excluding id, id failed
//mark all until this one as success and this one mark as permanent error
if finishMessage.status >= 2 && finishMessage.status <= 8 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), true)
logdebug("Mark message %d with permanend error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
}
//mark all including this one as success
if finishMessage.status == 10 {
messageList.SetSuccess(finishMessage.id)
messageList.SetAllFailed(fmt.Errorf("Apple it's in mantainance mode, socket shutdown"))
logdebug("Mark message %d with success and the rest with temp error %p", finishMessage.id, ps)
break
} //success until including id
//the rest of status codes we don't know, we consider that it's another problem
//from apple so mark the message as temporar error and the front as success
messageList.SetAllFailed(statusToError(finishMessage.status))
logdebug("Mark all messages with error: %s - %p", statusToError(finishMessage.status), ps)
}
}
}
type apnsReceiveMessage struct {
unknownMessage bool
lastMessage bool
status uint8
id uint32
}
type ApnsMessage struct {
PayloadInterface
DeviceToken string
Error error
id uint32
lastSentTime time.Time
receivedTime time.Time
sentTimes uint
}
func (a *ApnsMessage) SetStatus(err error, permanentError bool) {
a.Error = err
shouldConfirm := false
if err == nil || permanentError {
shouldConfirm = true
}
a.sentTimes++
if a.sentTimes >= defaultConfig.MaxMessageRetry {
shouldConfirm = true
}
if shouldConfirm {
nr := ¬ifReport{confirmTime: time.Since(a.lastSentTime), sendingTime: time.Since(a.receivedTime)}
if a.Error != nil {
nr.failed = 1
} else {
nr.success = 1
}
pushPool.reportQueue <- nr
confirmMessage(a)
} else {
pushPool.reportQueue <- ¬ifReport{failed: 1, resent: 1, confirmTime: time.Since(a.lastSentTime)}
resendMessage(a)
}
}
func newMessageQueue() *apnsMessageQueue {
return &apnsMessageQueue{list.New()}
}
type apnsMessageQueue struct {
mList *list.List
}
func (amq *apnsMessageQueue) PushBack(m *ApnsMessage) {
m.lastSentTime = time.Now()
amq.mList.PushBack(m)
}
func (amq *apnsMessageQueue) | SetSuccessOlder | identifier_name | |
push_service.go | to send the payload) - close socket
// if status number unknown ???? (ok, let's retry to send the payload) - close socket
status := readb[1]
id := binary.BigEndian.Uint32(readb[2:])
ps.confirmedQueue <- &apnsReceiveMessage{status: status, id: id}
logdebug("Received confirmation for id: %d with status: %d", id, status)
if status != 0 {
ps.lastError = fmt.Errorf("APNs server reply with status %d (%s), closing", status, statusToError(status))
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
} else {
//unknow data sent from apple
// let's close the socket and mark all the messagess with error
logerr("Unknow apple message (%s) socket will be closed", hex.EncodeToString(readb[:n]))
//we consinder that max uint32 means to delete all the messages from the queue
ps.lastError = fmt.Errorf("Unknow apple message (%s) socket will be closed", hex.EncodeToString(readb[:n]))
ps.confirmedQueue <- &apnsReceiveMessage{unknownMessage: true}
ps.doSenderClose <- true
close(ps.confirmedQueue)
break
}
}
}
func (ps *pushService) monitorMessages() {
defer func() {
ps.waitClose.Done()
logdebug("Message monitor stopped %p", ps)
}()
logdebug("Message monitor started %p", ps)
check := time.Tick(time.Millisecond * 50)
messageList := newMessageQueue()
readerStopped := false
writerStopped := false
//make sure that we don't have messages in the list
//what we have on exit we mark as error
defer func() {
messageList.SetAllFailed(fmt.Errorf("Message in the remained queue on close"))
logdebug("Push service is stopping, all the messages from the queue will be reposted")
if ps.lastError != nil { //anounnce the pool master that we had an error
pushPool.releasedServices <- ps
}
}()
for {
select {
case <-check: // check if we have messages older then SuccessTimeout so we can mark them
// logdebug("Check to mark message too old as success: %p", ps)
messageList.SetSuccessOlder(defaultConfig.SuccessTimeout)
case message, is_open := <-ps.sentQueue:
if !is_open {
//writer has exited we return only if the reader is stopped too
//we are going to clean the message list on exit
logdebug("Sent queue channel closed for %p", ps)
writerStopped = true
if readerStopped {
logdebug("Confirm channel closed too for: %p", ps)
return
}
ps.sentQueue = nil
break
}
logdebug("New message %d in the confirmation queue %p", message.id, ps)
messageList.PushBack(message)
case finishMessage, is_open := <-ps.confirmedQueue:
if !is_open {
//reader has exited we return only if the writer is stopped too
//we are going to clean the message list on exit
logdebug("Confirm queue channel closed for %p", ps)
readerStopped = true
if writerStopped {
logdebug("Sent channel closed too for: %p", ps)
return
}
ps.confirmedQueue = nil
break
}
//mark all excluding last one as success, we are going to close
if finishMessage.lastMessage {
messageList.SetLastFailed(fmt.Errorf("Unknow error after last message sent"))
logdebug("Going to remove last message from queue with error: %p", ps)
break
}
//mark all as failed
if finishMessage.unknownMessage {
messageList.SetAllFailed(fmt.Errorf("Unknown error response from apple, all failed"))
logdebug("All messages are marked as error :%p", ps)
break
}
//mark all from front to the id as success
if finishMessage.status == 0 {
messageList.SetSuccess(finishMessage.id)
logdebug("Mark message %d as success: %p", finishMessage.id, ps)
break
}
//mark all until this one as success and this one mark it as temporar error
if finishMessage.status == 1 || finishMessage.status == 255 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), false)
logdebug("Mark message %d with temporar error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
} //success until excluding id, id failed
//mark all until this one as success and this one mark as permanent error
if finishMessage.status >= 2 && finishMessage.status <= 8 {
messageList.SetFailed(finishMessage.id, statusToError(finishMessage.status), true)
logdebug("Mark message %d with permanend error on status: %d %p", finishMessage.id, finishMessage.status, ps)
break
}
//mark all including this one as success
if finishMessage.status == 10 {
messageList.SetSuccess(finishMessage.id)
messageList.SetAllFailed(fmt.Errorf("Apple it's in mantainance mode, socket shutdown"))
logdebug("Mark message %d with success and the rest with temp error %p", finishMessage.id, ps)
break
} //success until including id
//the rest of status codes we don't know, we consider that it's another problem
//from apple so mark the message as temporar error and the front as success
messageList.SetAllFailed(statusToError(finishMessage.status))
logdebug("Mark all messages with error: %s - %p", statusToError(finishMessage.status), ps)
}
}
}
type apnsReceiveMessage struct {
unknownMessage bool
lastMessage bool
status uint8
id uint32
}
type ApnsMessage struct {
PayloadInterface
DeviceToken string
Error error
id uint32
lastSentTime time.Time
receivedTime time.Time
sentTimes uint
}
func (a *ApnsMessage) SetStatus(err error, permanentError bool) {
a.Error = err
shouldConfirm := false
if err == nil || permanentError {
shouldConfirm = true
}
a.sentTimes++
if a.sentTimes >= defaultConfig.MaxMessageRetry {
shouldConfirm = true
}
if shouldConfirm {
nr := ¬ifReport{confirmTime: time.Since(a.lastSentTime), sendingTime: time.Since(a.receivedTime)}
if a.Error != nil {
nr.failed = 1
} else {
nr.success = 1
}
pushPool.reportQueue <- nr
confirmMessage(a)
} else {
pushPool.reportQueue <- ¬ifReport{failed: 1, resent: 1, confirmTime: time.Since(a.lastSentTime)}
resendMessage(a)
}
}
func newMessageQueue() *apnsMessageQueue {
return &apnsMessageQueue{list.New()}
}
type apnsMessageQueue struct {
mList *list.List
}
func (amq *apnsMessageQueue) PushBack(m *ApnsMessage) {
m.lastSentTime = time.Now()
amq.mList.PushBack(m)
}
func (amq *apnsMessageQueue) SetSuccessOlder(older time.Duration) {
var next *list.Element
for e := amq.mList.Front(); e != nil; e = next {
next = e.Next()
message := e.Value.(*ApnsMessage)
if time.Since(message.lastSentTime) > older {
logdebug("Mark message %d as success after timeout", message.id)
message.SetStatus(nil, false)
amq.mList.Remove(e)
}
}
}
func (amq *apnsMessageQueue) SetSuccess(id uint32) {
var next *list.Element
for e := amq.mList.Front(); e != nil; e = next {
next = e.Next()
message := e.Value.(*ApnsMessage)
message.SetStatus(nil, false)
amq.mList.Remove(e)
if message.id == id {
return
}
}
logwarn("I didn't found message %d to set it as success", id)
}
func (amq *apnsMessageQueue) SetFailed(id uint32, err error, permanentError bool) | {
var next *list.Element
logdebug("Set message %d to status failed permanent: %t (%s)", id, permanentError, err)
for e := amq.mList.Front(); e != nil; e = next {
next = e.Next()
message := e.Value.(*ApnsMessage)
amq.mList.Remove(e)
if message.id == id {
message.SetStatus(err, permanentError)
return
} else {
message.SetStatus(nil, false)
}
}
logwarn("I didn't found message %d to set it as failed, permanent: %t (%s)", id, permanentError, err) | identifier_body | |
view_test.go | ); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.Compilers.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.Settings.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
}
func (e *TestEnv) CreateUserRoles(login string, roles ...string) error {
for _, role := range roles {
if _, err := e.Socket.CreateUserRole(context.Background(), login, role); err != nil {
return err
}
}
return nil
}
func (e *TestEnv) Check(data any) {
e.checks.Check(data)
}
func (e *TestEnv) Close() {
e.Server.Close()
e.Core.Stop()
_ = db.ApplyMigrations(context.Background(), e.Core.DB, "solve", migrations.Schema, db.WithZeroMigration)
_ = db.ApplyMigrations(context.Background(), e.Core.DB, "solve_data", migrations.Data, db.WithZeroMigration)
e.checks.Close()
}
func (e *TestEnv) WaitProblemUpdated(id int64) {
for {
if err := e.Core.Tasks.Sync(context.Background()); err != nil {
e.tb.Fatal("Error:", err)
}
tasks, err := e.Core.Tasks.FindByProblem(id)
if err != nil {
e.tb.Fatal("Error:", err)
}
if len(tasks) == 0 {
e.tb.Fatal("Empty problem tasks")
}
if tasks[0].Status == models.SucceededTask {
return
}
if tasks[0].Status == models.FailedTask {
e.tb.Fatalf("Task failed: %q", string(tasks[0].State))
}
time.Sleep(time.Second)
}
}
type TestEnvOption interface {
UpdateConfig(*config.Config)
Setup(*TestEnv) error
}
type WithInvoker struct{}
func (o WithInvoker) UpdateConfig(cfg *config.Config) {
cfg.Invoker = &config.Invoker{
Workers: 1,
Safeexec: config.Safeexec{
Path: "../safeexec/safeexec",
},
}
}
func (o WithInvoker) Setup(env *TestEnv) error {
return invoker.New(env.Core).Start()
}
func NewTestEnv(tb testing.TB, options ...TestEnvOption) *TestEnv {
env := TestEnv{
tb: tb,
checks: newTestCheckState(tb),
Now: time.Date(2020, 1, 1, 10, 0, 0, 0, time.UTC),
Rand: rand.New(rand.NewSource(42)),
}
cfg := config.Config{
DB: config.DB{
Options: config.SQLiteOptions{Path: ":memory:"},
},
Security: &config.Security{
PasswordSalt: "qwerty123",
},
Storage: &config.Storage{
Options: config.LocalStorageOptions{
FilesDir: tb.TempDir(),
},
},
}
if _, ok := tb.(*testing.B); ok || os.Getenv("TEST_ENABLE_LOGS") != "1" {
log.SetLevel(log.OFF)
cfg.LogLevel = config.LogLevel(log.OFF)
}
for _, option := range options {
option.UpdateConfig(&cfg)
}
if c, err := core.NewCore(cfg); err != nil {
tb.Fatal("Error:", err)
} else {
env.Core = c
}
env.Core.SetupAllStores()
ctx := context.Background()
_ = db.ApplyMigrations(ctx, env.Core.DB, "solve", migrations.Schema, db.WithZeroMigration)
_ = db.ApplyMigrations(ctx, env.Core.DB, "solve_data", migrations.Data, db.WithZeroMigration)
if err := db.ApplyMigrations(ctx, env.Core.DB, "solve", migrations.Schema); err != nil {
tb.Fatal("Error:", err)
}
if err := db.ApplyMigrations(ctx, env.Core.DB, "solve_data", migrations.Data); err != nil {
tb.Fatal("Error:", err)
}
if err := env.Core.Start(); err != nil {
tb.Fatal("Error:", err)
}
e := echo.New()
e.Logger = env.Core.Logger()
view := NewView(env.Core)
nowFn := func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
c.Set(nowKey, env.Now)
return next(c)
}
}
e.Use(nowFn)
view.Register(e.Group("/api"))
view.RegisterSocket(e.Group("/socket"))
view.StartDaemons()
env.Server = httptest.NewServer(e)
env.Client = newTestClient(env.Server.URL + "/api")
env.Socket = newTestClient(env.Server.URL + "/socket")
for _, option := range options {
option.Setup(&env)
}
return &env
}
type TestUser struct {
User
Password string
env *TestEnv
}
func (u *TestUser) LoginClient() {
_, err := u.env.Client.Login(context.Background(), u.User.Login, u.Password)
if err != nil {
u.env.tb.Fatal("Error:", err)
}
}
func (u *TestUser) LogoutClient() {
if err := u.env.Client.Logout(context.Background()); err != nil {
u.env.tb.Fatal("Error:", err)
}
}
func (u *TestUser) AddRoles(names ...string) |
func NewTestUser(e *TestEnv) *TestUser {
login := fmt.Sprintf("login-%d", e.Rand.Int31())
password := fmt.Sprintf("password-%d", e.Rand.Int63())
user, err := e.Client.Register(context.Background(), RegisterUserForm{
Login: login,
Email: login + "@example.com",
Password: password,
FirstName: "First",
LastName: "Last",
MiddleName: "Middle",
})
if err != nil {
e.tb.Fatal("Error:", err)
}
return &TestUser{
User: user,
Password: password,
env: e,
}
}
type testCheckState struct {
tb testing.TB
checks []json.RawMessage
pos int
reset bool
path string
}
func (s *testCheckState) Check(data any) {
raw, err := json.MarshalIndent(data, "", " ")
if err != nil {
s.tb.Fatal("Unable to marshal data:", data)
}
if s.pos > len(s.checks) {
s.tb.Fatalf("Invalid check position: %d", s.pos)
}
if s.pos == len(s.checks) {
if s.reset {
s.checks = append(s.checks, raw)
s.pos++
return
}
s.tb.Errorf("Unexpected check with data: %s", raw)
s.tb.Fatalf("Maybe you should use: TEST_RESET_DATA=1")
}
options := jsondiff.DefaultConsoleOptions()
diff, report := jsondiff.Compare(s.checks[s.pos], raw, &options)
if diff != jsondiff.FullMatch {
if s.reset {
s.checks[s.pos] = raw
s.pos++
return
}
s.tb.Errorf("Unexpected result difference: %s", report)
s.tb.Fatalf("Maybe you should use: TEST_RESET_DATA=1")
}
s.pos++
}
func (s *testCheckState) Close() {
if s.reset {
if s.pos == 0 {
_ = os.Remove(s.path)
return
}
raw, err := json.MarshalIndent(s.checks, "", " ")
if err != nil {
s.tb.Fatal("Unable to marshal test data:", err)
}
if err := os.WriteFile(
s.path, raw, os.ModePerm,
); err != nil {
s.tb.Fatal("Error:", err)
}
}
}
func newTestCheckState(tb testing.TB) *testCheckState {
state := testCheckState{
tb: tb,
reset: os.Getenv("TEST_RESET_DATA") == "1",
path: filepath.Join("testdata", tb.Name()+".json"),
}
if !state.reset {
file, err := os.Open(state.path)
if err != nil {
if !errors.Is(err, os.ErrNotExist) {
tb.Fatal("Error:", err)
}
} else {
defer file.Close()
if err := json.NewDecoder(file).Decode(&state.checks); err != nil {
tb.Fatal("Error:", err)
}
}
}
return &state
}
type testClient struct {
*Client
}
type testJar struct {
mutex sync.Mutex
cookies map[string]*http.Cookie
}
func (j *testJar) Cookies(*url.URL) []*http.Cookie {
j.mutex.Lock()
defer j.mutex.Unlock()
var cookies []*http.Cookie
for _, cookie := range j.cookies {
cookies = append(cookies, cookie)
}
return cookies
}
func (j *testJar) SetCookies(u *url.URL, cookies []*http.Cookie) {
j.mutex.Lock()
defer j.mutex.Unlock()
if j.cookies == nil {
j.cookies = map[string]*http.Cookie{}
}
for _, cookie := range cookies {
j.cookies[cookie.Name] = cookie
}
}
func newTestClient(endpoint string) *testClient | {
if err := u.env.CreateUserRoles(u.User.Login, names...); err != nil {
u.env.tb.Fatal("Error:", err)
}
u.env.SyncStores()
} | identifier_body |
view_test.go |
if err := e.Core.Sessions.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.Roles.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.RoleEdges.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.AccountRoles.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.Contests.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.Problems.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.Compilers.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
if err := e.Core.Settings.Sync(ctx); err != nil {
e.tb.Fatal("Error:", err)
}
}
func (e *TestEnv) CreateUserRoles(login string, roles ...string) error {
for _, role := range roles {
if _, err := e.Socket.CreateUserRole(context.Background(), login, role); err != nil {
return err
}
}
return nil
}
func (e *TestEnv) Check(data any) {
e.checks.Check(data)
}
func (e *TestEnv) Close() {
e.Server.Close()
e.Core.Stop()
_ = db.ApplyMigrations(context.Background(), e.Core.DB, "solve", migrations.Schema, db.WithZeroMigration)
_ = db.ApplyMigrations(context.Background(), e.Core.DB, "solve_data", migrations.Data, db.WithZeroMigration)
e.checks.Close()
}
func (e *TestEnv) WaitProblemUpdated(id int64) {
for {
if err := e.Core.Tasks.Sync(context.Background()); err != nil {
e.tb.Fatal("Error:", err)
}
tasks, err := e.Core.Tasks.FindByProblem(id)
if err != nil {
e.tb.Fatal("Error:", err)
}
if len(tasks) == 0 {
e.tb.Fatal("Empty problem tasks")
}
if tasks[0].Status == models.SucceededTask {
return
}
if tasks[0].Status == models.FailedTask {
e.tb.Fatalf("Task failed: %q", string(tasks[0].State))
}
time.Sleep(time.Second)
}
}
type TestEnvOption interface {
UpdateConfig(*config.Config)
Setup(*TestEnv) error
}
type WithInvoker struct{}
func (o WithInvoker) UpdateConfig(cfg *config.Config) {
cfg.Invoker = &config.Invoker{
Workers: 1,
Safeexec: config.Safeexec{
Path: "../safeexec/safeexec",
},
}
}
func (o WithInvoker) Setup(env *TestEnv) error {
return invoker.New(env.Core).Start()
}
func NewTestEnv(tb testing.TB, options ...TestEnvOption) *TestEnv {
env := TestEnv{
tb: tb,
checks: newTestCheckState(tb),
Now: time.Date(2020, 1, 1, 10, 0, 0, 0, time.UTC),
Rand: rand.New(rand.NewSource(42)),
}
cfg := config.Config{
DB: config.DB{
Options: config.SQLiteOptions{Path: ":memory:"},
},
Security: &config.Security{
PasswordSalt: "qwerty123",
},
Storage: &config.Storage{
Options: config.LocalStorageOptions{
FilesDir: tb.TempDir(),
},
},
}
if _, ok := tb.(*testing.B); ok || os.Getenv("TEST_ENABLE_LOGS") != "1" {
log.SetLevel(log.OFF)
cfg.LogLevel = config.LogLevel(log.OFF)
}
for _, option := range options {
option.UpdateConfig(&cfg)
}
if c, err := core.NewCore(cfg); err != nil {
tb.Fatal("Error:", err)
} else {
env.Core = c
}
env.Core.SetupAllStores()
ctx := context.Background()
_ = db.ApplyMigrations(ctx, env.Core.DB, "solve", migrations.Schema, db.WithZeroMigration)
_ = db.ApplyMigrations(ctx, env.Core.DB, "solve_data", migrations.Data, db.WithZeroMigration)
if err := db.ApplyMigrations(ctx, env.Core.DB, "solve", migrations.Schema); err != nil {
tb.Fatal("Error:", err)
}
if err := db.ApplyMigrations(ctx, env.Core.DB, "solve_data", migrations.Data); err != nil {
tb.Fatal("Error:", err)
}
if err := env.Core.Start(); err != nil {
tb.Fatal("Error:", err)
}
e := echo.New()
e.Logger = env.Core.Logger()
view := NewView(env.Core)
nowFn := func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
c.Set(nowKey, env.Now)
return next(c)
}
}
e.Use(nowFn)
view.Register(e.Group("/api"))
view.RegisterSocket(e.Group("/socket"))
view.StartDaemons()
env.Server = httptest.NewServer(e)
env.Client = newTestClient(env.Server.URL + "/api")
env.Socket = newTestClient(env.Server.URL + "/socket")
for _, option := range options {
option.Setup(&env)
}
return &env
}
type TestUser struct {
User
Password string
env *TestEnv
}
func (u *TestUser) LoginClient() {
_, err := u.env.Client.Login(context.Background(), u.User.Login, u.Password)
if err != nil {
u.env.tb.Fatal("Error:", err)
}
}
func (u *TestUser) LogoutClient() {
if err := u.env.Client.Logout(context.Background()); err != nil {
u.env.tb.Fatal("Error:", err)
}
}
func (u *TestUser) AddRoles(names ...string) {
if err := u.env.CreateUserRoles(u.User.Login, names...); err != nil {
u.env.tb.Fatal("Error:", err)
}
u.env.SyncStores()
}
func NewTestUser(e *TestEnv) *TestUser {
login := fmt.Sprintf("login-%d", e.Rand.Int31())
password := fmt.Sprintf("password-%d", e.Rand.Int63())
user, err := e.Client.Register(context.Background(), RegisterUserForm{
Login: login,
Email: login + "@example.com",
Password: password,
FirstName: "First",
LastName: "Last",
MiddleName: "Middle",
})
if err != nil {
e.tb.Fatal("Error:", err)
}
return &TestUser{
User: user,
Password: password,
env: e,
}
}
type testCheckState struct {
tb testing.TB
checks []json.RawMessage
pos int
reset bool
path string
}
func (s *testCheckState) Check(data any) {
raw, err := json.MarshalIndent(data, "", " ")
if err != nil {
s.tb.Fatal("Unable to marshal data:", data)
}
if s.pos > len(s.checks) {
s.tb.Fatalf("Invalid check position: %d", s.pos)
}
if s.pos == len(s.checks) {
if s.reset {
s.checks = append(s.checks, raw)
s.pos++
return
}
s.tb.Errorf("Unexpected check with data: %s", raw)
s.tb.Fatalf("Maybe you should use: TEST_RESET_DATA=1")
}
options := jsondiff.DefaultConsoleOptions()
diff, report := jsondiff.Compare(s.checks[s.pos], raw, &options)
if diff != jsondiff.FullMatch {
if s.reset {
s.checks[s.pos] = raw
s.pos++
return
}
s.tb.Errorf("Unexpected result difference: %s", report)
s.tb.Fatalf("Maybe you should use: TEST_RESET_DATA=1")
}
s.pos++
}
func (s *testCheckState) Close() {
if s.reset {
if s.pos == 0 {
_ = os.Remove(s.path)
return
}
raw, err := json.MarshalIndent(s.checks, "", " ")
if err != nil {
s.tb.Fatal("Unable to marshal test data:", err)
}
if err := os.WriteFile(
s.path, raw, os.ModePerm,
); err != nil {
s.tb.Fatal("Error:", err)
}
}
}
func newTestCheckState(tb testing.TB) *testCheckState {
state := testCheckState{
tb: tb,
reset: os.Getenv("TEST_RESET_DATA") == "1",
path: filepath.Join("testdata", tb.Name()+".json"),
}
if !state.reset {
file, err := os.Open(state.path)
if err != nil {
if !errors.Is(err, os.ErrNotExist) {
tb.Fatal("Error:", err)
}
} else {
defer file.Close()
if err := json.NewDecoder(file).Decode(&state.checks); err != nil {
tb.Fatal("Error:", err)
}
}
}
return &state
}
type testClient struct {
*Client
}
type testJar struct {
mutex | {
e.tb.Fatal("Error:", err)
} | conditional_block |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.