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 |
|---|---|---|---|---|
demo.py | (modelID):
print "Loading parameters for model", modelID
selection=raw_input('Would you like to download NWB data for model? [Y/N] ')
if selection[0] == 'y' or selection[0] == 'Y':
currModel = Model(modelID, cache_stim = True)
if selection[0] == 'n' or selection[0] == 'N':
currModel = Model(modelID, cache_stim = False)
currModel.init_model()
while(True):
print "Initialized biophysical model", modelID
print '''
Please select from the following options:
1 - Run test pulse on model
2 - Fit model parameter to data
3 - Display static neuron model
4 - Visualize model dynamics
5 - Quit
'''
try:
selection=int(raw_input('Please choose an option above: '))
except ValueError:
print "Invalid selection."
continue
# test pulse example
if selection == 1:
# Run the model with a test pulse of the 'long square' type
print "Running model with a long square current injection pulse of 210pA"
output = currModel.long_square(0.21)
currModel.plot_output()
# fit parameter example
elif selection == 2:
if not currModel.bp.cache_stimulus:
print "Current model was not instantiated with NWB data cached. Please reload the current model and cache experimental stimulus data."
continue
print "Fitting somatic sodium conductance for model", modelID, "to experimental data in sweep 41."
print "Please be patient, this may take some time."
# Define which section and which parameter to fit.
# Here we'll fit the somatic sodium conductance.
currModel.set_fit_section('soma', 0)
currModel.set_parameter_to_fit('gbar_NaV')
# Running the model with an NWB pulse as stimulus takes a
# very long time because of the high sampling rate.
# As a computationally-cheaper approximation for stimuli of
# type Long Square pulse, we can rebuild the stimulus with the
# default (lower) sampling rate in h.IClamp
# currModel.run_nwb_pulse(41) # too slow
output = currModel.long_square(0.21)
# Set the experimental reference sweep and set up the variables for the objective function
currModel.set_reference_sweep(ref_index=41)
currModel.set_up_objective(measure='spike frequency')
# Use SciPy's minimize functions to fit the specified parameter
#results = minimize(currModel.objective_function, currModel.theta, method='Nelder-Mead', tol=1e-3)
#results = minimize(currModel.objective_function, currModel.theta, method='Powell', tol=1e-3)
#results = minimize(currModel.objective_function, currModel.theta, method='COBYLA', tol=1e-5)
currModel.gradient_descent(alpha=0.00005, epsilon=0.001, threshold=0.01, max_cycles=1000)
currModel.plot_fit()
output = currModel.long_square(0.21)
currModel.plot_output()
times = np.array(output['t'])/1000
spikes = detect_putative_spikes(np.array(output['v']), times, 0.1, 1.1)
avg_rate = currModel.average_rate_from_delays(times, spikes, 0.1, 1.1)
print "spike rate for theta of", currModel.theta, ":", avg_rate
# static visualization example
elif selection == 3:
run_visualization(currModel)
elif selection == 4:
run_visualization(currModel, show_simulation_dynamics = True)
elif selection == 5:
quit()
else:
print "Invalid selection."
continue
def run_visualization(currModel, show_simulation_dynamics = False):
print "Setting up visualization..."
morphology = currModel.get_reconstruction()
# Prepare model coordinates for uploading to OpenGL.
tempIndices = []
tempVertices = []
n_index = 0
tempX = []
tempY = []
tempZ = []
tempCol = []
if not show_simulation_dynamics:
print '''
Soma - Red
Axon - Green
Dendrites - Blue
Apical Dendrites - Purple'''
# array of colors to denote individual compartment types
compartmentColors=[[0.0,0.0,0.0,0.0], # padding for index convenience
[1.0, 0.0, 0.0, 1.0], #1: soma - red
[0.0, 1.0, 0.0, 1.0], #2: axon - green
[0.0, 0.0, 1.0, 1.0], #3: dendrites - blue
[1.0, 0.0, 1.0, 1.0]] #4: apical dendrites - purple
color_dim = 4
# used to set up section monitoring for visualization of dynamics
compartmentNames=['none', # padding for index convenience
'soma', #1: soma
'axon', #2: axon
'dend', #3: dendrites - blue
'dend'] #4: apical dendrites - purple
sectionIndices=[0,0,0,0,0]
segmentsPerSection = {}
sec_name = ''
# initialize storage arrays for each vertex.
index = 0
n_compartments = len(morphology.compartment_list)
tempX = [0] * n_compartments
tempY = [0] * n_compartments
tempZ = [0] * n_compartments
tempCol = [0] * n_compartments * color_dim
for n in morphology.compartment_list:
# add parent coords
tempX[n['id']] = n['x']
tempY[n['id']] = -n['y']
tempZ[n['id']] = n['z']
# add color data for parent
col_i = 0
offset = n['id']*color_dim
for cval in compartmentColors[n['type']]:
tempCol[offset+col_i] = cval
col_i += 1
# if at a branch point or an end of a section, set up a vector to monitor that segment's voltage
type = compartmentNames[n['type']]
sec_index = sectionIndices[n['type']]
if not (len(morphology.children_of(n)) == 1): #either branch pt or end
sec_name = type + '[' + str(sec_index) + ']'
sectionIndices[n['type']] += 1
currModel.monitor_section_voltage(type, sec_index)
segmentsPerSection[sec_name] = 1
else:
segmentsPerSection[sec_name] += 1
index += 1
for c in morphology.children_of(n):
# add child coods
tempX[c['id']] = c['x']
tempY[c['id']] = -c['y']
tempZ[c['id']] = c['z']
# add index data:
# draw from parent to child, for each child
tempIndices.append(n['id'])
tempIndices.append(c['id'])
index += 1
# add color data for child
col_i = 0
offset = c['id']*color_dim
for cval in compartmentColors[c['type']]:
tempCol[offset+col_i] = cval
col_i += 1
segmentsPerSection[sec_name] += 1
# get ranges for scaling
maxX = max(tempX)
maxY = max(tempY)
maxZ = max(tempZ)
minX = min(tempX)
minY = min(tempY)
minZ = min(tempZ)
xHalfRange = (maxX - minX)/2.0
yHalfRange = (maxY - minY)/2.0
zHalfRange = (maxZ - minZ)/2.0
longestDimLen = max(xHalfRange, yHalfRange, zHalfRange)
# center coords about 0,0,0, with range -1 to 1
tempX = [((((x-minX)*(2*xHalfRange))/(2*xHalfRange)) - xHalfRange)/longestDimLen for x in tempX]
tempY = [((((y-minY)*(2*yHalfRange))/(2*yHalfRange)) - yHalfRange)/longestDimLen for y in tempY]
tempZ = [((((z-minZ)*(2*zHalfRange))/(2*zHalfRange)) - zHalfRange)/longestDimLen for z in tempZ]
# convert everything to a numpy array so OpenGL can use it
indexData = np.array(tempIndices, dtype='uint16')
vertexData = np.array([tempX,tempY,tempZ | main | identifier_name |
|
demo.py | "Initialized biophysical model", modelID
print '''
Please select from the following options:
1 - Run test pulse on model
2 - Fit model parameter to data
3 - Display static neuron model
4 - Visualize model dynamics
5 - Quit
'''
try:
selection=int(raw_input('Please choose an option above: '))
except ValueError:
print "Invalid selection."
continue
# test pulse example
if selection == 1:
# Run the model with a test pulse of the 'long square' type
print "Running model with a long square current injection pulse of 210pA"
output = currModel.long_square(0.21)
currModel.plot_output()
# fit parameter example
elif selection == 2:
if not currModel.bp.cache_stimulus:
print "Current model was not instantiated with NWB data cached. Please reload the current model and cache experimental stimulus data."
continue
print "Fitting somatic sodium conductance for model", modelID, "to experimental data in sweep 41."
print "Please be patient, this may take some time."
# Define which section and which parameter to fit.
# Here we'll fit the somatic sodium conductance.
currModel.set_fit_section('soma', 0)
currModel.set_parameter_to_fit('gbar_NaV')
# Running the model with an NWB pulse as stimulus takes a
# very long time because of the high sampling rate.
# As a computationally-cheaper approximation for stimuli of
# type Long Square pulse, we can rebuild the stimulus with the
# default (lower) sampling rate in h.IClamp
# currModel.run_nwb_pulse(41) # too slow
output = currModel.long_square(0.21)
# Set the experimental reference sweep and set up the variables for the objective function
currModel.set_reference_sweep(ref_index=41)
currModel.set_up_objective(measure='spike frequency')
# Use SciPy's minimize functions to fit the specified parameter
#results = minimize(currModel.objective_function, currModel.theta, method='Nelder-Mead', tol=1e-3)
#results = minimize(currModel.objective_function, currModel.theta, method='Powell', tol=1e-3)
#results = minimize(currModel.objective_function, currModel.theta, method='COBYLA', tol=1e-5)
currModel.gradient_descent(alpha=0.00005, epsilon=0.001, threshold=0.01, max_cycles=1000)
currModel.plot_fit()
output = currModel.long_square(0.21)
currModel.plot_output()
times = np.array(output['t'])/1000
spikes = detect_putative_spikes(np.array(output['v']), times, 0.1, 1.1)
avg_rate = currModel.average_rate_from_delays(times, spikes, 0.1, 1.1)
print "spike rate for theta of", currModel.theta, ":", avg_rate
# static visualization example
elif selection == 3:
run_visualization(currModel)
elif selection == 4:
run_visualization(currModel, show_simulation_dynamics = True)
elif selection == 5:
quit()
else:
print "Invalid selection."
continue
def run_visualization(currModel, show_simulation_dynamics = False):
print "Setting up visualization..."
morphology = currModel.get_reconstruction()
# Prepare model coordinates for uploading to OpenGL.
tempIndices = []
tempVertices = []
n_index = 0
tempX = []
tempY = []
tempZ = []
tempCol = []
if not show_simulation_dynamics:
print '''
Soma - Red
Axon - Green
Dendrites - Blue
Apical Dendrites - Purple'''
# array of colors to denote individual compartment types
compartmentColors=[[0.0,0.0,0.0,0.0], # padding for index convenience
[1.0, 0.0, 0.0, 1.0], #1: soma - red
[0.0, 1.0, 0.0, 1.0], #2: axon - green
[0.0, 0.0, 1.0, 1.0], #3: dendrites - blue
[1.0, 0.0, 1.0, 1.0]] #4: apical dendrites - purple
color_dim = 4
# used to set up section monitoring for visualization of dynamics
compartmentNames=['none', # padding for index convenience
'soma', #1: soma
'axon', #2: axon
'dend', #3: dendrites - blue
'dend'] #4: apical dendrites - purple
sectionIndices=[0,0,0,0,0]
segmentsPerSection = {}
sec_name = ''
# initialize storage arrays for each vertex.
index = 0
n_compartments = len(morphology.compartment_list)
tempX = [0] * n_compartments
tempY = [0] * n_compartments
tempZ = [0] * n_compartments
tempCol = [0] * n_compartments * color_dim
for n in morphology.compartment_list:
# add parent coords
tempX[n['id']] = n['x']
tempY[n['id']] = -n['y']
tempZ[n['id']] = n['z']
# add color data for parent
col_i = 0
offset = n['id']*color_dim
for cval in compartmentColors[n['type']]:
|
# if at a branch point or an end of a section, set up a vector to monitor that segment's voltage
type = compartmentNames[n['type']]
sec_index = sectionIndices[n['type']]
if not (len(morphology.children_of(n)) == 1): #either branch pt or end
sec_name = type + '[' + str(sec_index) + ']'
sectionIndices[n['type']] += 1
currModel.monitor_section_voltage(type, sec_index)
segmentsPerSection[sec_name] = 1
else:
segmentsPerSection[sec_name] += 1
index += 1
for c in morphology.children_of(n):
# add child coods
tempX[c['id']] = c['x']
tempY[c['id']] = -c['y']
tempZ[c['id']] = c['z']
# add index data:
# draw from parent to child, for each child
tempIndices.append(n['id'])
tempIndices.append(c['id'])
index += 1
# add color data for child
col_i = 0
offset = c['id']*color_dim
for cval in compartmentColors[c['type']]:
tempCol[offset+col_i] = cval
col_i += 1
segmentsPerSection[sec_name] += 1
# get ranges for scaling
maxX = max(tempX)
maxY = max(tempY)
maxZ = max(tempZ)
minX = min(tempX)
minY = min(tempY)
minZ = min(tempZ)
xHalfRange = (maxX - minX)/2.0
yHalfRange = (maxY - minY)/2.0
zHalfRange = (maxZ - minZ)/2.0
longestDimLen = max(xHalfRange, yHalfRange, zHalfRange)
# center coords about 0,0,0, with range -1 to 1
tempX = [((((x-minX)*(2*xHalfRange))/(2*xHalfRange)) - xHalfRange)/longestDimLen for x in tempX]
tempY = [((((y-minY)*(2*yHalfRange))/(2*yHalfRange)) - yHalfRange)/longestDimLen for y in tempY]
tempZ = [((((z-minZ)*(2*zHalfRange))/(2*zHalfRange)) - zHalfRange)/longestDimLen for z in tempZ]
# convert everything to a numpy array so OpenGL can use it
indexData = np.array(tempIndices, dtype='uint16')
vertexData = np.array([tempX,tempY,tempZ], dtype='float32')
tempCol = np.array(tempCol, dtype='float32')
vertexData = np.append(vertexData.transpose().flatten(), tempCol)
#################### /Preparing Model Coords
# Set up the Visualization instance
n_vertices = len(tempX)
currVis = Visualization(data=vertexData, indices=indexData, nVert=n_vertices, colorDim=color_dim)
if show_simulation_dynamics:
currModel.run_test_pulse(amp=0.25, delay=20.0 | tempCol[offset+col_i] = cval
col_i += 1 | conditional_block |
fs.rs | x| Error::from_sys(x))
}
}
impl Drop for File {
fn drop(&mut self) {
let _ = close(self.fd);
}
}
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct FileType {
dir: bool,
file: bool,
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.dir
}
pub fn is_file(&self) -> bool {
self.file
}
pub fn is_symlink(&self) -> bool {
false
}
}
impl ::os::unix::fs::FileTypeExt for FileType {
fn is_block_device(&self) -> bool { false }
fn is_char_device(&self) -> bool { false }
fn is_fifo(&self) -> bool { false }
fn is_socket(&self) -> bool { false }
}
pub struct OpenOptions {
read: bool,
write: bool,
append: bool,
create: bool,
truncate: bool,
mode: u16,
}
impl OpenOptions {
pub fn new() -> OpenOptions {
OpenOptions {
read: false,
write: false,
append: false,
create: false,
truncate: false,
mode: 0,
}
}
pub fn read(&mut self, read: bool) -> &mut OpenOptions {
self.read = read;
self
}
pub fn write(&mut self, write: bool) -> &mut OpenOptions {
self.write = write;
self
}
pub fn append(&mut self, append: bool) -> &mut OpenOptions {
self.append = append;
self
}
pub fn create(&mut self, create: bool) -> &mut OpenOptions {
self.create = create;
self
}
pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
self.truncate = truncate;
self
}
pub fn open<P: AsRef<Path>>(&self, path: P) -> Result<File> {
let mut flags = 0;
if self.read && self.write {
flags |= O_RDWR;
} else if self.read {
flags |= O_RDONLY;
} else if self.write {
flags |= O_WRONLY;
}
if self.append {
flags |= O_APPEND;
}
if self.create {
flags |= O_CREAT;
}
if self.truncate {
flags |= O_TRUNC;
}
flags |= (self.mode & MODE_PERM) as usize;
let path_str = path.as_ref().as_os_str().as_inner();
open(path_str, flags).map(|fd| unsafe { File::from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
}
impl ::os::unix::fs::OpenOptionsExt for OpenOptions {
fn mode(&mut self, mode: u32) -> &mut Self {
self.mode = mode as u16;
self
}
}
pub struct Metadata {
stat: Stat
}
impl Metadata {
pub fn file_type(&self) -> FileType {
FileType {
dir: self.stat.st_mode & MODE_DIR == MODE_DIR,
file: self.stat.st_mode & MODE_FILE == MODE_FILE
}
}
pub fn is_dir(&self) -> bool {
self.stat.st_mode & MODE_DIR == MODE_DIR
}
pub fn is_file(&self) -> bool {
self.stat.st_mode & MODE_FILE == MODE_FILE
}
pub fn len(&self) -> u64 {
self.stat.st_size
}
pub fn permissions(&self) -> Permissions {
Permissions {
mode: self.stat.st_mode & MODE_PERM
}
}
}
impl ::os::unix::fs::MetadataExt for Metadata {
fn mode(&self) -> u32 {
self.stat.st_mode as u32
}
fn uid(&self) -> u32 {
self.stat.st_uid
}
fn gid(&self) -> u32 {
self.stat.st_gid
}
fn size(&self) -> u64 {
self.stat.st_size
}
}
pub struct Permissions {
mode: u16
}
impl Permissions {
pub fn readonly(&self) -> bool {
self.mode & 0o222 == 0
}
pub fn set_readonly(&mut self, readonly: bool) {
if readonly {
self.mode &= !0o222;
} else {
self.mode |= 0o222;
}
}
}
impl ::os::unix::fs::PermissionsExt for Permissions {
fn mode(&self) -> u32 {
self.mode as u32
}
fn set_mode(&mut self, mode: u32) {
self.mode = mode as u16;
}
fn from_mode(mode: u32) -> Self {
Permissions {
mode: mode as u16
}
}
}
pub struct DirEntry {
path: PathBuf,
}
impl DirEntry {
pub fn file_name(&self) -> &Path {
unsafe { mem::transmute(self.path.file_name().unwrap().to_str().unwrap()) }
}
pub fn file_type(&self) -> Result<FileType> {
self.metadata().map(|metadata| metadata.file_type())
}
pub fn metadata(&self) -> Result<Metadata> {
metadata(&self.path)
}
pub fn path(&self) -> PathBuf {
self.path.clone()
}
}
pub struct ReadDir {
path: PathBuf,
file: BufReader<File>,
}
impl Iterator for ReadDir {
type Item = Result<DirEntry>;
fn next(&mut self) -> Option<Result<DirEntry>> {
let mut name = String::new();
match self.file.read_line(&mut name) {
Ok(0) => None,
Ok(_) => {
if name.ends_with('\n') {
name.pop();
}
let mut path = self.path.clone();
path.push(name);
Some(Ok(DirEntry {
path: path
}))
},
Err(err) => Some(Err(err))
}
}
}
/// Find the canonical path of a file
pub fn canonicalize<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
match File::open(path) {
Ok(file) => {
match file.path() {
Ok(realpath) => Ok(realpath),
Err(err) => Err(err)
}
},
Err(err) => Err(err)
}
}
/// Get information about a file
pub fn metadata<P: AsRef<Path>>(path: P) -> Result<Metadata> {
try!(File::open(path)).metadata()
}
/// Get information about a file without following symlinks
/// Warning: Redox does not currently support symlinks
pub fn symlink_metadata<P: AsRef<Path>>(path: P) -> Result<Metadata> {
metadata(path)
}
/// Create a new directory, using a path
/// The default mode of the directory is 775
pub fn create_dir<P: AsRef<Path>>(path: P) -> Result<()> {
let path_str = path.as_ref().as_os_str().as_inner();
mkdir(path_str, 0o775).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Recursively create a directory and all of its parent components if they are missing.
pub fn create_dir_all<P: AsRef<Path>>(path: P) -> Result<()> {
if let Some(parent) = path.as_ref().parent() {
try!(create_dir_all(&parent));
}
if let Err(_err) = metadata(&path) {
try!(create_dir(&path));
}
Ok(())
}
/// Copy the contents of one file to another
pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<u64> {
let mut infile = try!(File::open(from));
let mut outfile = try!(File::create(to));
io::copy(&mut infile, &mut outfile)
}
/// Rename a file or directory to a new name
pub fn rename<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<()> {
try!(copy(Path::new(from.as_ref()), to));
remove_file(from)
}
/// Return an iterator over the entries within a directory
pub fn read_dir<P: AsRef<Path>>(path: P) -> Result<ReadDir> {
let path_buf = path.as_ref().to_owned();
File::open(&path_buf).map(|file| ReadDir { path: path_buf, file: BufReader::new(file) })
}
/// Removes an existing, empty directory
pub fn remove_dir<P: AsRef<Path>>(path: P) -> Result<()> {
let path_str = path.as_ref().as_os_str().as_inner();
rmdir(path_str).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Removes a directory at this path, after removing all its contents. Use carefully!
pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> Result<()> {
for child in try!(read_dir(&path)) {
let child = try!(child);
if try!(child.file_type()).is_dir() {
try!(remove_dir_all(&child.path()));
} else | {
try!(remove_file(&child.path()));
} | conditional_block |
|
fs.rs | from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
/// Duplicate the file
pub fn dup(&self, buf: &[u8]) -> Result<File> {
dup(self.fd, buf).map(|fd| unsafe { File::from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
/// Get information about a file
pub fn metadata(&self) -> Result<Metadata> {
let mut stat = Stat::default();
try!(fstat(self.fd, &mut stat).map_err(|x| Error::from_sys(x)));
Ok(Metadata {
stat: stat
})
}
/// Get the canonical path of the file
pub fn path(&self) -> Result<PathBuf> {
let mut buf: [u8; 4096] = [0; 4096];
match fpath(self.fd, &mut buf) {
Ok(count) => Ok(PathBuf::from(unsafe { String::from_utf8_unchecked(Vec::from(&buf[0..count])) })),
Err(err) => Err(Error::from_sys(err)),
}
}
/// Flush the file data and metadata
pub fn sync_all(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Flush the file data
pub fn sync_data(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Truncates the file
pub fn set_len(&self, size: u64) -> Result<()> {
ftruncate(self.fd, size as usize).and(Ok(())).map_err(|x| Error::from_sys(x))
}
}
impl AsRawFd for File {
fn as_raw_fd(&self) -> RawFd {
self.fd
}
}
impl FromRawFd for File {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
File {
fd: fd
}
}
}
impl IntoRawFd for File {
fn into_raw_fd(self) -> RawFd {
let fd = self.fd;
mem::forget(self);
fd
}
}
impl Read for File {
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
read(self.fd, buf).map_err(|x| Error::from_sys(x))
}
}
impl Write for File {
fn write(&mut self, buf: &[u8]) -> Result<usize> {
write(self.fd, buf).map_err(|x| Error::from_sys(x))
}
fn flush(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
}
impl Seek for File {
/// Seek a given position
fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
let (whence, offset) = match pos {
SeekFrom::Start(offset) => (SEEK_SET, offset as isize),
SeekFrom::Current(offset) => (SEEK_CUR, offset as isize),
SeekFrom::End(offset) => (SEEK_END, offset as isize),
};
lseek(self.fd, offset, whence).map(|position| position as u64).map_err(|x| Error::from_sys(x))
}
}
impl Drop for File {
fn drop(&mut self) {
let _ = close(self.fd);
}
}
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct FileType {
dir: bool,
file: bool,
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.dir
}
pub fn is_file(&self) -> bool {
self.file
}
pub fn is_symlink(&self) -> bool {
false
}
}
impl ::os::unix::fs::FileTypeExt for FileType {
fn is_block_device(&self) -> bool { false }
fn is_char_device(&self) -> bool { false }
fn is_fifo(&self) -> bool { false }
fn is_socket(&self) -> bool { false }
}
pub struct OpenOptions {
read: bool,
write: bool,
append: bool,
create: bool,
truncate: bool,
mode: u16,
}
impl OpenOptions {
pub fn new() -> OpenOptions {
OpenOptions {
read: false,
write: false,
append: false,
create: false,
truncate: false,
mode: 0,
}
}
pub fn read(&mut self, read: bool) -> &mut OpenOptions {
self.read = read;
self
}
pub fn write(&mut self, write: bool) -> &mut OpenOptions {
self.write = write;
self
}
pub fn append(&mut self, append: bool) -> &mut OpenOptions {
self.append = append;
self
}
pub fn create(&mut self, create: bool) -> &mut OpenOptions {
self.create = create;
self
}
pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
self.truncate = truncate;
self
}
pub fn open<P: AsRef<Path>>(&self, path: P) -> Result<File> {
let mut flags = 0;
if self.read && self.write {
flags |= O_RDWR;
} else if self.read {
flags |= O_RDONLY;
} else if self.write {
flags |= O_WRONLY;
}
if self.append {
flags |= O_APPEND;
}
if self.create {
flags |= O_CREAT;
}
if self.truncate {
flags |= O_TRUNC;
}
flags |= (self.mode & MODE_PERM) as usize;
let path_str = path.as_ref().as_os_str().as_inner();
open(path_str, flags).map(|fd| unsafe { File::from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
}
impl ::os::unix::fs::OpenOptionsExt for OpenOptions {
fn mode(&mut self, mode: u32) -> &mut Self {
self.mode = mode as u16;
self
}
}
pub struct Metadata {
stat: Stat
}
impl Metadata {
pub fn file_type(&self) -> FileType {
FileType {
dir: self.stat.st_mode & MODE_DIR == MODE_DIR,
file: self.stat.st_mode & MODE_FILE == MODE_FILE
}
}
pub fn is_dir(&self) -> bool {
self.stat.st_mode & MODE_DIR == MODE_DIR
}
pub fn is_file(&self) -> bool {
self.stat.st_mode & MODE_FILE == MODE_FILE
}
pub fn len(&self) -> u64 {
self.stat.st_size
}
pub fn permissions(&self) -> Permissions {
Permissions {
mode: self.stat.st_mode & MODE_PERM
}
}
}
impl ::os::unix::fs::MetadataExt for Metadata {
fn mode(&self) -> u32 {
self.stat.st_mode as u32
}
fn uid(&self) -> u32 {
self.stat.st_uid
}
fn gid(&self) -> u32 {
self.stat.st_gid
}
fn size(&self) -> u64 {
self.stat.st_size
}
}
pub struct Permissions {
mode: u16
}
impl Permissions {
pub fn readonly(&self) -> bool {
self.mode & 0o222 == 0
}
pub fn set_readonly(&mut self, readonly: bool) {
if readonly {
self.mode &= !0o222;
} else {
self.mode |= 0o222;
}
}
}
impl ::os::unix::fs::PermissionsExt for Permissions {
fn mode(&self) -> u32 {
self.mode as u32
}
fn set_mode(&mut self, mode: u32) { | self.mode = mode as u16;
}
fn from_mode(mode: u32) -> Self {
Permissions {
mode: mode as u16
}
}
}
pub struct DirEntry {
path: PathBuf,
}
impl DirEntry {
pub fn file_name(&self) -> &Path {
unsafe { mem::transmute(self.path.file_name().unwrap().to_str().unwrap()) }
}
pub fn file_type(&self) -> Result<FileType> {
self.metadata().map(|metadata| metadata.file_type())
}
pub fn metadata(&self) -> Result<Metadata> {
metadata(&self.path)
}
pub fn path(&self) -> PathBuf {
self.path.clone()
}
}
pub struct ReadDir {
path: PathBuf,
file: BufReader<File>,
}
impl Iterator for ReadDir {
type Item = Result<DirEntry>;
fn next(&mut self) -> Option<Result<DirEntry>> {
let mut name = String::new();
match self.file.read_line(&mut name) {
Ok(0) => None,
Ok(_) => {
if name.ends_with('\n') {
name.pop();
}
let mut path = self.path.clone();
path.push(name);
Some(Ok(D | random_line_split |
|
fs.rs | from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
/// Duplicate the file
pub fn dup(&self, buf: &[u8]) -> Result<File> {
dup(self.fd, buf).map(|fd| unsafe { File::from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
/// Get information about a file
pub fn metadata(&self) -> Result<Metadata> {
let mut stat = Stat::default();
try!(fstat(self.fd, &mut stat).map_err(|x| Error::from_sys(x)));
Ok(Metadata {
stat: stat
})
}
/// Get the canonical path of the file
pub fn path(&self) -> Result<PathBuf> {
let mut buf: [u8; 4096] = [0; 4096];
match fpath(self.fd, &mut buf) {
Ok(count) => Ok(PathBuf::from(unsafe { String::from_utf8_unchecked(Vec::from(&buf[0..count])) })),
Err(err) => Err(Error::from_sys(err)),
}
}
/// Flush the file data and metadata
pub fn sync_all(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Flush the file data
pub fn sync_data(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Truncates the file
pub fn set_len(&self, size: u64) -> Result<()> {
ftruncate(self.fd, size as usize).and(Ok(())).map_err(|x| Error::from_sys(x))
}
}
impl AsRawFd for File {
fn as_raw_fd(&self) -> RawFd |
}
impl FromRawFd for File {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
File {
fd: fd
}
}
}
impl IntoRawFd for File {
fn into_raw_fd(self) -> RawFd {
let fd = self.fd;
mem::forget(self);
fd
}
}
impl Read for File {
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
read(self.fd, buf).map_err(|x| Error::from_sys(x))
}
}
impl Write for File {
fn write(&mut self, buf: &[u8]) -> Result<usize> {
write(self.fd, buf).map_err(|x| Error::from_sys(x))
}
fn flush(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
}
impl Seek for File {
/// Seek a given position
fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
let (whence, offset) = match pos {
SeekFrom::Start(offset) => (SEEK_SET, offset as isize),
SeekFrom::Current(offset) => (SEEK_CUR, offset as isize),
SeekFrom::End(offset) => (SEEK_END, offset as isize),
};
lseek(self.fd, offset, whence).map(|position| position as u64).map_err(|x| Error::from_sys(x))
}
}
impl Drop for File {
fn drop(&mut self) {
let _ = close(self.fd);
}
}
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct FileType {
dir: bool,
file: bool,
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.dir
}
pub fn is_file(&self) -> bool {
self.file
}
pub fn is_symlink(&self) -> bool {
false
}
}
impl ::os::unix::fs::FileTypeExt for FileType {
fn is_block_device(&self) -> bool { false }
fn is_char_device(&self) -> bool { false }
fn is_fifo(&self) -> bool { false }
fn is_socket(&self) -> bool { false }
}
pub struct OpenOptions {
read: bool,
write: bool,
append: bool,
create: bool,
truncate: bool,
mode: u16,
}
impl OpenOptions {
pub fn new() -> OpenOptions {
OpenOptions {
read: false,
write: false,
append: false,
create: false,
truncate: false,
mode: 0,
}
}
pub fn read(&mut self, read: bool) -> &mut OpenOptions {
self.read = read;
self
}
pub fn write(&mut self, write: bool) -> &mut OpenOptions {
self.write = write;
self
}
pub fn append(&mut self, append: bool) -> &mut OpenOptions {
self.append = append;
self
}
pub fn create(&mut self, create: bool) -> &mut OpenOptions {
self.create = create;
self
}
pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
self.truncate = truncate;
self
}
pub fn open<P: AsRef<Path>>(&self, path: P) -> Result<File> {
let mut flags = 0;
if self.read && self.write {
flags |= O_RDWR;
} else if self.read {
flags |= O_RDONLY;
} else if self.write {
flags |= O_WRONLY;
}
if self.append {
flags |= O_APPEND;
}
if self.create {
flags |= O_CREAT;
}
if self.truncate {
flags |= O_TRUNC;
}
flags |= (self.mode & MODE_PERM) as usize;
let path_str = path.as_ref().as_os_str().as_inner();
open(path_str, flags).map(|fd| unsafe { File::from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
}
impl ::os::unix::fs::OpenOptionsExt for OpenOptions {
fn mode(&mut self, mode: u32) -> &mut Self {
self.mode = mode as u16;
self
}
}
pub struct Metadata {
stat: Stat
}
impl Metadata {
pub fn file_type(&self) -> FileType {
FileType {
dir: self.stat.st_mode & MODE_DIR == MODE_DIR,
file: self.stat.st_mode & MODE_FILE == MODE_FILE
}
}
pub fn is_dir(&self) -> bool {
self.stat.st_mode & MODE_DIR == MODE_DIR
}
pub fn is_file(&self) -> bool {
self.stat.st_mode & MODE_FILE == MODE_FILE
}
pub fn len(&self) -> u64 {
self.stat.st_size
}
pub fn permissions(&self) -> Permissions {
Permissions {
mode: self.stat.st_mode & MODE_PERM
}
}
}
impl ::os::unix::fs::MetadataExt for Metadata {
fn mode(&self) -> u32 {
self.stat.st_mode as u32
}
fn uid(&self) -> u32 {
self.stat.st_uid
}
fn gid(&self) -> u32 {
self.stat.st_gid
}
fn size(&self) -> u64 {
self.stat.st_size
}
}
pub struct Permissions {
mode: u16
}
impl Permissions {
pub fn readonly(&self) -> bool {
self.mode & 0o222 == 0
}
pub fn set_readonly(&mut self, readonly: bool) {
if readonly {
self.mode &= !0o222;
} else {
self.mode |= 0o222;
}
}
}
impl ::os::unix::fs::PermissionsExt for Permissions {
fn mode(&self) -> u32 {
self.mode as u32
}
fn set_mode(&mut self, mode: u32) {
self.mode = mode as u16;
}
fn from_mode(mode: u32) -> Self {
Permissions {
mode: mode as u16
}
}
}
pub struct DirEntry {
path: PathBuf,
}
impl DirEntry {
pub fn file_name(&self) -> &Path {
unsafe { mem::transmute(self.path.file_name().unwrap().to_str().unwrap()) }
}
pub fn file_type(&self) -> Result<FileType> {
self.metadata().map(|metadata| metadata.file_type())
}
pub fn metadata(&self) -> Result<Metadata> {
metadata(&self.path)
}
pub fn path(&self) -> PathBuf {
self.path.clone()
}
}
pub struct ReadDir {
path: PathBuf,
file: BufReader<File>,
}
impl Iterator for ReadDir {
type Item = Result<DirEntry>;
fn next(&mut self) -> Option<Result<DirEntry>> {
let mut name = String::new();
match self.file.read_line(&mut name) {
Ok(0) => None,
Ok(_) => {
if name.ends_with('\n') {
name.pop();
}
let mut path = self.path.clone();
path.push(name);
Some( | {
self.fd
} | identifier_body |
fs.rs | pub fn sync_data(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Truncates the file
pub fn set_len(&self, size: u64) -> Result<()> {
ftruncate(self.fd, size as usize).and(Ok(())).map_err(|x| Error::from_sys(x))
}
}
impl AsRawFd for File {
fn as_raw_fd(&self) -> RawFd {
self.fd
}
}
impl FromRawFd for File {
unsafe fn from_raw_fd(fd: RawFd) -> Self {
File {
fd: fd
}
}
}
impl IntoRawFd for File {
fn into_raw_fd(self) -> RawFd {
let fd = self.fd;
mem::forget(self);
fd
}
}
impl Read for File {
fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
read(self.fd, buf).map_err(|x| Error::from_sys(x))
}
}
impl Write for File {
fn write(&mut self, buf: &[u8]) -> Result<usize> {
write(self.fd, buf).map_err(|x| Error::from_sys(x))
}
fn flush(&mut self) -> Result<()> {
fsync(self.fd).and(Ok(())).map_err(|x| Error::from_sys(x))
}
}
impl Seek for File {
/// Seek a given position
fn seek(&mut self, pos: SeekFrom) -> Result<u64> {
let (whence, offset) = match pos {
SeekFrom::Start(offset) => (SEEK_SET, offset as isize),
SeekFrom::Current(offset) => (SEEK_CUR, offset as isize),
SeekFrom::End(offset) => (SEEK_END, offset as isize),
};
lseek(self.fd, offset, whence).map(|position| position as u64).map_err(|x| Error::from_sys(x))
}
}
impl Drop for File {
fn drop(&mut self) {
let _ = close(self.fd);
}
}
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct FileType {
dir: bool,
file: bool,
}
impl FileType {
pub fn is_dir(&self) -> bool {
self.dir
}
pub fn is_file(&self) -> bool {
self.file
}
pub fn is_symlink(&self) -> bool {
false
}
}
impl ::os::unix::fs::FileTypeExt for FileType {
fn is_block_device(&self) -> bool { false }
fn is_char_device(&self) -> bool { false }
fn is_fifo(&self) -> bool { false }
fn is_socket(&self) -> bool { false }
}
pub struct OpenOptions {
read: bool,
write: bool,
append: bool,
create: bool,
truncate: bool,
mode: u16,
}
impl OpenOptions {
pub fn new() -> OpenOptions {
OpenOptions {
read: false,
write: false,
append: false,
create: false,
truncate: false,
mode: 0,
}
}
pub fn read(&mut self, read: bool) -> &mut OpenOptions {
self.read = read;
self
}
pub fn write(&mut self, write: bool) -> &mut OpenOptions {
self.write = write;
self
}
pub fn append(&mut self, append: bool) -> &mut OpenOptions {
self.append = append;
self
}
pub fn create(&mut self, create: bool) -> &mut OpenOptions {
self.create = create;
self
}
pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {
self.truncate = truncate;
self
}
pub fn open<P: AsRef<Path>>(&self, path: P) -> Result<File> {
let mut flags = 0;
if self.read && self.write {
flags |= O_RDWR;
} else if self.read {
flags |= O_RDONLY;
} else if self.write {
flags |= O_WRONLY;
}
if self.append {
flags |= O_APPEND;
}
if self.create {
flags |= O_CREAT;
}
if self.truncate {
flags |= O_TRUNC;
}
flags |= (self.mode & MODE_PERM) as usize;
let path_str = path.as_ref().as_os_str().as_inner();
open(path_str, flags).map(|fd| unsafe { File::from_raw_fd(fd) }).map_err(|x| Error::from_sys(x))
}
}
impl ::os::unix::fs::OpenOptionsExt for OpenOptions {
fn mode(&mut self, mode: u32) -> &mut Self {
self.mode = mode as u16;
self
}
}
pub struct Metadata {
stat: Stat
}
impl Metadata {
pub fn file_type(&self) -> FileType {
FileType {
dir: self.stat.st_mode & MODE_DIR == MODE_DIR,
file: self.stat.st_mode & MODE_FILE == MODE_FILE
}
}
pub fn is_dir(&self) -> bool {
self.stat.st_mode & MODE_DIR == MODE_DIR
}
pub fn is_file(&self) -> bool {
self.stat.st_mode & MODE_FILE == MODE_FILE
}
pub fn len(&self) -> u64 {
self.stat.st_size
}
pub fn permissions(&self) -> Permissions {
Permissions {
mode: self.stat.st_mode & MODE_PERM
}
}
}
impl ::os::unix::fs::MetadataExt for Metadata {
fn mode(&self) -> u32 {
self.stat.st_mode as u32
}
fn uid(&self) -> u32 {
self.stat.st_uid
}
fn gid(&self) -> u32 {
self.stat.st_gid
}
fn size(&self) -> u64 {
self.stat.st_size
}
}
pub struct Permissions {
mode: u16
}
impl Permissions {
pub fn readonly(&self) -> bool {
self.mode & 0o222 == 0
}
pub fn set_readonly(&mut self, readonly: bool) {
if readonly {
self.mode &= !0o222;
} else {
self.mode |= 0o222;
}
}
}
impl ::os::unix::fs::PermissionsExt for Permissions {
fn mode(&self) -> u32 {
self.mode as u32
}
fn set_mode(&mut self, mode: u32) {
self.mode = mode as u16;
}
fn from_mode(mode: u32) -> Self {
Permissions {
mode: mode as u16
}
}
}
pub struct DirEntry {
path: PathBuf,
}
impl DirEntry {
pub fn file_name(&self) -> &Path {
unsafe { mem::transmute(self.path.file_name().unwrap().to_str().unwrap()) }
}
pub fn file_type(&self) -> Result<FileType> {
self.metadata().map(|metadata| metadata.file_type())
}
pub fn metadata(&self) -> Result<Metadata> {
metadata(&self.path)
}
pub fn path(&self) -> PathBuf {
self.path.clone()
}
}
pub struct ReadDir {
path: PathBuf,
file: BufReader<File>,
}
impl Iterator for ReadDir {
type Item = Result<DirEntry>;
fn next(&mut self) -> Option<Result<DirEntry>> {
let mut name = String::new();
match self.file.read_line(&mut name) {
Ok(0) => None,
Ok(_) => {
if name.ends_with('\n') {
name.pop();
}
let mut path = self.path.clone();
path.push(name);
Some(Ok(DirEntry {
path: path
}))
},
Err(err) => Some(Err(err))
}
}
}
/// Find the canonical path of a file
pub fn canonicalize<P: AsRef<Path>>(path: P) -> Result<PathBuf> {
match File::open(path) {
Ok(file) => {
match file.path() {
Ok(realpath) => Ok(realpath),
Err(err) => Err(err)
}
},
Err(err) => Err(err)
}
}
/// Get information about a file
pub fn metadata<P: AsRef<Path>>(path: P) -> Result<Metadata> {
try!(File::open(path)).metadata()
}
/// Get information about a file without following symlinks
/// Warning: Redox does not currently support symlinks
pub fn symlink_metadata<P: AsRef<Path>>(path: P) -> Result<Metadata> {
metadata(path)
}
/// Create a new directory, using a path
/// The default mode of the directory is 775
pub fn create_dir<P: AsRef<Path>>(path: P) -> Result<()> {
let path_str = path.as_ref().as_os_str().as_inner();
mkdir(path_str, 0o775).and(Ok(())).map_err(|x| Error::from_sys(x))
}
/// Recursively create a directory and all of its parent components if they are missing.
pub fn | create_dir_all | identifier_name |
|
dnp3.go | File
case 27: // Delete File
case 28: // Get File Info
case 29: // Authenticate File
case 30: // Abort File
case 31: // Activate Config
case 32: // Authentication Request
case 33: // Authentication Error
case 129: // Response
case 130: // Unsolicited Response
case 131: // Authentication Response
}
objTypeField := binary.BigEndian.Uint16([]byte{data[objectStart], data[objectStart+1]})
objectGroup := objTypeField & 0xFF00
objectVariation := objTypeField & 0x00FF
object := d.hexConvert([]byte{data[objectStart], data[objectStart+1]})
objectPrefixCode := data[objectStart+2] & 0x70 // OPC
objectRangeSpecifierCode := data[objectStart+2] & 0x0F // RSC
fmt.Println(object)
fmt.Println(objectGroup)
fmt.Println(objectVariation)
fmt.Printf("Prefix Code %d\n", objectPrefixCode)
fmt.Println(ObjPrefixCodes[objectPrefixCode])
fmt.Printf("Range Specifier Code %d\n", objectRangeSpecifierCode) // 6 means no range field
fmt.Println(ObjRangeSpecifierCodes[objectRangeSpecifierCode])
fmt.Println(d.hexConvert([]byte{data[objectStart+3]}))
offset := objectStart + 3
rangebytes := 0
fmt.Println(offset)
switch objectRangeSpecifierCode {
case 0:
// start := offset
numItems := int(data[offset+1]) - int(data[offset]) + 1
rangebytes = 2
fmt.Println(numItems)
pointAddress := int(data[offset])
fmt.Println(pointAddress)
// num_items = ( tvb_get_guint8(tvb, offset+1) - tvb_get_guint8(tvb, offset) + 1);
// proto_item_set_generated(range_item);
// al_ptaddr = tvb_get_guint8(tvb, offset);
// proto_tree_add_item(range_tree, hf_dnp3_al_range_start8, tvb, offset, 1, ENC_LITTLE_ENDIAN);
// proto_tree_add_item(range_tree, hf_dnp3_al_range_stop8, tvb, offset + 1, 1, ENC_LITTLE_ENDIAN);
// rangebytes = 2;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
}
/* Move offset past any range field */
offset += rangebytes
fmt.Println(offset)
// RSCArrayFirst := []byte{0, 1, 2, 3, 4, 5}
// if d.contains(RSCArrayFirst, objectRangeSpecifierCode) {
// }
/* Special handling for Octet string objects as the variation is the length of the string */
// temp = objTypeField & 0xFF00
// if (temp == AL_OBJ_OCT) || (temp == AL_OBJ_OCT_EVT) {
// al_oct_len = al_obj & 0xFF
// al_obj = temp
// }
// objectGroup := data[objectStart] & 0x0f
// objectGroup := fmt.Sprintf("0x%x%x", data[objectStart], data[objectStart+1])
// fmt.Println(objectGroup)
// objectGroup, _ := strconv.Atoi(fmt.Sprintf("%d", data[objectStart]))
// objectVariation, _ := strconv.Atoi(fmt.Sprintf("%d", data[objectStart+1]))
// fmt.Println(objectGroup)
// fmt.Println(objectVariation)
/* Index Size (3-bits x111xxxx) */
// /* When Qualifier Code != 11 */
// #define AL_OBJQL_PREFIX_NI 0x00 /* Objects are Packed with no index */
// #define AL_OBJQL_PREFIX_1O 0x01 /* Objects are prefixed w/ 1-octet index */
// #define AL_OBJQL_PREFIX_2O 0x02 /* Objects are prefixed w/ 2-octet index */
// #define AL_OBJQL_PREFIX_4O 0x03 /* Objects are prefixed w/ 4-octet index */
// #define AL_OBJQL_PREFIX_1OS 0x04 /* Objects are prefixed w/ 1-octet object size */
// #define AL_OBJQL_PREFIX_2OS 0x05 /* Objects are prefixed w/ 2-octet object size */
// #define AL_OBJQL_PREFIX_4OS 0x06 /* Objects are prefixed w/ 4-octet object size */
// /* When Qualifier Code == 11 */
// #define AL_OBJQL_IDX11_1OIS 0x01 /* 1 octet identifier size */
// #define AL_OBJQL_IDX11_2OIS 0x02 /* 2 octet identifier size */
// #define AL_OBJQL_IDX11_4OIS 0x03 /* 4 octet identifier size */
// /* Qualifier Code (4-bits) */
// /* 4-bits ( xxxx1111 ) */
// #define AL_OBJQL_RANGE_SSI8 0x00 /* 00 8-bit Start and Stop Indices in Range Field */
// #define AL_OBJQL_RANGE_SSI16 0x01 /* 01 16-bit Start and Stop Indices in Range Field */
// #define AL_OBJQL_RANGE_SSI32 0x02 /* 02 32-bit Start and Stop Indices in Range Field */
// #define AL_OBJQL_RANGE_AA8 0x03 /* 03 8-bit Absolute Address in Range Field */
// #define AL_OBJQL_RANGE_AA16 0x04 /* 04 16-bit Absolute Address in Range Field */
// #define AL_OBJQL_RANGE_AA32 0x05 /* 05 32-bit Absolute Address in Range Field */
// #define AL_OBJQL_RANGE_R0 0x06 /* 06 Length of Range field is 0 (no range field) */
// #define AL_OBJQL_RANGE_SF8 0x07 /* 07 8-bit Single Field Quantity */
// #define AL_OBJQL_RANGE_SF16 0x08 /* 08 16-bit Single Field Quantity */
// #define AL_OBJQL_RANGE_SF32 0x09 /* 09 32-bit Single Field Quantity */
// /* 0x0A 10 Reserved */
// #define AL_OBJQL_RANGE_FF 0x0B /* 11 Free-format Qualifier, range field has 1 octet count of objects */
// /* 0x0C 12 Reserved */
// /* 0x0D 13 Reserved */
// /* 0x0E 14 Reserved */
// /* 0x0F 15 Reserved */
/***************************************************************************/
/* Application Layer Data Object Qualifier */
/***************************************************************************/
// /* Bit-Masks */
// #define AL_OBJQ_PREFIX 0x70 /* x111xxxx Masks Prefix from Qualifier */
// #define AL_OBJQ_RANGE 0x0F /* xxxx1111 Masks Range from Qualifier */
// objectQualifier := fmt.Sprintf("0x%d", data[objectStart+2])
// fmt.Println(objectQualifier)
// src = []byte{data[objectStart], data[objectStart+1]}
// dst = make([]byte, hex.EncodedLen(len(src)))
// hex.Encode(dst, src)
// prefixCode := fmt.Sprintf("0x%s", dst)
// fmt.Println(prefixCode)
}
func (d *DNP3) IsDNP3(bytesRead []byte) bool {
if len(bytesRead) >= MIN_HEADER_LENGTH && binary.BigEndian.Uint16(bytesRead[0:2]) == START_FIELD {
return true
}
return false
}
func (d *DNP3) isMaster(bytesRead []byte) bool {
intValue := int((bytesRead[3] & 0x80) >> 7)
var boolValue bool = intValue != 0
return boolValue
}
func (d *DNP3) hexConvert(byteArray []byte) string {
return "0x" + hex.EncodeToString(byteArray)
}
func (d *DNP3) isMultiPart(bytesRead []byte) bool {
var FirstOfMulti01 byte = 0x40
var NotFirstNotLast00 byte = 0x00 | var FinalFrame10 byte = 0x80
var OneFrame11 byte = 0xC0
TpFinFir := bytesRead[10] & 0xC0
switch TpFinFir { | random_line_split |
|
dnp3.go | 3: "Objects prefixed with 4-octet index",
4: "Objects prefixed with 1-octet object size",
5: "Objects prefixed with 2-octet object size",
6: "Objects prefixed with 4-octet object size",
7: "Reserved",
}
/***************************************************************************/
/* Application Layer Object Prefix codes bits */
/***************************************************************************/
var ObjRangeSpecifierCodes = map[byte]string{
0: "8-bit Start and Stop Indices in Range Field",
1: "16-bit Start and Stop Indices in Range Field",
2: "32-bit Start and Stop Indices in Range Field",
3: "8-bit Absolute Address in Range Field",
4: "16-bit Absolute Address in Range Field",
5: "32-bit Absolute Address in Range Field",
6: "Length of Range field is 0 (no range field)",
7: "8-bit Single Field Quantity",
8: "16-bit Single Field Quantity",
9: "32-bit Single Field Quantity",
10: "Reserved",
11: "Free-format Qualifier, range field has 1 octet count of objects",
12: "Reserved",
13: "Reserved",
14: "Reserved",
15: "Reserved",
}
var (
errDNP3PacketTooShort = errors.New("DNS packet too short")
)
type DNP3 struct {
BaseLayer // Stores the packet bytes and payload bytes.
DNP3DataLinkLayer DNP3DataLinkLayer
DNP3TransportLayer DNP3TransportLayer
DNP3ApplicationLayer DNP3ApplicationLayer
SomeByte byte
AnotherByte byte
restOfData []byte
}
type DNP3DataLinkLayer struct {
Start string
Length int
Control struct {
ControlByte string
IsMaster int `json:"Is Master"`
PRM int `json:"Primary"`
FCB int `json:"Frame Count Bit"`
FCV int `json:"Frame Count Valid"`
FUNC string `json:"Function Code"`
}
Destination int
Source int
CRC string
}
type DNP3TransportLayer struct {
TransportByte string
Final int
First int
Sequence int
}
type DNP3ApplicationLayer struct {
Control struct {
ControlByte string
First int
Final int
Confirm int
Unsolicited int
Sequence int
}
Function string `json:"Function Code"`
IINCode string `json:"Internal Indication (IIN)"`
}
type DNP3AppObject struct {
Group int
Variation int
Qualifier int
RangeStart int
RangeStop int
DataType int
Length int
}
func (d *DNP3) LayerType() gopacket.LayerType { return LayerTypeDNP3 }
func (d *DNP3) LayerContents() []byte {
return []byte{d.SomeByte, d.AnotherByte}
}
func (d *DNP3) LayerPayload() []byte {
return d.restOfData
}
func (d *DNP3) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
// If the data block is too short to be a DNP3 layer, then return an error.
if len(data) < 10 {
df.SetTruncated()
return errDNP3PacketTooShort
}
d.linkLayer(data)
d.transportLayer(data)
d.applicationLayer(data)
return nil
}
func decodeDNP3(data []byte, p gopacket.PacketBuilder) error {
// Attempt to decode the byte slice.
d := &DNP3{}
err := d.DecodeFromBytes(data, p)
if err != nil {
return err
}
// If the decoding worked, add the layer to the packet and set it
// as the application layer too, if there isn't already one.
p.AddLayer(d)
p.SetApplicationLayer(d)
d.BaseLayer = BaseLayer{Contents: data[:len(data)]}
d.BaseLayer.Payload = nil
return p.NextDecoder(gopacket.LayerTypePayload)
}
// CanDecode implements gopacket.DecodingLayer.
func (d *DNP3) CanDecode() gopacket.LayerClass {
return LayerTypeDNP3
}
// NextLayerType returns the layer type contained by this DecodingLayer.
func (d *DNP3) | () gopacket.LayerType {
return gopacket.LayerTypePayload
}
// Payload returns nil, since TLS encrypted payload is inside TLSAppDataRecord
func (d *DNP3) Payload() []byte {
return nil
}
func appObject(bytesRead []byte) {
object := bytesRead[22:]
// indexSize := uint(object[2] & 0x70 >> 4)
// QualifierCode := uint(object[2] & 0x0F)
// fmt.Println(indexSize)
// fmt.Println(QualifierCode)
group := int(object[0])
variation := int(object[1])
qualifier := int(object[2])
rangeStart := int(object[3])
rangeStop := int(object[4])
dataType := int(object[5])
length := int(object[6])
appObject := DNP3AppObject{
Group: group,
Variation: variation,
Qualifier: qualifier,
RangeStart: rangeStart,
RangeStop: rangeStop,
DataType: dataType,
Length: length,
}
out, err := json.Marshal(appObject)
if err != nil {
panic(err)
}
fmt.Println(string(out))
}
func (d *DNP3) linkLayer(data []byte) {
start := d.hexConvert(data[0:2])
d.DNP3DataLinkLayer.Start = start
length := int(data[2])
d.DNP3DataLinkLayer.Length = length
ctlControl := d.hexConvert([]byte{data[3]})
d.DNP3DataLinkLayer.Control.ControlByte = ctlControl
IsMaster := int((data[3] & 0x80) >> 7)
d.DNP3DataLinkLayer.Control.IsMaster = IsMaster
PRM := int((data[3] & 0x40) >> 6)
d.DNP3DataLinkLayer.Control.PRM = PRM
FCB := int((data[3] & 0x20) >> 5)
d.DNP3DataLinkLayer.Control.FCB = FCB
FCV := int((data[3] & 0x10) >> 4)
d.DNP3DataLinkLayer.Control.FCV = FCV
FUNCCODE := data[3] & 0x0F
ctlFUNCCODE := fmt.Sprintf("%d", FUNCCODE)
var ctlFUNC string
if PRM == 0x00 {
ctlFUNC = SfCodes[FUNCCODE]
}
if PRM == 0x01 {
ctlFUNC = PfCodes[FUNCCODE]
}
ctlFUNC = ctlFUNC + " (" + ctlFUNCCODE + ")"
d.DNP3DataLinkLayer.Control.FUNC = ctlFUNC
// TODO: make sure 0 to 65535
destination := fmt.Sprintf("%x%x", data[5], data[4])
destinationInt, _ := strconv.Atoi(destination)
d.DNP3DataLinkLayer.Destination = destinationInt
// TODO: make sure 0 to 65535
source := fmt.Sprintf("%x%x", data[7], data[6])
sourceInt, _ := strconv.Atoi(source)
d.DNP3DataLinkLayer.Source = sourceInt
// TODO: Is correct? Hesapla
crc := fmt.Sprintf("0x%x%x", data[9], data[8])
d.DNP3DataLinkLayer.CRC = crc
}
func (d *DNP3) transportLayer(data []byte) {
transport := fmt.Sprintf("0x%x", data[10])
d.DNP3TransportLayer.TransportByte = transport
final := data[10] & 0x80 >> 7
d.DNP3TransportLayer.Final = int(final)
first := data[10] & 0x40 >> 6
d.DNP3TransportLayer.First = int(first)
sequence := data[10] & 0x3f // 6bit
d.DNP3TransportLayer.Sequence = int(sequence)
}
func (d *DNP3) applicationLayer(data []byte) {
// /***************************************************************************/
// /* Application Layer Bit-Masks */
// /***************************************************************************/
// #define DNP3_AL_UNS 0x10
// #define DNP3_AL_CON 0x20
// #define DNP3_AL_FIN 0x40
// #define DNP3_AL_FIR 0x80
// #define DNP3_AL_SEQ 0x0f
// #define DNP3_AL_FUNC 0xff
controlByte := fmt.Sprintf("0x%x", data[11])
d.DNP3ApplicationLayer.Control.ControlByte = controlByte
| NextLayerType | identifier_name |
dnp3.go | 3: "Objects prefixed with 4-octet index",
4: "Objects prefixed with 1-octet object size",
5: "Objects prefixed with 2-octet object size",
6: "Objects prefixed with 4-octet object size",
7: "Reserved",
}
/***************************************************************************/
/* Application Layer Object Prefix codes bits */
/***************************************************************************/
var ObjRangeSpecifierCodes = map[byte]string{
0: "8-bit Start and Stop Indices in Range Field",
1: "16-bit Start and Stop Indices in Range Field",
2: "32-bit Start and Stop Indices in Range Field",
3: "8-bit Absolute Address in Range Field",
4: "16-bit Absolute Address in Range Field",
5: "32-bit Absolute Address in Range Field",
6: "Length of Range field is 0 (no range field)",
7: "8-bit Single Field Quantity",
8: "16-bit Single Field Quantity",
9: "32-bit Single Field Quantity",
10: "Reserved",
11: "Free-format Qualifier, range field has 1 octet count of objects",
12: "Reserved",
13: "Reserved",
14: "Reserved",
15: "Reserved",
}
var (
errDNP3PacketTooShort = errors.New("DNS packet too short")
)
type DNP3 struct {
BaseLayer // Stores the packet bytes and payload bytes.
DNP3DataLinkLayer DNP3DataLinkLayer
DNP3TransportLayer DNP3TransportLayer
DNP3ApplicationLayer DNP3ApplicationLayer
SomeByte byte
AnotherByte byte
restOfData []byte
}
type DNP3DataLinkLayer struct {
Start string
Length int
Control struct {
ControlByte string
IsMaster int `json:"Is Master"`
PRM int `json:"Primary"`
FCB int `json:"Frame Count Bit"`
FCV int `json:"Frame Count Valid"`
FUNC string `json:"Function Code"`
}
Destination int
Source int
CRC string
}
type DNP3TransportLayer struct {
TransportByte string
Final int
First int
Sequence int
}
type DNP3ApplicationLayer struct {
Control struct {
ControlByte string
First int
Final int
Confirm int
Unsolicited int
Sequence int
}
Function string `json:"Function Code"`
IINCode string `json:"Internal Indication (IIN)"`
}
type DNP3AppObject struct {
Group int
Variation int
Qualifier int
RangeStart int
RangeStop int
DataType int
Length int
}
func (d *DNP3) LayerType() gopacket.LayerType { return LayerTypeDNP3 }
func (d *DNP3) LayerContents() []byte {
return []byte{d.SomeByte, d.AnotherByte}
}
func (d *DNP3) LayerPayload() []byte |
func (d *DNP3) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
// If the data block is too short to be a DNP3 layer, then return an error.
if len(data) < 10 {
df.SetTruncated()
return errDNP3PacketTooShort
}
d.linkLayer(data)
d.transportLayer(data)
d.applicationLayer(data)
return nil
}
func decodeDNP3(data []byte, p gopacket.PacketBuilder) error {
// Attempt to decode the byte slice.
d := &DNP3{}
err := d.DecodeFromBytes(data, p)
if err != nil {
return err
}
// If the decoding worked, add the layer to the packet and set it
// as the application layer too, if there isn't already one.
p.AddLayer(d)
p.SetApplicationLayer(d)
d.BaseLayer = BaseLayer{Contents: data[:len(data)]}
d.BaseLayer.Payload = nil
return p.NextDecoder(gopacket.LayerTypePayload)
}
// CanDecode implements gopacket.DecodingLayer.
func (d *DNP3) CanDecode() gopacket.LayerClass {
return LayerTypeDNP3
}
// NextLayerType returns the layer type contained by this DecodingLayer.
func (d *DNP3) NextLayerType() gopacket.LayerType {
return gopacket.LayerTypePayload
}
// Payload returns nil, since TLS encrypted payload is inside TLSAppDataRecord
func (d *DNP3) Payload() []byte {
return nil
}
func appObject(bytesRead []byte) {
object := bytesRead[22:]
// indexSize := uint(object[2] & 0x70 >> 4)
// QualifierCode := uint(object[2] & 0x0F)
// fmt.Println(indexSize)
// fmt.Println(QualifierCode)
group := int(object[0])
variation := int(object[1])
qualifier := int(object[2])
rangeStart := int(object[3])
rangeStop := int(object[4])
dataType := int(object[5])
length := int(object[6])
appObject := DNP3AppObject{
Group: group,
Variation: variation,
Qualifier: qualifier,
RangeStart: rangeStart,
RangeStop: rangeStop,
DataType: dataType,
Length: length,
}
out, err := json.Marshal(appObject)
if err != nil {
panic(err)
}
fmt.Println(string(out))
}
func (d *DNP3) linkLayer(data []byte) {
start := d.hexConvert(data[0:2])
d.DNP3DataLinkLayer.Start = start
length := int(data[2])
d.DNP3DataLinkLayer.Length = length
ctlControl := d.hexConvert([]byte{data[3]})
d.DNP3DataLinkLayer.Control.ControlByte = ctlControl
IsMaster := int((data[3] & 0x80) >> 7)
d.DNP3DataLinkLayer.Control.IsMaster = IsMaster
PRM := int((data[3] & 0x40) >> 6)
d.DNP3DataLinkLayer.Control.PRM = PRM
FCB := int((data[3] & 0x20) >> 5)
d.DNP3DataLinkLayer.Control.FCB = FCB
FCV := int((data[3] & 0x10) >> 4)
d.DNP3DataLinkLayer.Control.FCV = FCV
FUNCCODE := data[3] & 0x0F
ctlFUNCCODE := fmt.Sprintf("%d", FUNCCODE)
var ctlFUNC string
if PRM == 0x00 {
ctlFUNC = SfCodes[FUNCCODE]
}
if PRM == 0x01 {
ctlFUNC = PfCodes[FUNCCODE]
}
ctlFUNC = ctlFUNC + " (" + ctlFUNCCODE + ")"
d.DNP3DataLinkLayer.Control.FUNC = ctlFUNC
// TODO: make sure 0 to 65535
destination := fmt.Sprintf("%x%x", data[5], data[4])
destinationInt, _ := strconv.Atoi(destination)
d.DNP3DataLinkLayer.Destination = destinationInt
// TODO: make sure 0 to 65535
source := fmt.Sprintf("%x%x", data[7], data[6])
sourceInt, _ := strconv.Atoi(source)
d.DNP3DataLinkLayer.Source = sourceInt
// TODO: Is correct? Hesapla
crc := fmt.Sprintf("0x%x%x", data[9], data[8])
d.DNP3DataLinkLayer.CRC = crc
}
func (d *DNP3) transportLayer(data []byte) {
transport := fmt.Sprintf("0x%x", data[10])
d.DNP3TransportLayer.TransportByte = transport
final := data[10] & 0x80 >> 7
d.DNP3TransportLayer.Final = int(final)
first := data[10] & 0x40 >> 6
d.DNP3TransportLayer.First = int(first)
sequence := data[10] & 0x3f // 6bit
d.DNP3TransportLayer.Sequence = int(sequence)
}
func (d *DNP3) applicationLayer(data []byte) {
// /***************************************************************************/
// /* Application Layer Bit-Masks */
// /***************************************************************************/
// #define DNP3_AL_UNS 0x10
// #define DNP3_AL_CON 0x20
// #define DNP3_AL_FIN 0x40
// #define DNP3_AL_FIR 0x80
// #define DNP3_AL_SEQ 0x0f
// #define DNP3_AL_FUNC 0xff
controlByte := fmt.Sprintf("0x%x", data[11])
d.DNP3ApplicationLayer.Control.ControlByte = controlByte | {
return d.restOfData
} | identifier_body |
dnp3.go | 3: "Objects prefixed with 4-octet index",
4: "Objects prefixed with 1-octet object size",
5: "Objects prefixed with 2-octet object size",
6: "Objects prefixed with 4-octet object size",
7: "Reserved",
}
/***************************************************************************/
/* Application Layer Object Prefix codes bits */
/***************************************************************************/
var ObjRangeSpecifierCodes = map[byte]string{
0: "8-bit Start and Stop Indices in Range Field",
1: "16-bit Start and Stop Indices in Range Field",
2: "32-bit Start and Stop Indices in Range Field",
3: "8-bit Absolute Address in Range Field",
4: "16-bit Absolute Address in Range Field",
5: "32-bit Absolute Address in Range Field",
6: "Length of Range field is 0 (no range field)",
7: "8-bit Single Field Quantity",
8: "16-bit Single Field Quantity",
9: "32-bit Single Field Quantity",
10: "Reserved",
11: "Free-format Qualifier, range field has 1 octet count of objects",
12: "Reserved",
13: "Reserved",
14: "Reserved",
15: "Reserved",
}
var (
errDNP3PacketTooShort = errors.New("DNS packet too short")
)
type DNP3 struct {
BaseLayer // Stores the packet bytes and payload bytes.
DNP3DataLinkLayer DNP3DataLinkLayer
DNP3TransportLayer DNP3TransportLayer
DNP3ApplicationLayer DNP3ApplicationLayer
SomeByte byte
AnotherByte byte
restOfData []byte
}
type DNP3DataLinkLayer struct {
Start string
Length int
Control struct {
ControlByte string
IsMaster int `json:"Is Master"`
PRM int `json:"Primary"`
FCB int `json:"Frame Count Bit"`
FCV int `json:"Frame Count Valid"`
FUNC string `json:"Function Code"`
}
Destination int
Source int
CRC string
}
type DNP3TransportLayer struct {
TransportByte string
Final int
First int
Sequence int
}
type DNP3ApplicationLayer struct {
Control struct {
ControlByte string
First int
Final int
Confirm int
Unsolicited int
Sequence int
}
Function string `json:"Function Code"`
IINCode string `json:"Internal Indication (IIN)"`
}
type DNP3AppObject struct {
Group int
Variation int
Qualifier int
RangeStart int
RangeStop int
DataType int
Length int
}
func (d *DNP3) LayerType() gopacket.LayerType { return LayerTypeDNP3 }
func (d *DNP3) LayerContents() []byte {
return []byte{d.SomeByte, d.AnotherByte}
}
func (d *DNP3) LayerPayload() []byte {
return d.restOfData
}
func (d *DNP3) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
// If the data block is too short to be a DNP3 layer, then return an error.
if len(data) < 10 {
df.SetTruncated()
return errDNP3PacketTooShort
}
d.linkLayer(data)
d.transportLayer(data)
d.applicationLayer(data)
return nil
}
func decodeDNP3(data []byte, p gopacket.PacketBuilder) error {
// Attempt to decode the byte slice.
d := &DNP3{}
err := d.DecodeFromBytes(data, p)
if err != nil {
return err
}
// If the decoding worked, add the layer to the packet and set it
// as the application layer too, if there isn't already one.
p.AddLayer(d)
p.SetApplicationLayer(d)
d.BaseLayer = BaseLayer{Contents: data[:len(data)]}
d.BaseLayer.Payload = nil
return p.NextDecoder(gopacket.LayerTypePayload)
}
// CanDecode implements gopacket.DecodingLayer.
func (d *DNP3) CanDecode() gopacket.LayerClass {
return LayerTypeDNP3
}
// NextLayerType returns the layer type contained by this DecodingLayer.
func (d *DNP3) NextLayerType() gopacket.LayerType {
return gopacket.LayerTypePayload
}
// Payload returns nil, since TLS encrypted payload is inside TLSAppDataRecord
func (d *DNP3) Payload() []byte {
return nil
}
func appObject(bytesRead []byte) {
object := bytesRead[22:]
// indexSize := uint(object[2] & 0x70 >> 4)
// QualifierCode := uint(object[2] & 0x0F)
// fmt.Println(indexSize)
// fmt.Println(QualifierCode)
group := int(object[0])
variation := int(object[1])
qualifier := int(object[2])
rangeStart := int(object[3])
rangeStop := int(object[4])
dataType := int(object[5])
length := int(object[6])
appObject := DNP3AppObject{
Group: group,
Variation: variation,
Qualifier: qualifier,
RangeStart: rangeStart,
RangeStop: rangeStop,
DataType: dataType,
Length: length,
}
out, err := json.Marshal(appObject)
if err != nil {
panic(err)
}
fmt.Println(string(out))
}
func (d *DNP3) linkLayer(data []byte) {
start := d.hexConvert(data[0:2])
d.DNP3DataLinkLayer.Start = start
length := int(data[2])
d.DNP3DataLinkLayer.Length = length
ctlControl := d.hexConvert([]byte{data[3]})
d.DNP3DataLinkLayer.Control.ControlByte = ctlControl
IsMaster := int((data[3] & 0x80) >> 7)
d.DNP3DataLinkLayer.Control.IsMaster = IsMaster
PRM := int((data[3] & 0x40) >> 6)
d.DNP3DataLinkLayer.Control.PRM = PRM
FCB := int((data[3] & 0x20) >> 5)
d.DNP3DataLinkLayer.Control.FCB = FCB
FCV := int((data[3] & 0x10) >> 4)
d.DNP3DataLinkLayer.Control.FCV = FCV
FUNCCODE := data[3] & 0x0F
ctlFUNCCODE := fmt.Sprintf("%d", FUNCCODE)
var ctlFUNC string
if PRM == 0x00 {
ctlFUNC = SfCodes[FUNCCODE]
}
if PRM == 0x01 |
ctlFUNC = ctlFUNC + " (" + ctlFUNCCODE + ")"
d.DNP3DataLinkLayer.Control.FUNC = ctlFUNC
// TODO: make sure 0 to 65535
destination := fmt.Sprintf("%x%x", data[5], data[4])
destinationInt, _ := strconv.Atoi(destination)
d.DNP3DataLinkLayer.Destination = destinationInt
// TODO: make sure 0 to 65535
source := fmt.Sprintf("%x%x", data[7], data[6])
sourceInt, _ := strconv.Atoi(source)
d.DNP3DataLinkLayer.Source = sourceInt
// TODO: Is correct? Hesapla
crc := fmt.Sprintf("0x%x%x", data[9], data[8])
d.DNP3DataLinkLayer.CRC = crc
}
func (d *DNP3) transportLayer(data []byte) {
transport := fmt.Sprintf("0x%x", data[10])
d.DNP3TransportLayer.TransportByte = transport
final := data[10] & 0x80 >> 7
d.DNP3TransportLayer.Final = int(final)
first := data[10] & 0x40 >> 6
d.DNP3TransportLayer.First = int(first)
sequence := data[10] & 0x3f // 6bit
d.DNP3TransportLayer.Sequence = int(sequence)
}
func (d *DNP3) applicationLayer(data []byte) {
// /***************************************************************************/
// /* Application Layer Bit-Masks */
// /***************************************************************************/
// #define DNP3_AL_UNS 0x10
// #define DNP3_AL_CON 0x20
// #define DNP3_AL_FIN 0x40
// #define DNP3_AL_FIR 0x80
// #define DNP3_AL_SEQ 0x0f
// #define DNP3_AL_FUNC 0xff
controlByte := fmt.Sprintf("0x%x", data[11])
d.DNP3ApplicationLayer.Control.ControlByte = controlByte | {
ctlFUNC = PfCodes[FUNCCODE]
} | conditional_block |
config.js | UENTD_PORT, 10) || 24224;
internals.Config.nginxHost = process.env.UNMS_NGINX_HOST || '127.0.0.1';
internals.Config.nginxPort = parseInt(process.env.UNMS_NGINX_PORT, 10) || 12345;
internals.Config.defaultInternalHttpPort = 8081;
internals.Config.defaultInternalWsPort = 8082;
internals.Config.defaultHttpsPort = 443;
internals.Config.httpPort = parseInt(process.env.HTTP_PORT, 10) || internals.Config.defaultInternalHttpPort;
internals.Config.wsPort = parseInt(process.env.WS_PORT, 10) || internals.Config.defaultInternalWsPort;
internals.Config.publicHttpsPort = parseInt(process.env.PUBLIC_HTTPS_PORT, 10) || internals.Config.defaultHttpsPort;
internals.Config.publicWsPort = parseInt(process.env.PUBLIC_WS_PORT, 10) || internals.Config.publicHttpsPort;
internals.Config.secureLinkSecret = process.env.SECURE_LINK_SECRET || 'enigma';
internals.Config.leChallengeDir = './challenge';
internals.Config.useCustomSslCert = Boolean(process.env.SSL_CERT);
internals.Config.socketRPCTimeout = 15000; // generic rpc call timeout
internals.Config.socketRPCBackupTimeout = 180000; // backup rpc call timeout
internals.Config.pg = {
host: process.env.UNMS_PG_HOST || '127.0.0.1',
port: parseInt(process.env.UNMS_PG_PORT, 10) || 5432,
database: process.env.UNMS_PG_DATABASE || 'unms',
user: process.env.UNMS_PG_USER || 'postgres',
password: process.env.UNMS_PG_PASSWORD || '',
schema: process.env.UNMS_PG_SCHEMA || 'public',
};
internals.Config.rabbitMQ = {
host: process.env.UNMS_RABBITMQ_HOST || '127.0.0.1',
port: parseInt(process.env.UNMS_RABBITMQ_PORT, 10) || 5672,
exchange: 'unms',
};
internals.Config.publicDir = path.join(__dirname, 'public');
internals.Config.templatePaths = map(viewPath => path.join(__dirname, viewPath), [
'/public',
'/lib/api-docs/templates',
]);
internals.Config.publicPaths = map(viewPath => path.join(__dirname, viewPath), [
'/public',
'/lib/api-docs/public',
]);
// UNMS cloud related settings
internals.Config.cloudSettings = internals.Config.cloud ? {
domain: process.env.CLOUD_DOMAIN,
googleMapsApiKey: process.env.CLOUD_MAPS_API_KEY,
mapsProvider: process.env.CLOUD_MAPS_PROVIDER,
billingApiUrl: process.env.CLOUD_BILLING_API_URL,
ssoApiUrl: process.env.CLOUD_SSO_API_URL,
maintenanceWindowApiUrl: process.env.CLOUD_MAINTENANCE_WINDOW_API_URL,
redisInstanceId: process.env.UNMS_REDISDB_INSTANCE_ID,
smtpHostname: process.env.CLOUD_SMTP_HOSTNAME,
smtpPort: process.env.CLOUD_SMTP_PORT,
smtpUsername: process.env.CLOUD_SMTP_USERNAME,
smtpPassword: process.env.CLOUD_SMTP_PASSWORD,
smtpSender: process.env.CLOUD_SMTP_SENDER_ADDRESS,
smtpTimeout: process.env.CLOUD_SMTP_TIMEOUT,
smtpTlsAllowUnauthorized: process.env.CLOUD_SMTP_TLS_ALLOW_UNAUTHORIZED,
smtpSecurityMode: process.env.CLOUD_SMTP_SECURITY_MODE,
smtpAuthEnabled: process.env.CLOUD_SMTP_AUTH_ENABLED,
storage: {
gcsProjectId: process.env.CLOUD_GCS_PROJECT_ID,
gcsKeyFilename: process.env.CLOUD_GCS_KEY_FILENAME,
},
} : null;
internals.Config.branch = process.env.BRANCH || 'master';
internals.Config.unmsLatestVersionUrl =
`https://api.github.com/repos/Ubiquiti-App/UNMS/contents/latest-version?ref=${internals.Config.branch}`;
// discovery
internals.Config.discoveryScanTimeout = toMs('second', 5);
internals.Config.discoveryIpRangeMaxSize = 65536; // 2^16
// Reporting
internals.Config.sentryDSN =
'https://3a0cdfa562074c6ca018c01b666d37c5:[email protected]/120911';
// production log token in Logentries
internals.Config.logentriesToken = 'b740d3fa-9176-43b8-b259-58a6660590dc';
// affects password hashing time, see https://github.com/kelektiv/node.bcrypt.js#a-note-on-rounds
internals.Config.pwdSaltRounds = 8;
internals.Config.jwtToken = 'x-auth-token';
internals.Config.authStrategy = 'jwt';
internals.Config.defaultEmail = '[email protected]';
internals.Config.defaultUsername = 'ubnt';
internals.Config.defaultPwd = 'ubntubnt';
internals.Config.passwordTokenExpiry = toMs('minute', 30);
internals.Config.sessionTimeout = toMs('minute', 30);
internals.Config.extendedSessionTimeout = toMs('hour', 24);
internals.Config.hashAlgorithm = 'aes-256-cbc';
internals.Config.totpAuthSecretOptions = {
issuer: 'UNMS',
};
internals.Config.httpConnection = {
port: internals.Config.httpPort,
routes: {
cors: {
origin: ['*'],
headers: ['Accept', 'Authorization', 'Content-Type', 'If-None-Match', internals.Config.jwtToken],
exposedHeaders: [internals.Config.jwtToken],
},
files: {
relativeTo: internals.Config.publicDir,
},
security: true,
},
state: {
strictHeader: false,
},
};
internals.Config.deviceConfigBackup = {
dir: './data/config-backups',
minimumFiles: 6,
ttl: toMs('day', 30),
multiBackup: {
dir: 'multi',
ttl: toMs('hour', 1),
},
fileMaxBytes: 10000000,
queue: {
delay: toMs('minute', 2),
concurency: 5,
},
};
internals.Config.deviceTypes = {
all: ['olt', 'erouter'],
};
internals.Config.deviceServices = {
ntpServers: {
ntpServer1: '0.pool.ntp.org',
ntpServer2: '1.pool.ntp.org',
},
};
internals.Config.statisticsIntervals = {
minute: { length: toMs('minute', 2), period: toMs('second', 1) },
hour: { length: toMs('hour', 1), period: toMs('second', 15) },
day: { length: toMs('day', 1), period: toMs('minute', 15) },
month: { length: toMs('month', 1), period: toMs('hour', 8) },
quarter: { length: toMs('month', 3), period: toMs('hour', 24) },
year: { length: toMs('year', 1), period: toMs('hour', 106) },
};
internals.Config.statisticsIntervalMapping = {
[IntervalEnum.Hour]: ['hour'],
[IntervalEnum.Day]: ['day'],
[IntervalEnum.Month]: ['month'],
[IntervalEnum.Quarter]: ['quarter'],
[IntervalEnum.Year]: ['year'],
};
const findMaxStatisticsIntervalPeriod = flow(
map(name => internals.Config.statisticsIntervals[name].period),
max
);
internals.Config.statisticsIntervalPeriodMapping = reduce(
internals.Config.statisticsIntervalMapping,
(acc, values, interval) => (Object.assign(acc, { [interval]: findMaxStatisticsIntervalPeriod(values) })),
{}
);
const findMaxStatisticsIntervalLength = flow(
map(name => internals.Config.statisticsIntervals[name].length),
max
);
internals.Config.statisticsIntervalLengthMapping = reduce(
internals.Config.statisticsIntervalMapping,
(acc, values, interval) => (Object.assign(acc, { [interval]: findMaxStatisticsIntervalLength(values) })),
{}
);
internals.Config.deviceLog = {
[DevicePropertyEnum.Cpu]: {
name: 'CPU',
unit: '%',
limit: 90,
interval: toMs('second', 30),
level: LogLevelEnum.Warning,
logType: LogTypeEnum.DeviceCpuOverLimit,
},
[DevicePropertyEnum.Ram]: {
name: 'RAM',
unit: '%',
limit: 90,
interval: toMs('second', 10),
level: LogLevelEnum.Warning,
logType: LogTypeEnum.DeviceRamOverLimit,
},
};
internals.Config.outages = {
unmsStartGracePeriod: toMs('minute', 2),
lagGracePeriod: toMs('second', 5), // avoid responding to possible lagging device's communication
maxAge: toMs('month', 3),
};
internals.Config.siteImages = { | random_line_split |
||
packet.go | kCidDefaultLength is the length of connection ID we generate.
// TODO: make this configurable.
const kCidDefaultLength = 5
// ConnectionId identifies the connection that a packet belongs to.
type ConnectionId []byte
// String stringifies a connection ID in the natural way.
func (c ConnectionId) String() string {
return hex.EncodeToString(c)
}
// EncodeLength produces the length encoding used in the long packet header.
func (c ConnectionId) EncodeLength() byte {
if len(c) == 0 {
return 0
}
assert(len(c) >= 4 && len(c) <= 18)
return byte(len(c) - 3)
}
// The PDU definition for the header.
// These types are capitalized so that |codec| can use them.
type packetHeader struct {
// Type is the on-the-wire form of the packet type.
// Consult getHeaderType if you want a value that corresponds to the
// definition of packetType.
Type packetType
Version VersionNumber
ConnectionIDLengths byte
DestinationConnectionID ConnectionId
SourceConnectionID ConnectionId
TokenLength uint8
Token []byte
PayloadLength uint64 `tls:"varint"`
// In order to decode a short header, the length of the connection
// ID must be set in |shortCidLength| before decoding.
shortCidLength uintptr
}
func (p packetHeader) String() string {
ht := "SHORT"
if p.Type.isLongHeader() {
ht = "LONG"
}
return fmt.Sprintf("%s PT=%v", ht, p.getHeaderType())
}
func (p *packetHeader) getHeaderType() packetType {
if p.Type.isLongHeader() {
return p.Type & 0x7f
}
return packetTypeProtectedShort
}
type packet struct {
packetHeader
PacketNumber uint64 // Never more than 32 bits on the wire.
payload []byte
}
// This reads from p.ConnectionIDLengths.
func (p packetHeader) ConnectionIDLengths__length() uintptr {
if p.Type.isLongHeader() {
return 1
}
return 0
}
func (p packetHeader) TokenLength__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return 1
}
func (p packetHeader) Token__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return uintptr(p.TokenLength)
}
func (p packetHeader) DestinationConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return p.shortCidLength
}
l := p.ConnectionIDLengths >> 4
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) SourceConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return 0
}
l := p.ConnectionIDLengths & 0xf
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) PayloadLength__length() uintptr {
if p.Type.isLongHeader() {
return codecDefaultSize
}
return 0
}
func (p packetHeader) Version__length() uintptr {
if p.Type.isLongHeader() {
return 4
}
return 0
}
func newPacket(pt packetType, destCid ConnectionId, srcCid ConnectionId, ver VersionNumber, pn uint64, payload []byte, aeadOverhead int) *packet {
if pt == packetTypeProtectedShort {
// Only support writing the 32-bit packet number.
pt = packetType(0x2 | packetFlagShortHeader)
srcCid = nil
} else {
pt = pt | packetType(packetFlagLongHeader)
}
lengths := (destCid.EncodeLength() << 4) | srcCid.EncodeLength()
return &packet{
packetHeader: packetHeader{
Type: pt,
ConnectionIDLengths: lengths,
DestinationConnectionID: destCid,
SourceConnectionID: srcCid,
Version: ver,
PayloadLength: uint64(len(payload) + 4 + aeadOverhead),
},
PacketNumber: pn,
payload: payload,
}
}
type versionNegotiationPacket struct {
Versions []byte
}
func newVersionNegotiationPacket(versions []VersionNumber) *versionNegotiationPacket {
var buf bytes.Buffer
for _, v := range versions {
buf.Write(encodeArgs(v))
}
return &versionNegotiationPacket{buf.Bytes()}
}
/*
We don't use these.
func encodePacket(c ConnectionState, aead Aead, p *Packet) ([]byte, error) {
hdr, err := encode(&p.packetHeader)
if err != nil {
return nil, err
}
b, err := aead.protect(p.packetHeader.PacketNumber, hdr, p.payload)
if err != nil {
return nil, err
}
return encodeArgs(hdr, b), nil
}
func decodePacket(c ConnectionState, aead Aead, b []byte) (*Packet, error) {
// Parse the header
var hdr packetHeader
br, err := decode(&hdr, b)
if err != nil {
return nil, err
}
hdr.PacketNumber = c.expandPacketNumber(hdr.PacketNumber)
pt, err := aead.unprotect(hdr.PacketNumber, b[0:br], b[br:])
if err != nil {
return nil, err
}
return &Packet{hdr, pt}, nil
}
*/
func dumpPacket(payload []byte) string {
first := true
ret := fmt.Sprintf("%d=[", len(payload))
for len(payload) > 0 {
if !first {
ret += ", "
}
first = false
n, f, err := decodeFrame(payload)
if err != nil {
ret += fmt.Sprintf("Undecoded: [%x]", payload)
break
}
payload = payload[n:]
// TODO([email protected]): Not sure why %v doesn't work
ret += f.String()
}
ret += "]"
return ret
}
type pneCipherFactory interface {
create(sample []byte) cipher.Stream
}
type pneCipherFactoryAES struct {
block cipher.Block
}
func newPneCipherFactoryAES(key []byte) pneCipherFactory {
inner, err := aes.NewCipher(key)
assert(err == nil)
if err != nil {
return nil
}
return &pneCipherFactoryAES{block: inner}
}
func (f *pneCipherFactoryAES) create(sample []byte) cipher.Stream {
if len(sample) != 16 {
return nil
}
return cipher.NewCTR(f.block, sample)
}
func xorPacketNumber(hdr *packetHeader, hdrlen int, pnbuf []byte, p []byte, factory pneCipherFactory) error {
logf(logTypeTrace, "PNE Operation: hdrlen=%v, hdr=%x, payload=%x", hdrlen, p[:hdrlen], p)
// The packet must be at least long enough to contain
// the header, plus a minimum 1-byte PN, plus the sample.
sample_length := 16
if sample_length > len(p)-(hdrlen+1) {
logf(logTypePacket, "Packet too short")
return nil
}
// Now compute the offset
sample_offset := hdrlen + 4
if sample_offset+sample_length > len(p) {
sample_offset = len(p) - sample_length
}
sample := p[sample_offset : sample_offset+sample_length]
logf(logTypeTrace, "PNE sample_offset=%d sample=%x", sample_offset, sample)
stream := factory.create(sample)
stream.XORKeyStream(pnbuf, p[hdrlen:hdrlen+len(pnbuf)])
return nil
}
var pnPatterns = []struct {
prefix byte
mask byte
length int
}{
{
0, 0x80, 1,
},
{
0x80, 0xc0, 2,
},
{
0xc0, 0xc0, 4,
},
}
const ()
func encodePacketNumber(pn uint64, l int) []byte {
var buf bytes.Buffer
i := 0
for i, _ = range pnPatterns {
if pnPatterns[i].length == l {
break
}
}
uintEncodeInt(&buf, pn, uintptr(l))
b := buf.Bytes()
b[0] &= ^pnPatterns[i].mask
b[0] |= pnPatterns[i].prefix
return b
}
func decodePacketNumber(buf []byte) (uint64, int, error) {
if len(buf) < 1 {
return 0, 0, fmt.Errorf("Zero-length packet number")
}
i := 0
for i, _ = range pnPatterns {
if pnPatterns[i].mask&buf[0] == pnPatterns[i].prefix {
break
}
}
pat := &pnPatterns[i]
if len(buf) < pat.length | {
return 0, 0, fmt.Errorf("Buffer too short for packet number (%v < %v)", len(buf), pat.length)
} | conditional_block |
|
packet.go | 9 0 1
+-+-+-+-+-+-+-+-+
|0|K|1|1|0|R R R|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Connection ID (0..144) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Packet Number (8/16/32) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Protected Payload (*) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
const (
packetFlagLongHeader = byte(0x80)
packetFlagK = byte(0x40)
packetFlagShortHeader = byte(0x30)
)
// This packet type differs considerably from the spec. It includes both
// long and short headers in the same value space. Long headers are from
// 0-0x7f (inclusive); short headers are always represented as 0xff.
type packetType byte
const (
packetTypeInitial = packetType(0x7f)
packetTypeRetry = packetType(0x7e)
packetTypeHandshake = packetType(0x7d)
packetType0RTTProtected = packetType(0x7c)
packetTypeProtectedShort = packetType(0x00) // Not a real type
)
func (pt packetType) isLongHeader() bool {
return pt&packetType(packetFlagLongHeader) != 0
}
func (pt packetType) isProtected() bool {
if !pt.isLongHeader() {
return true
}
switch pt & 0x7f {
case packetTypeInitial, packetTypeHandshake, packetTypeRetry:
return false
}
return true
}
func (pt packetType) String() string {
switch pt {
case packetTypeInitial:
return "Initial"
case packetTypeRetry:
return "Retry"
case packetTypeHandshake:
return "Handshake"
case packetType0RTTProtected:
return "0-RTT"
case packetTypeProtectedShort:
return "1-RTT"
default:
return fmt.Sprintf("%x", uint8(pt))
}
}
// kCidDefaultLength is the length of connection ID we generate.
// TODO: make this configurable.
const kCidDefaultLength = 5
// ConnectionId identifies the connection that a packet belongs to.
type ConnectionId []byte
// String stringifies a connection ID in the natural way.
func (c ConnectionId) String() string {
return hex.EncodeToString(c)
}
// EncodeLength produces the length encoding used in the long packet header.
func (c ConnectionId) EncodeLength() byte {
if len(c) == 0 {
return 0
}
assert(len(c) >= 4 && len(c) <= 18)
return byte(len(c) - 3)
}
// The PDU definition for the header.
// These types are capitalized so that |codec| can use them.
type packetHeader struct {
// Type is the on-the-wire form of the packet type.
// Consult getHeaderType if you want a value that corresponds to the
// definition of packetType.
Type packetType
Version VersionNumber
ConnectionIDLengths byte
DestinationConnectionID ConnectionId
SourceConnectionID ConnectionId
TokenLength uint8
Token []byte
PayloadLength uint64 `tls:"varint"`
// In order to decode a short header, the length of the connection
// ID must be set in |shortCidLength| before decoding.
shortCidLength uintptr
}
func (p packetHeader) String() string {
ht := "SHORT"
if p.Type.isLongHeader() {
ht = "LONG"
}
return fmt.Sprintf("%s PT=%v", ht, p.getHeaderType())
}
func (p *packetHeader) getHeaderType() packetType {
if p.Type.isLongHeader() {
return p.Type & 0x7f
}
return packetTypeProtectedShort
}
type packet struct {
packetHeader
PacketNumber uint64 // Never more than 32 bits on the wire.
payload []byte
}
// This reads from p.ConnectionIDLengths.
func (p packetHeader) ConnectionIDLengths__length() uintptr {
if p.Type.isLongHeader() {
return 1
}
return 0
}
func (p packetHeader) TokenLength__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return 1
}
func (p packetHeader) Token__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return uintptr(p.TokenLength)
}
func (p packetHeader) DestinationConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return p.shortCidLength
}
l := p.ConnectionIDLengths >> 4
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) SourceConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return 0
}
l := p.ConnectionIDLengths & 0xf
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) PayloadLength__length() uintptr {
if p.Type.isLongHeader() {
return codecDefaultSize
}
return 0
}
func (p packetHeader) Version__length() uintptr {
if p.Type.isLongHeader() {
return 4
}
return 0
}
func newPacket(pt packetType, destCid ConnectionId, srcCid ConnectionId, ver VersionNumber, pn uint64, payload []byte, aeadOverhead int) *packet {
if pt == packetTypeProtectedShort {
// Only support writing the 32-bit packet number.
pt = packetType(0x2 | packetFlagShortHeader)
srcCid = nil
} else {
pt = pt | packetType(packetFlagLongHeader)
}
lengths := (destCid.EncodeLength() << 4) | srcCid.EncodeLength()
return &packet{
packetHeader: packetHeader{
Type: pt,
ConnectionIDLengths: lengths,
DestinationConnectionID: destCid,
SourceConnectionID: srcCid,
Version: ver,
PayloadLength: uint64(len(payload) + 4 + aeadOverhead),
},
PacketNumber: pn,
payload: payload,
}
}
type versionNegotiationPacket struct {
Versions []byte
}
func newVersionNegotiationPacket(versions []VersionNumber) *versionNegotiationPacket {
var buf bytes.Buffer
for _, v := range versions {
buf.Write(encodeArgs(v))
}
return &versionNegotiationPacket{buf.Bytes()}
}
/*
We don't use these.
func encodePacket(c ConnectionState, aead Aead, p *Packet) ([]byte, error) {
hdr, err := encode(&p.packetHeader)
if err != nil {
return nil, err
}
b, err := aead.protect(p.packetHeader.PacketNumber, hdr, p.payload)
if err != nil {
return nil, err
}
return encodeArgs(hdr, b), nil
}
func decodePacket(c ConnectionState, aead Aead, b []byte) (*Packet, error) {
// Parse the header
var hdr packetHeader
br, err := decode(&hdr, b)
if err != nil {
return nil, err
}
hdr.PacketNumber = c.expandPacketNumber(hdr.PacketNumber)
pt, err := aead.unprotect(hdr.PacketNumber, b[0:br], b[br:])
if err != nil {
return nil, err
}
return &Packet{hdr, pt}, nil
}
*/
func dumpPacket(payload []byte) string {
first := true
ret := fmt.Sprintf("%d=[", len(payload))
for len(payload) > 0 {
if !first {
ret += ", "
}
first = false
n, f, err := decodeFrame(payload)
if err != nil {
ret += fmt.Sprintf("Undecoded: [%x]", payload)
break
}
payload = payload[n:]
// TODO([email protected]): Not sure why %v doesn't work
ret += f.String()
}
ret += "]"
return ret
}
type pneCipherFactory interface {
create(sample []byte) cipher.Stream
}
type pneCipherFactoryAES struct {
block cipher.Block
}
func newPneCipherFactoryAES(key []byte) pneCipherFactory {
inner, err := aes.NewCipher(key)
assert(err == nil)
if err != nil {
return nil
}
return &pneCipherFactoryAES{block: inner}
}
func (f *pneCipherFactoryAES) create(sample []byte) cipher.Stream {
if len(sample) != 16 {
return nil
}
return cipher.NewCTR(f.block, sample)
}
func xorPacketNumber(hdr *packetHeader, hdrlen int, pnbuf []byte, p []byte, factory pneCipherFactory) error {
logf(logTypeTrace, "PNE Operation: hdrlen=%v, hdr=%x, payload=%x", hdrlen, p[:hdrlen], p)
// The packet must be at least long enough to contain
// the header, plus a minimum 1-byte PN, plus the sample. | sample_length := 16
if sample_length > len(p)-(hdrlen+1) { | random_line_split |
|
packet.go | 2) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|DCIL(4)|SCIL(4)|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Connection ID (0/32..144) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Connection ID (0/32..144) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Token Length (i) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Token (*) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Length (i) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Packet Number (8/16/32) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Payload (*) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+
|0|K|1|1|0|R R R|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Connection ID (0..144) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Packet Number (8/16/32) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Protected Payload (*) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
const (
packetFlagLongHeader = byte(0x80)
packetFlagK = byte(0x40)
packetFlagShortHeader = byte(0x30)
)
// This packet type differs considerably from the spec. It includes both
// long and short headers in the same value space. Long headers are from
// 0-0x7f (inclusive); short headers are always represented as 0xff.
type packetType byte
const (
packetTypeInitial = packetType(0x7f)
packetTypeRetry = packetType(0x7e)
packetTypeHandshake = packetType(0x7d)
packetType0RTTProtected = packetType(0x7c)
packetTypeProtectedShort = packetType(0x00) // Not a real type
)
func (pt packetType) isLongHeader() bool {
return pt&packetType(packetFlagLongHeader) != 0
}
func (pt packetType) isProtected() bool {
if !pt.isLongHeader() {
return true
}
switch pt & 0x7f {
case packetTypeInitial, packetTypeHandshake, packetTypeRetry:
return false
}
return true
}
func (pt packetType) String() string {
switch pt {
case packetTypeInitial:
return "Initial"
case packetTypeRetry:
return "Retry"
case packetTypeHandshake:
return "Handshake"
case packetType0RTTProtected:
return "0-RTT"
case packetTypeProtectedShort:
return "1-RTT"
default:
return fmt.Sprintf("%x", uint8(pt))
}
}
// kCidDefaultLength is the length of connection ID we generate.
// TODO: make this configurable.
const kCidDefaultLength = 5
// ConnectionId identifies the connection that a packet belongs to.
type ConnectionId []byte
// String stringifies a connection ID in the natural way.
func (c ConnectionId) String() string {
return hex.EncodeToString(c)
}
// EncodeLength produces the length encoding used in the long packet header.
func (c ConnectionId) EncodeLength() byte {
if len(c) == 0 {
return 0
}
assert(len(c) >= 4 && len(c) <= 18)
return byte(len(c) - 3)
}
// The PDU definition for the header.
// These types are capitalized so that |codec| can use them.
type packetHeader struct {
// Type is the on-the-wire form of the packet type.
// Consult getHeaderType if you want a value that corresponds to the
// definition of packetType.
Type packetType
Version VersionNumber
ConnectionIDLengths byte
DestinationConnectionID ConnectionId
SourceConnectionID ConnectionId
TokenLength uint8
Token []byte
PayloadLength uint64 `tls:"varint"`
// In order to decode a short header, the length of the connection
// ID must be set in |shortCidLength| before decoding.
shortCidLength uintptr
}
func (p packetHeader) String() string {
ht := "SHORT"
if p.Type.isLongHeader() {
ht = "LONG"
}
return fmt.Sprintf("%s PT=%v", ht, p.getHeaderType())
}
func (p *packetHeader) getHeaderType() packetType {
if p.Type.isLongHeader() {
return p.Type & 0x7f
}
return packetTypeProtectedShort
}
type packet struct {
packetHeader
PacketNumber uint64 // Never more than 32 bits on the wire.
payload []byte
}
// This reads from p.ConnectionIDLengths.
func (p packetHeader) ConnectionIDLengths__length() uintptr {
if p.Type.isLongHeader() {
return 1
}
return 0
}
func (p packetHeader) TokenLength__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return 1
}
func (p packetHeader) Token__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return uintptr(p.TokenLength)
}
func (p packetHeader) DestinationConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return p.shortCidLength
}
l := p.ConnectionIDLengths >> 4
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) SourceConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return 0
}
l := p.ConnectionIDLengths & 0xf
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) PayloadLength__length() uintptr {
if p.Type.isLongHeader() {
return codecDefaultSize
}
return 0
}
func (p packetHeader) Version__length() uintptr {
if p.Type.isLongHeader() {
return 4
}
return 0
}
func newPacket(pt packetType, destCid ConnectionId, srcCid ConnectionId, ver VersionNumber, pn uint64, payload []byte, aeadOverhead int) *packet {
if pt == packetTypeProtectedShort {
// Only support writing the 32-bit packet number.
pt = packetType(0x2 | packetFlagShortHeader)
srcCid = nil
} else {
pt = pt | packetType(packetFlagLongHeader)
}
lengths := (destCid.EncodeLength() << 4) | srcCid.EncodeLength()
return &packet{
packetHeader: packetHeader{
Type: pt,
ConnectionIDLengths: lengths,
DestinationConnectionID: destCid,
SourceConnectionID: srcCid,
Version: ver,
PayloadLength: uint64(len(payload) + 4 + aeadOverhead),
},
PacketNumber: pn,
payload: payload,
}
}
type versionNegotiationPacket struct {
Versions []byte
}
func | (versions []VersionNumber) *versionNegotiationPacket {
var buf bytes.Buffer
for _, v := range versions {
buf.Write(encodeArgs(v))
}
return &versionNegotiationPacket{buf.Bytes()}
}
/*
We don't use these.
func encodePacket(c ConnectionState, aead Aead, p *Packet) ([]byte, error) {
hdr, err := encode(&p.packetHeader)
if err != nil {
return nil, err
}
b, err := aead.protect(p.packetHeader.PacketNumber, hdr, p.payload)
if err != nil {
return nil, err
}
return encodeArgs(hdr, b), nil
}
func decodePacket(c ConnectionState, aead Aead, b []byte) (*Packet, error) {
// Parse the header
var hdr packetHeader
br, err := decode(&hdr, b)
if err != nil {
return nil, err
}
hdr.PacketNumber = c.expandPacketNumber(hdr.PacketNumber)
pt, err := aead.unprotect(hdr.PacketNumber, b[0:br], b[br:])
if err != nil {
return nil, err
}
return &Packet{hdr, pt}, nil
}
*/
func dumpPacket(payload []byte) string {
first := true
ret := fmt.Sprintf("%d=[", len(payload))
for len(payload) > 0 {
if !first {
ret += ", "
}
first = false
n, f, err := decodeFrame(payload)
if err != nil {
ret += fmt.Sprintf("Undecoded: [%x]", payload)
break
}
payload = payload[n:]
// TODO([email protected]): Not sure why %v doesn't work
ret += f.String()
}
ret += "]"
return ret
}
type pneCipherFactory interface {
create(sample []byte) cipher.Stream
}
type pneCipherFactoryAES struct {
block cipher.Block
}
| newVersionNegotiationPacket | identifier_name |
packet.go | 2) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|DCIL(4)|SCIL(4)|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Connection ID (0/32..144) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Connection ID (0/32..144) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Token Length (i) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Token (*) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Length (i) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Packet Number (8/16/32) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Payload (*) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+
|0|K|1|1|0|R R R|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Connection ID (0..144) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Packet Number (8/16/32) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Protected Payload (*) ...
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
const (
packetFlagLongHeader = byte(0x80)
packetFlagK = byte(0x40)
packetFlagShortHeader = byte(0x30)
)
// This packet type differs considerably from the spec. It includes both
// long and short headers in the same value space. Long headers are from
// 0-0x7f (inclusive); short headers are always represented as 0xff.
type packetType byte
const (
packetTypeInitial = packetType(0x7f)
packetTypeRetry = packetType(0x7e)
packetTypeHandshake = packetType(0x7d)
packetType0RTTProtected = packetType(0x7c)
packetTypeProtectedShort = packetType(0x00) // Not a real type
)
func (pt packetType) isLongHeader() bool {
return pt&packetType(packetFlagLongHeader) != 0
}
func (pt packetType) isProtected() bool |
func (pt packetType) String() string {
switch pt {
case packetTypeInitial:
return "Initial"
case packetTypeRetry:
return "Retry"
case packetTypeHandshake:
return "Handshake"
case packetType0RTTProtected:
return "0-RTT"
case packetTypeProtectedShort:
return "1-RTT"
default:
return fmt.Sprintf("%x", uint8(pt))
}
}
// kCidDefaultLength is the length of connection ID we generate.
// TODO: make this configurable.
const kCidDefaultLength = 5
// ConnectionId identifies the connection that a packet belongs to.
type ConnectionId []byte
// String stringifies a connection ID in the natural way.
func (c ConnectionId) String() string {
return hex.EncodeToString(c)
}
// EncodeLength produces the length encoding used in the long packet header.
func (c ConnectionId) EncodeLength() byte {
if len(c) == 0 {
return 0
}
assert(len(c) >= 4 && len(c) <= 18)
return byte(len(c) - 3)
}
// The PDU definition for the header.
// These types are capitalized so that |codec| can use them.
type packetHeader struct {
// Type is the on-the-wire form of the packet type.
// Consult getHeaderType if you want a value that corresponds to the
// definition of packetType.
Type packetType
Version VersionNumber
ConnectionIDLengths byte
DestinationConnectionID ConnectionId
SourceConnectionID ConnectionId
TokenLength uint8
Token []byte
PayloadLength uint64 `tls:"varint"`
// In order to decode a short header, the length of the connection
// ID must be set in |shortCidLength| before decoding.
shortCidLength uintptr
}
func (p packetHeader) String() string {
ht := "SHORT"
if p.Type.isLongHeader() {
ht = "LONG"
}
return fmt.Sprintf("%s PT=%v", ht, p.getHeaderType())
}
func (p *packetHeader) getHeaderType() packetType {
if p.Type.isLongHeader() {
return p.Type & 0x7f
}
return packetTypeProtectedShort
}
type packet struct {
packetHeader
PacketNumber uint64 // Never more than 32 bits on the wire.
payload []byte
}
// This reads from p.ConnectionIDLengths.
func (p packetHeader) ConnectionIDLengths__length() uintptr {
if p.Type.isLongHeader() {
return 1
}
return 0
}
func (p packetHeader) TokenLength__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return 1
}
func (p packetHeader) Token__length() uintptr {
if p.getHeaderType() != packetTypeInitial {
assert(len(p.Token) == 0)
return 0
}
return uintptr(p.TokenLength)
}
func (p packetHeader) DestinationConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return p.shortCidLength
}
l := p.ConnectionIDLengths >> 4
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) SourceConnectionID__length() uintptr {
if !p.Type.isLongHeader() {
return 0
}
l := p.ConnectionIDLengths & 0xf
if l != 0 {
l += 3
}
return uintptr(l)
}
func (p packetHeader) PayloadLength__length() uintptr {
if p.Type.isLongHeader() {
return codecDefaultSize
}
return 0
}
func (p packetHeader) Version__length() uintptr {
if p.Type.isLongHeader() {
return 4
}
return 0
}
func newPacket(pt packetType, destCid ConnectionId, srcCid ConnectionId, ver VersionNumber, pn uint64, payload []byte, aeadOverhead int) *packet {
if pt == packetTypeProtectedShort {
// Only support writing the 32-bit packet number.
pt = packetType(0x2 | packetFlagShortHeader)
srcCid = nil
} else {
pt = pt | packetType(packetFlagLongHeader)
}
lengths := (destCid.EncodeLength() << 4) | srcCid.EncodeLength()
return &packet{
packetHeader: packetHeader{
Type: pt,
ConnectionIDLengths: lengths,
DestinationConnectionID: destCid,
SourceConnectionID: srcCid,
Version: ver,
PayloadLength: uint64(len(payload) + 4 + aeadOverhead),
},
PacketNumber: pn,
payload: payload,
}
}
type versionNegotiationPacket struct {
Versions []byte
}
func newVersionNegotiationPacket(versions []VersionNumber) *versionNegotiationPacket {
var buf bytes.Buffer
for _, v := range versions {
buf.Write(encodeArgs(v))
}
return &versionNegotiationPacket{buf.Bytes()}
}
/*
We don't use these.
func encodePacket(c ConnectionState, aead Aead, p *Packet) ([]byte, error) {
hdr, err := encode(&p.packetHeader)
if err != nil {
return nil, err
}
b, err := aead.protect(p.packetHeader.PacketNumber, hdr, p.payload)
if err != nil {
return nil, err
}
return encodeArgs(hdr, b), nil
}
func decodePacket(c ConnectionState, aead Aead, b []byte) (*Packet, error) {
// Parse the header
var hdr packetHeader
br, err := decode(&hdr, b)
if err != nil {
return nil, err
}
hdr.PacketNumber = c.expandPacketNumber(hdr.PacketNumber)
pt, err := aead.unprotect(hdr.PacketNumber, b[0:br], b[br:])
if err != nil {
return nil, err
}
return &Packet{hdr, pt}, nil
}
*/
func dumpPacket(payload []byte) string {
first := true
ret := fmt.Sprintf("%d=[", len(payload))
for len(payload) > 0 {
if !first {
ret += ", "
}
first = false
n, f, err := decodeFrame(payload)
if err != nil {
ret += fmt.Sprintf("Undecoded: [%x]", payload)
break
}
payload = payload[n:]
// TODO([email protected]): Not sure why %v doesn't work
ret += f.String()
}
ret += "]"
return ret
}
type pneCipherFactory interface {
create(sample []byte) cipher.Stream
}
type pneCipherFactoryAES struct {
block cipher.Block
| {
if !pt.isLongHeader() {
return true
}
switch pt & 0x7f {
case packetTypeInitial, packetTypeHandshake, packetTypeRetry:
return false
}
return true
} | identifier_body |
TCP_echo_server.py | Error:
search_result = False
except ssl.SSLError:
search_result = False
if search_result:
print('\n用户' + account['username'] + '登陆成功！\n')
writer.write('Login Success'.encode())
await writer.drain()
return True
else:
writer.write('Need Email'.encode())
await writer.drain()
email = await reader.read(1024)
verify_email = re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}(.cn)?$', email.decode())
if verify_email:
email = verify_email.group()
sql = "insert into user(username,password,email) values ('{}','{}','{}')".format(
str(account['username']), str(account['password']), str(email))
try:
cur.execute(sql)
con.commit()
print('\n用户' + account['username'] + '注册成功！\n')
writer.write('Register Success'.encode())
await writer.drain()
return True
except Exception as e:
writer.write('Register Fail'.encode())
await writer.drain()
return False
else:
writer.write('Register Fail'.encode())
await writer.drain()
return False
def creat_server_ssl():
ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_ctx.options |= ssl.OP_NO_TLSv1
ssl_ctx.options |= ssl.OP_NO_TLSv1_1
ssl_ctx.options |= ssl.OP_SINGLE_DH_USE
ssl_ctx.options |= ssl.OP_SINGLE_ECDH_USE
ssl_ctx.load_cert_chain(certfile='./server_ssl/mycertfile.pem', keyfile='./server_ssl/mykeyfile.pem')
ssl_ctx.load_verify_locations(cafile='./server_ssl/mycertfile.pem')
ssl_ctx.check_hostname = False
ssl_ctx.verify_mode = ssl.VerifyMode.CERT_REQUIRED
ssl_ctx.set_ciphers('ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384')
return ssl_ctx
def set_rule(rule_json):
global rule
rule = json.loads(rule_json)
rules.append(rule)
rpc_server.server_close()
return rule_json
def RPC_server(rpc_port):
global rpc_server
# port = 0
rpc_server = SimpleXMLRPCServer(('localhost', rpc_port)) # 初始化
rpc_server.register_function(set_rule, "set_rule") # 注册函数
print("等待RPC规则配置......")
try:
rpc_server.handle_request() # 保持等待调用状态
print('配置完成......')
except OSError:
print('配置完成......')
return rule
async def handle_echo(reader, writer):
client_addr = writer.get_extra_info('peername')
connect_result = await server_authenticate(reader, writer, SECRET_KEY) # 用户合法性验证
if not connect_result:
print('客户端：' + str(client_addr) + '连接失败')
writer.close()
return
try:
login_result = await user_login(reader, writer)
if not login_result:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('已断开用户连接:', client_addr)
writer.close()
return
except ConnectionResetError:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('用户已断开连接:', client_addr)
writer.close()
return
except ssl.SSLError as e:
return
rpc_port = random.randint(49995,50000)
# await asyncio.sleep(0.01)
rpc_port = 12039
# print(rpc_port)
writer.write(str(rpc_port).encode())
await writer.drain()
loop = asyncio.get_running_loop()
with concurrent.futures.ProcessPoolExecutor() as pool:
config_rule = await loop.run_in_executor(pool, RPC_server, rpc_port)
# config_rule = RPC_server()
ident, src_ip, src_port, dst_ip, dst_port = \
config_rule['ident'], config_rule['src_ip'], config_rule['src_port'],config_rule['dst_ip'],config_rule['dst_port'],
# 此处设置要访问的默认服务器
dst_ip = Client_Ip[0]
dst_port = Client_Port[0]
l_reader, l_writer = await asyncio.open_connection(dst_ip, dst_port)
server_addr = l_writer.get_extra_info('peername')
server_addr_str = str(server_addr[0]) + str(server_addr[1])
hold_server_info(server_addr_str, server_addr, l_reader, l_writer) # 将处理目标客户端（服务器）的请求信息存起来
# print(server_list)
try:
# dest_ip = await reader.read(100) # 首先需要得到客户端的请求ip
# dest_ip = dest_ip.decode()
dest_ip = server_addr # 此处设置默认连接server_addr
print('正在请求：' + str(client_addr) + '请求目的ip:' + str(dest_ip))
find_dest = await connect_dest_server(dest_ip, reader, writer, l_reader, l_writer)
if find_dest:
config_rule['ident'] = 'hi'
config_rule_json = json.dumps(config_rule)
writer.write(config_rule_json.encode())
await writer.drain()
# print(config_rule)
s_reader = find_dest['Reader']
s_writer = find_dest['Writer']
while True:
data = await reader.read(100)
message = data.decode()
if message == 'Heart beat!':
writer.write(message.encode())
print('心跳响应' + message)
continue
if message == '' or message == 'exit':
message = 'Disconnect Request'
s_writer.write(message.encode())
await s_writer.drain()
re_msg = await s_reader.read(1024)
if re_msg.decode() == 'ByeBye':
writer.write(re_msg)
await writer.drain()
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('用户已断开连接:', client_addr)
writer.close()
s_writer.close()
break
else:
pass
s_writer.write(data)
await s_writer.drain()
print(str(client_addr) + '正在给' + str(server_addr) + '发送信息：' + data.decode())
try:
re_msg = await s_reader.read(1024)
print('已收到' + str(server_addr) + '的回复：\n' + re_msg.decode())
try:
writer.write(re_msg)
await writer.drain()
print('成功给' + str(client_addr) + '发送回复：\n' + re_msg.decode())
except Exception as e:
print('5',e)
except Exception as e:
print('6',e)
else:
print("请求失败，连接已断开！")
except ConnectionResetError:
message = 'Force Disconnect'
l_writer.write(message.encode())
await l_writer.drain()
l_writer.close()
# user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('用户已断开连接:', client_addr)
writer.close()
except ssl.SSLError as e:
pass
async def get_general_control():
reader, writer = await asyncio.open_connection(Operat_server_IP[0], Operat_server_Port[0])
while True:
cmd = await reader.read(100)
cmd = cmd.decode()
if cmd == '1' or cmd == 'find -all':
user_info = []
for user in user_list:
user_info.append(user_list[user]['addr'])
re_cmd = transfer_json(user_info, True)
writer.write(re_cmd.encode())
await writer.drain()
elif cmd == '2' or cmd == 'break -all':
for user in user_list:
try:
user_writer = user_list[user]['Writer']
user_writer.write('exit'.encode())
await writer.drain()
user_writer.close()
print('已断开用户连接:', user_list[user]['addr'])
except Exception as e:
print('7',e)
user_list.clear()
writer.write('-----全部关闭成功-----'.encode())
await writer.drain()
else:
writer.write('-----命令有误！请重试-----'.encode())
await writer.drain()
async def main():
ssl_server = creat_server_ssl()
server = await asyncio.start_server(handle_echo, Server_Ip[0], Server_Port[0], ssl=ssl_server)
# server.socket返回内部的服务器套接字列表副本
addr = server.sockets[0].getsockname()
print('成功开启服务器:', addr)
print('等待客户端连接...\n')
try:
await get_general_control()
except Exception as e:
print('8',e)
async with server:
# 开始接受连接，直到协程被取消。 serve_forever 任务的取消将导致服务器被关闭。
await server.serve_forever()
def open_agent_server():
asyncio.run(main())
con, cur = create_sqlite_db()
if __name__ == '__main__':
open_agent_server()
| identifier_body |
||
TCP_echo_server.py | _connection.decode(), method=False)
if ensure_connection['code'] == 'Accept connection':
try:
connect_success = {'local_addr': local_addr, 'request_addr': dest_addr, 'code': 'Ready'}
connect_success = transfer_json(connect_success, method=True)
local_writer.write(connect_success.encode())
await local_writer.drain()
print('请求成功：' + str(local_addr) + '正在与' + str(dest_addr) + '通讯...\n')
dest = {'addr': dest_addr, 'Reader': dest_reader, 'Writer': dest_writer}
return dest
except ConnectionResetError:
# print('已断开用户连接:', local_addr)
return False
except Exception as e:
print('0',e)
elif ensure_connection['code'] == 'Refuse connection':
try:
connect_fail = {'local_addr': local_addr, 'request_addr': dest_addr, 'code': 'No'}
connect_fail = transfer_json(connect_fail, method=True)
local_writer.write(connect_fail.encode())
await local_writer.drain()
print('请求失败：' + str(dest_addr) + '拒绝与' + str(local_addr) + '通讯...\n')
dest_writer.close()
local_writer.close()
return False
except Exception as e:
print('1',e)
else:
pass
except Exception as e:
print('2',e)
pass
except Exception as e:
print('3',e)
pass
def hold_user_info(ip, addr, reader, writer):
"""存储已连接客户端的相关内容"""
user = {'addr': addr, 'Reader': reader, 'Writer': writer}
user_list[ip] = user
def hold_server_info(ip, addr, reader, writer):
"""存储已连接目标服务器（客户端）的相关内容"""
user = {'addr': addr, 'Reader': reader, 'Writer': writer}
server_list[ip] = user
async def server_authenticate(reader, writer, secret_key):
"""客户端合法认证"""
message = os.urandom(32) # 随机产生 n=32 个字节的字符串
writer.write(message)
await writer.drain()
s = hashlib.sha512()
s.update(message + secret_key.encode('utf-8')) # 加密
digest = s.hexdigest()
response = await reader.read(1024)
if digest == response.decode('utf-8'):
client_addr = writer.get_extra_info('peername')
client_addr_str = str(client_addr[0]) + str(client_addr[1]) # 拼接ip和port
hold_user_info(client_addr_str, client_addr, reader, writer)
print('\n客户端：' + str(client_addr) + '连接成功\n')
return digest
else:
writer.write('connection_error'.encode()) # 若连接失败，发送错误信息
writer.close()
async def user_login(reader, writer):
global search_result, account
try:
search_result = None
account = await reader.read(1024)
account = transfer_json(account.decode(), False)
sql = "select * from user where username = '{}' and password = '{}'".format(account['username'],
account['password'])
cur.execute(sql)
search_result = cur.fetchall()
except sqlite3.OperationalError:
search_result = False
except ssl.SSLError:
search_result = False
if search_result:
print('\n用户' + account['username'] + '登陆成功！\n')
writer.write('Login Success'.encode())
await writer.drain()
return True
else:
writer.write('Need Email'.encode())
await writer.drain()
email = await reader.read(1024)
verify_email = re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}(.cn)?$', email.decode())
if verify_email:
email = verify_email.group()
sql = "insert into user(username,password,email) values ('{}','{}','{}')".format(
str(account['username']), str(account['password']), str(email))
try:
cur.execute(sql)
con.commit()
print('\n用户' + account['username'] + '注册成功！\n')
writer.write('Register Success'.encode())
await writer.drain()
return True
except Exception as e:
writer.write('Register Fail'.encode())
await writer.drain()
return False
else:
writer.write('Register Fail'.encode())
await writer.drain()
return False
def creat_server_ssl():
ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_ctx.options |= ssl.OP_NO_TLSv1
ssl_ctx.options |= ssl.OP_NO_TLSv1_1
ssl_ctx.options |= ssl.OP_SINGLE_DH_USE
ssl_ctx.options |= ssl.OP_SINGLE_ECDH_USE
ssl_ctx.load_cert_chain(certfile='./server_ssl/mycertfile.pem', keyfile='./server_ssl/mykeyfile.pem')
ssl_ctx.load_verify_locations(cafile='./server_ssl/mycertfile.pem')
ssl_ctx.check_hostname = False
ssl_ctx.verify_mode = ssl.VerifyMode.CERT_REQUIRED
ssl_ctx.set_ciphers('ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384')
return ssl_ctx
def set_rule(rule_json):
global rule
rule = json.loads(rule_json)
rules.append(rule)
rpc_server.server_close()
return rule_json
def RPC_server(rpc_port):
global rpc_server
# port = 0
rpc_server = SimpleXMLRPCServer(('localhost', rpc_port)) # 初始化
rpc_server.register_function(set_rule, "set_rule") # 注册函数
print("等待RPC规则配置......")
try:
rpc_server.handle_request() # 保持等待调用状态
print('配置完成......')
except OSError:
print('配置完成......')
return rule
async def handle_echo(reader, writer):
client_addr = writer.get_extra_info('peername')
connect_result = await server_authenticate(reader, writer, SECRET_KEY) # 用户合法性验证
if not connect_result:
print('客户端：' + str(client_addr) + '连接失败')
writer.close()
return
try:
login_result = await user_login(reader, writer)
if not login_result:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('已断开用户连接:', client_addr)
writer.close()
return
except ConnectionResetError:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('用户已断开连接:', client_addr)
writer.close()
return
except ssl.SSLError as e:
return
rpc_port = random.randint(49995,50000)
# await asyncio.sleep(0.01)
rpc_port = 12039
# print(rpc_port)
writer.write(str(rpc_port).encode())
await writer.drain()
loop = asyncio.get_running_loop()
with concurrent.futures.ProcessPoolExecutor() as pool:
config_rule = await loop.run_in_executor(pool, RPC_server, rpc_port)
# config_rule = RPC_server()
ident, src_ip, src_port, dst_ip, dst_port = \
config_rule['ident'], config_rule['src_ip'], config_rule['src_port'],config_rule['dst_ip'],config_rule['dst_port'],
# 此处设置要访问的默认服务器
dst_ip = Client_Ip[0]
dst_port = Client_Port[0]
l_reader, l_writer = await asyncio.open_connection(dst_ip, dst_port)
server_addr = l_writer.get_extra_info('peername')
server_addr_str = str(server_addr[0]) + str(server_addr[1])
hold_server_info(server_addr_str, server_addr, l_reader, l_writer) # 将处理目标客户端（服务器）的请求信息存起来
# print(server_list)
try:
# dest_ip = await reader.read(100) # 首先需要得到客户端的请求ip
# dest_ip = dest_ip.decode()
dest_ip = server_addr # 此处设置默认连接server_addr |
print('正在请求：' + str(client_addr) + '请求目的ip:' + str(dest_ip))
find_dest = await connect_dest_server(dest_ip, reader, writer, l_reader, l_writer)
if find_dest:
config_rule['ident'] = 'hi'
config_rule_json = json.dumps(config_rule)
writer.write(config_rule_json.encode())
await writer.drain()
# print(config_rule)
s_reader = find_dest['Reader']
s_writer = find_dest['Writer']
while True:
data = await reader.read(100)
message = data.decode()
if message == 'Heart beat!':
writer.write(message.encode())
print('心跳响应' + message)
continue
if message == '' or message == 'exit':
message = 'Disconnect Request'
s_writer.write(message.encode())
await s_writer.drain()
re_msg = await s_reader.read(1024)
| random_line_split |
|
TCP_echo_server.py | .decode(), method=False)
if ensure_connection['code'] == 'Accept connection':
try:
connect_success = {'local_addr': local_addr, 'request_addr': dest_addr, 'code': 'Ready'}
connect_success = transfer_json(connect_success, method=True)
local_writer.write(connect_success.encode())
await local_writer.drain()
print('请求成功：' + str(local_addr) + '正在与' + str(dest_addr) + '通讯...\n')
dest = {'addr': dest_addr, 'Reader': dest_reader, 'Writer': dest_writer}
return dest
except ConnectionResetError:
# print('已断开用户连接:', local_addr)
return False
except Exception as e:
print('0',e)
elif ensure_connection['code'] == 'Refuse connection':
try:
connect_fail = {'local_addr': local_addr, 'request_addr': dest_addr, 'code': 'No'}
connect_fail = transfer_json(connect_fail, method=True)
local_writer.write(connect_fail.encode())
await local_writer.drain()
print('请求失败：' + str(dest_addr) + '拒绝与' + str(local_addr) + '通讯...\n')
dest_writer.close()
local_writer.close()
return False
except Exception as e:
print('1',e)
else:
pass
except Exception as e:
print('2',e)
pass
except Exception as e:
print('3',e)
pass
def hold_user_info(ip, addr, reader, writer):
"""存储已连接客户端的相关内容"""
user = {'addr': addr, 'Reader': reader, 'Writer': writer}
user_list[ip] = user
def hold_server_info(ip, addr, reader, writer):
"""存储已连接目标服务器（客户端）的相关内容"""
user = {'addr': addr, 'Reader': reader, 'Writer': writer}
server_list[ip] = user
async def server_authenticate(reader, writer, secret_key):
"""客户端合法认证"""
message = os.urandom(32) # 随机产生 n=32 个字节的字符串
writer.write(message)
await writer.drain()
s = hashlib.sha512()
s.update(message + secret_key.encode('utf-8')) # 加密
digest = s.hexdigest()
response = await reader.read(1024)
if digest == response.decode('utf-8'):
client_addr = writer.get_extra_info('peername')
client_addr_str = str(client_addr[0]) + str(client_addr[1]) # 拼接ip和port
hold_user_info(client_addr_str, client_addr, reader, writer)
print('\n客户端：' + str(client_addr) + '连接成功\n')
return digest
else:
writer.write('connection_error'.encode()) # 若连接失败，发送错误信息
writer.close()
async def user_login(reader, writer):
global search_result, account
try:
search_result = None
account = await reader.read(1024)
account = transfer_json(account.decode(), False)
sql = "select * from user where username = '{}' and password = '{}'".format(account['username'],
| account['password'])
cur.execute(sql)
search_result = cur.fetchall()
except sqlite3.OperationalError:
search_result = False
except ssl.SSLError:
search_result = False
if search_result:
print('\n用户' + account['username'] + '登陆成功！\n')
writer.write('Login Success'.encode())
await writer.drain()
return True
else:
writer.write('Need Email'.encode())
await writer.drain()
email = await reader.read(1024)
verify_email = re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}(.cn)?$', email.decode())
if verify_email:
email = verify_email.group()
sql = "insert into user(username,password,email) values ('{}','{}','{}')".format(
str(account['username']), str(account['password']), str(email))
try:
cur.execute(sql)
con.commit()
print('\n用户' + account['username'] + '注册成功！\n')
writer.write('Register Success'.encode())
await writer.drain()
return True
except Exception as e:
writer.write('Register Fail'.encode())
await writer.drain()
return False
else:
writer.write('Register Fail'.encode())
await writer.drain()
return False
def creat_server_ssl():
ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_ctx.options |= ssl.OP_NO_TLSv1
ssl_ctx.options |= ssl.OP_NO_TLSv1_1
ssl_ctx.options |= ssl.OP_SINGLE_DH_USE
ssl_ctx.options |= ssl.OP_SINGLE_ECDH_USE
ssl_ctx.load_cert_chain(certfile='./server_ssl/mycertfile.pem', keyfile='./server_ssl/mykeyfile.pem')
ssl_ctx.load_verify_locations(cafile='./server_ssl/mycertfile.pem')
ssl_ctx.check_hostname = False
ssl_ctx.verify_mode = ssl.VerifyMode.CERT_REQUIRED
ssl_ctx.set_ciphers('ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384')
return ssl_ctx
def set_rule(rule_json):
global rule
rule = json.loads(rule_json)
rules.append(rule)
rpc_server.server_close()
return rule_json
def RPC_server(rpc_port):
global rpc_server
# port = 0
rpc_server = SimpleXMLRPCServer(('localhost', rpc_port)) # 初始化
rpc_server.register_function(set_rule, "set_rule") # 注册函数
print("等待RPC规则配置......")
try:
rpc_server.handle_request() # 保持等待调用状态
print('配置完成......')
except OSError:
print('配置完成......')
return rule
async def handle_echo(reader, writer):
client_addr = writer.get_extra_info('peername')
connect_result = await server_authenticate(reader, writer, SECRET_KEY) # 用户合法性验证
if not connect_result:
print('客户端：' + str(client_addr) + '连接失败')
writer.close()
return
try:
login_result = await user_login(reader, writer)
if not login_result:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('已断开用户连接:', client_addr)
writer.close()
return
except ConnectionResetError:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('用户已断开连接:', client_addr)
writer.close()
return
except ssl.SSLError as e:
return
rpc_port = random.randint(49995,50000)
# await asyncio.sleep(0.01)
rpc_port = 12039
# print(rpc_port)
writer.write(str(rpc_port).encode())
await writer.drain()
loop = asyncio.get_running_loop()
with concurrent.futures.ProcessPoolExecutor() as pool:
config_rule = await loop.run_in_executor(pool, RPC_server, rpc_port)
# config_rule = RPC_server()
ident, src_ip, src_port, dst_ip, dst_port = \
config_rule['ident'], config_rule['src_ip'], config_rule['src_port'],config_rule['dst_ip'],config_rule['dst_port'],
# 此处设置要访问的默认服务器
dst_ip = Client_Ip[0]
dst_port = Client_Port[0]
l_reader, l_writer = await asyncio.open_connection(dst_ip, dst_port)
server_addr = l_writer.get_extra_info('peername')
server_addr_str = str(server_addr[0]) + str(server_addr[1])
hold_server_info(server_addr_str, server_addr, l_reader, l_writer) # 将处理目标客户端（服务器）的请求信息存起来
# print(server_list)
try:
# dest_ip = await reader.read(100) # 首先需要得到客户端的请求ip
# dest_ip = dest_ip.decode()
dest_ip = server_addr # 此处设置默认连接server_addr
print('正在请求：' + str(client_addr) + '请求目的ip:' + str(dest_ip))
find_dest = await connect_dest_server(dest_ip, reader, writer, l_reader, l_writer)
if find_dest:
config_rule['ident'] = 'hi'
config_rule_json = json.dumps(config_rule)
writer.write(config_rule_json.encode())
await writer.drain()
# print(config_rule)
s_reader = find_dest['Reader']
s_writer = find_dest['Writer']
while True:
data = await reader.read(100)
message = data.decode()
if message == 'Heart beat!':
writer.write(message.encode())
print('心跳响应' + message)
continue
if message == '' or message == 'exit':
message = 'Disconnect Request'
s_writer.write(message.encode())
await s_writer.drain()
re_msg = await s_reader.read(1024)
| identifier_name |
|
TCP_echo_server.py | (connect_success.encode())
await local_writer.drain()
print('请求成功：' + str(local_addr) + '正在与' + str(dest_addr) + '通讯...\n')
dest = {'addr': dest_addr, 'Reader': dest_reader, 'Writer': dest_writer}
return dest
except ConnectionResetError:
# print('已断开用户连接:', local_addr)
return False
except Exception as e:
print('0',e)
elif ensure_connection['code'] == 'Refuse connection':
try:
connect_fail = {'local_addr': local_addr, 'request_addr': dest_addr, 'code': 'No'}
connect_fail = transfer_json(connect_fail, method=True)
local_writer.write(connect_fail.encode())
await local_writer.drain()
print('请求失败：' + str(dest_addr) + '拒绝与' + str(local_addr) + '通讯...\n')
dest_writer.close()
local_writer.close()
return False
except Exception as e:
print('1',e)
else:
pass
except Exception as e:
print('2',e)
pass
except Exception as e:
print('3',e)
pass
def hold_user_info(ip, addr, reader, writer):
"""存储已连接客户端的相关内容"""
user = {'addr': addr, 'Reader': reader, 'Writer': writer}
user_list[ip] = user
def hold_server_info(ip, addr, reader, writer):
"""存储已连接目标服务器（客户端）的相关内容"""
user = {'addr': addr, 'Reader': reader, 'Writer': writer}
server_list[ip] = user
async def server_authenticate(reader, writer, secret_key):
"""客户端合法认证"""
message = os.urandom(32) # 随机产生 n=32 个字节的字符串
writer.write(message)
await writer.drain()
s = hashlib.sha512()
s.update(message + secret_key.encode('utf-8')) # 加密
digest = s.hexdigest()
response = await reader.read(1024)
if digest == response.decode('utf-8'):
client_addr = writer.get_extra_info('peername')
client_addr_str = str(client_addr[0]) + str(client_addr[1]) # 拼接ip和port
hold_user_info(client_addr_str, client_addr, reader, writer)
print('\n客户端：' + str(client_addr) + '连接成功\n')
return digest
else:
writer.write('connection_error'.encode()) # 若连接失败，发送错误信息
writer.close()
async def user_login(reader, writer):
global search_result, account
try:
search_result = None
account = await reader.read(1024)
account = transfer_json(account.decode(), False)
sql = "select * from user where username = '{}' and password = '{}'".format(account['username'],
account['password'])
cur.execute(sql)
search_result = cur.fetchall()
except sqlite3.OperationalError:
search_result = False
except ssl.SSLError:
search_result = False
if search_result:
print('\n用户' + account['username'] + '登陆成功！\n')
writer.write('Login Success'.encode())
await writer.drain()
return True
else:
writer.write('Need Email'.encode())
await writer.drain()
email = await reader.read(1024)
verify_email = re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}(.cn)?$', email.decode())
if verify_email:
email = verify_email.group()
sql = "insert into user(username,password,email) values ('{}','{}','{}')".format(
str(account['username']), str(account['password']), str(email))
try:
cur.execute(sql)
con.commit()
print('\n用户' + account['username'] + '注册成功！\n')
writer.write('Register Success'.encode())
await writer.drain()
return True
except Exception as e:
writer.write('Register Fail'.encode())
await writer.drain()
return False
else:
writer.write('Register Fail'.encode())
await writer.drain()
return False
def creat_server_ssl():
ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_ctx.options |= ssl.OP_NO_TLSv1
ssl_ctx.options |= ssl.OP_NO_TLSv1_1
ssl_ctx.options |= ssl.OP_SINGLE_DH_USE
ssl_ctx.options |= ssl.OP_SINGLE_ECDH_USE
ssl_ctx.load_cert_chain(certfile='./server_ssl/mycertfile.pem', keyfile='./server_ssl/mykeyfile.pem')
ssl_ctx.load_verify_locations(cafile='./server_ssl/mycertfile.pem')
ssl_ctx.check_hostname = False
ssl_ctx.verify_mode = ssl.VerifyMode.CERT_REQUIRED
ssl_ctx.set_ciphers('ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384')
return ssl_ctx
def set_rule(rule_json):
global rule
rule = json.loads(rule_json)
rules.append(rule)
rpc_server.server_close()
return rule_json
def RPC_server(rpc_port):
global rpc_server
# port = 0
rpc_server = SimpleXMLRPCServer(('localhost', rpc_port)) # 初始化
rpc_server.register_function(set_rule, "set_rule") # 注册函数
print("等待RPC规则配置......")
try:
rpc_server.handle_request() # 保持等待调用状态
print('配置完成......')
except OSError:
print('配置完成......')
return rule
async def handle_echo(reader, writer):
client_addr = writer.get_extra_info('peername')
connect_result = await server_authenticate(reader, writer, SECRET_KEY) # 用户合法性验证
if not connect_result:
print('客户端：' + str(client_addr) + '连接失败')
writer.close()
return
try:
login_result = await user_login(reader, writer)
if not login_result:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('已断开用户连接:', client_addr)
writer.close()
return
except ConnectionResetError:
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
print('用户已断开连接:', client_addr)
writer.close()
return
except ssl.SSLError as e:
return
rpc_port = random.randint(49995,50000)
# await asyncio.sleep(0.01)
rpc_port = 12039
# print(rpc_port)
writer.write(str(rpc_port).encode())
await writer.drain()
loop = asyncio.get_running_loop()
with concurrent.futures.ProcessPoolExecutor() as pool:
config_rule = await loop.run_in_executor(pool, RPC_server, rpc_port)
# config_rule = RPC_server()
ident, src_ip, src_port, dst_ip, dst_port = \
config_rule['ident'], config_rule['src_ip'], config_rule['src_port'],config_rule['dst_ip'],config_rule['dst_port'],
# 此处设置要访问的默认服务器
dst_ip = Client_Ip[0]
dst_port = Client_Port[0]
l_reader, l_writer = await asyncio.open_connection(dst_ip, dst_port)
server_addr = l_writer.get_extra_info('peername')
server_addr_str = str(server_addr[0]) + str(server_addr[1])
hold_server_info(server_addr_str, server_addr, l_reader, l_writer) # 将处理目标客户端（服务器）的请求信息存起来
# print(server_list)
try:
# dest_ip = await reader.read(100) # 首先需要得到客户端的请求ip
# dest_ip = dest_ip.decode()
dest_ip = server_addr # 此处设置默认连接server_addr
print('正在请求：' + str(client_addr) + '请求目的ip:' + str(dest_ip))
find_dest = await connect_dest_server(dest_ip, reader, writer, l_reader, l_writer)
if find_dest:
config_rule['ident'] = 'hi'
config_rule_json = json.dumps(config_rule)
writer.write(config_rule_json.encode())
await writer.drain()
# print(config_rule)
s_reader = find_dest['Reader']
s_writer = find_dest['Writer']
while True:
data = await reader.read(100)
message = data.decode()
if message == 'Heart beat!':
writer.write(message.encode())
print('心跳响应' + message)
continue
if message == '' or message == 'exit':
message = 'Disconnect Request'
s_writer.write(message.encode())
await s_writer.drain()
re_msg = await s_reader.read(1024)
if re_msg.decode() == 'ByeBye':
writer.write(re_msg)
await writer.drain()
user_list.pop(str(client_addr[0]) + str(client_addr[1]))
| print('用户已断开连接:', client_addr)
writer.close()
s_w | conditional_block |
|
localization.rs | .clone()
} else {
let string = fs::read_to_string(&path).unwrap_or_else(|_| {
if (res_id, locale) == ("builtin.ftl", "en-US") {
FALLBACK_STRINGS.to_string()
} else {
error!("missing resouce {}/{}", locale, res_id);
String::new()
}
});
let res = match FluentResource::try_new(string) {
Ok(res) => Arc::new(res),
Err((res, _err)) => Arc::new(res),
};
self.resources.insert(path, res.clone());
res
}
}
/// Return the best localization bundle for the provided `LanguageIdentifier`.
fn get_bundle(&mut self, locale: &LanguageIdentifier, resource_ids: &[String]) -> BundleStack {
let resolved_locales = self.resolve_locales(locale.clone());
debug!("resolved: {}", PrintLocales(resolved_locales.as_slice()));
let mut stack = Vec::new();
for locale in &resolved_locales {
let mut bundle = FluentBundle::new(&resolved_locales);
for res_id in resource_ids {
let res = self.get_resource(&res_id, &locale.to_string());
bundle.add_resource(res).unwrap();
}
stack.push(bundle);
}
BundleStack(stack)
}
/// Given a locale, returns the best set of available locales.
pub(crate) fn resolve_locales(&self, locale: LanguageIdentifier) -> Vec<LanguageIdentifier> {
negotiate_languages(
&[locale],
&self.locales,
Some(&self.default_locale),
NegotiationStrategy::Filtering,
)
.into_iter()
.map(|l| l.to_owned())
.collect()
}
}
impl L10nManager {
/// Create a new localization manager.
///
/// `resources` is a list of file names that contain strings. `base_dir`
/// is a path to a directory that includes per-locale subdirectories.
///
/// This directory should be of the structure `base_dir/{locale}/{resource}`,
/// where '{locale}' is a valid BCP47 language tag, and {resource} is a `.ftl`
/// included in `resources`.
pub fn new(resources: Vec<String>, base_dir: &str) -> Self {
fn get_available_locales(base_dir: &str) -> Result<Vec<LanguageIdentifier>, io::Error> {
let mut locales = vec![];
let res_dir = fs::read_dir(base_dir)?;
for entry in res_dir {
if let Ok(entry) = entry {
let path = entry.path();
if path.is_dir() {
if let Some(name) = path.file_name() {
if let Some(name) = name.to_str() {
let langid: LanguageIdentifier =
name.parse().expect("Parsing failed.");
locales.push(langid);
}
}
}
}
}
Ok(locales)
}
let default_locale: LanguageIdentifier =
"en-US".parse().expect("failed to parse default locale");
let current_locale = Application::get_locale()
.parse()
.unwrap_or_else(|_| default_locale.clone());
let locales = get_available_locales(base_dir).unwrap_or_default();
debug!(
"available locales {}, current {}",
PrintLocales(&locales),
current_locale,
);
let mut path_scheme = base_dir.to_string();
path_scheme.push_str("/{locale}/{res_id}");
let mut res_mgr = ResourceManager {
resources: HashMap::new(),
path_scheme,
default_locale,
locales,
};
let current_bundle = res_mgr.get_bundle(¤t_locale, &resources);
L10nManager {
res_mgr,
current_bundle,
resources,
current_locale,
}
}
/// Fetch a localized string from the current bundle by key.
///
/// In general, this should not be used directly; [`LocalizedString`]
/// should be used for localization, and you should call
/// [`LocalizedString::resolve`] to update the string as required.
///
///[`LocalizedString`]: struct.LocalizedString.html
///[`LocalizedString::resolve`]: struct.LocalizedString.html#method.resolve
pub fn localize<'args>(
&'args self,
key: &str,
args: impl Into<Option<&'args FluentArgs<'args>>>,
) -> Option<String> {
let args = args.into();
let value = match self
.current_bundle
.get_message(key)
.and_then(|msg| msg.value)
{
Some(v) => v,
None => return None,
};
let mut errs = Vec::new();
let result = self
.current_bundle
.format_pattern(key, value, args, &mut errs);
for err in errs {
warn!("localization error {:?}", err);
}
// fluent inserts bidi controls when interpolating, and they can
// cause rendering issues; for now we just strip them.
// https://www.w3.org/International/questions/qa-bidi-unicode-controls#basedirection
const START_ISOLATE: char = '\u{2068}';
const END_ISOLATE: char = '\u{2069}';
if args.is_some() && result.chars().any(|c| c == START_ISOLATE) {
Some(
result
.chars()
.filter(|c| c != &START_ISOLATE && c != &END_ISOLATE)
.collect(),
)
} else {
Some(result)
}
}
//TODO: handle locale change
}
*/ ////
impl<T> LocalizedString<T> {
/// Create a new `LocalizedString` with the given key.
pub const fn new(key: &'static str) -> Self {
LocalizedString {
key,
args: None,
placeholder: None,
resolved: None,
////resolved_lang: None,
}
}
/* ////
/// Add a placeholder value. This will be used if localization fails.
///
/// This is intended for use during prototyping.
pub fn with_placeholder(mut self, placeholder: String) -> Self {
self.placeholder = Some(placeholder);
self
}
*/ ////
/// Return the localized value for this string, or the placeholder, if
/// the localization is missing, or the key if there is no placeholder.
pub fn localized_str(&self) -> &str {
//cortex_m::asm::bkpt(); ////
self.resolved ////
.as_ref()
.expect("not resolved")
.as_str()
/* ////
self.resolved
.as_ref()
.map(|s| s.as_str())
.or_else(|| self.placeholder.as_ref().map(String::as_ref))
.unwrap_or(self.key)
*/ ////
}
}
impl<T: Data> LocalizedString<T> {
/// Add a named argument and a corresponding [`ArgClosure`]. This closure
/// is a function that will return a value for the given key from the current
/// environment and data.
///
/// [`ArgClosure`]: type.ArgClosure.html
pub fn with_arg(
mut self,
key: &'static str,
f: fn(&T, &Env) -> ArgValue, ////
////f: impl Fn(&T, &Env) -> FluentValue<'static> + 'static,
) -> Self {
self.args
.get_or_insert(Vec::new())
.push((key, ArgSource(f)))
.expect("with arg failed"); ////
////.push((key, ArgSource(Arc::new(f))));
self
}
/// Lazily compute the localized value for this string based on the provided
/// environment and data.
///
/// Returns `true` if the current value of the string has changed.
pub fn resolve<'a>(&'a mut self, data: &T, env: &Env) -> bool {
//TODO: this recomputes the string if either the language has changed,
//or *anytime* we have arguments. Ideally we would be using a lens
//to only recompute when our actual data has changed.
if self.args.is_some()
////|| self.resolved_lang.as_ref() != Some(&env.localization_manager().current_locale)
{
//// Resolve all args
let mut args = ArgValues::new();
for arg in self.args.as_ref().expect("resolve fail") {
let (k, v) = arg;
let argvalue = (v.0)(data, env);
args.insert(k, argvalue.clone())
.expect("resolve fail");
//// Convert the first arg to text and exit
self.resolved = Some(argvalue.to_string());
//cortex_m::asm::bkpt(); ////
return true;
}
//// No args to resolve
false
/* ////
let args: Option<FluentArgs> = self
.args
.as_ref()
.map(|a| a.iter().map(|(k, v)| (*k, (v.0)(data, env))).collect());
self.resolved_lang = Some(env.localization_manager().current_locale.clone());
let next = env.localization_manager().localize(self.key, args.as_ref());
let result = next != self.resolved;
self.resolved = next;
result
*/ ////
} else | {
false
} | conditional_block |
|
localization.rs | on things like `Menu`.
/////// A closure that generates a localization value.
type ArgClosure<T> = fn(&T, &Env) -> ArgValue; ////
////type ArgClosure<T> = Arc<dyn Fn(&T, &Env) -> FluentValue<'static> + 'static>;
/// Wraps a closure that generates an argument for localization.
#[derive(Clone)]
struct ArgSource<T>(ArgClosure<T>);
/// A string that can be localized based on the current locale.
///
/// At its simplest, a `LocalizedString` is a key that can be resolved
/// against a map of localized strings for a given locale.
#[derive(Clone)]////
////#[derive(Debug, Clone)]
pub struct LocalizedString<T> {
pub(crate) key: &'static str,
placeholder: Option<String>,
args: Option<Vec<(&'static str, ArgSource<T>)>>,
resolved: Option<String>,
////resolved_lang: Option<LanguageIdentifier>,
}
/* ////
/// A stack of localization resources, used for fallback.
struct BundleStack(Vec<FluentBundle<Arc<FluentResource>>>);
impl BundleStack {
fn get_message(&self, id: &str) -> Option<FluentMessage> {
self.0.iter().flat_map(|b| b.get_message(id)).next()
}
fn format_pattern(
&self,
id: &str,
pattern: &FluentPattern,
args: Option<&FluentArgs>,
errors: &mut Vec<FluentError>,
) -> String {
for bundle in self.0.iter() {
if bundle.has_message(id) {
return bundle.format_pattern(pattern, args, errors).to_string();
}
}
format!("localization failed for key '{}'", id)
}
}
//NOTE: much of this is adapted from https://github.com/projectfluent/fluent-rs/blob/master/fluent-resmgr/src/resource_manager.rs
impl ResourceManager {
/// Loads a new localization resource from disk, as needed.
fn get_resource(&mut self, res_id: &str, locale: &str) -> Arc<FluentResource> {
let path = self
.path_scheme
.replace("{locale}", locale)
.replace("{res_id}", res_id);
if let Some(res) = self.resources.get(&path) {
res.clone()
} else {
let string = fs::read_to_string(&path).unwrap_or_else(|_| {
if (res_id, locale) == ("builtin.ftl", "en-US") {
FALLBACK_STRINGS.to_string()
} else {
error!("missing resouce {}/{}", locale, res_id);
String::new()
}
});
let res = match FluentResource::try_new(string) {
Ok(res) => Arc::new(res),
Err((res, _err)) => Arc::new(res),
};
self.resources.insert(path, res.clone());
res
}
}
/// Return the best localization bundle for the provided `LanguageIdentifier`.
fn get_bundle(&mut self, locale: &LanguageIdentifier, resource_ids: &[String]) -> BundleStack {
let resolved_locales = self.resolve_locales(locale.clone());
debug!("resolved: {}", PrintLocales(resolved_locales.as_slice()));
let mut stack = Vec::new();
for locale in &resolved_locales {
let mut bundle = FluentBundle::new(&resolved_locales);
for res_id in resource_ids {
let res = self.get_resource(&res_id, &locale.to_string());
bundle.add_resource(res).unwrap();
}
stack.push(bundle);
}
BundleStack(stack)
}
/// Given a locale, returns the best set of available locales.
pub(crate) fn resolve_locales(&self, locale: LanguageIdentifier) -> Vec<LanguageIdentifier> {
negotiate_languages(
&[locale],
&self.locales,
Some(&self.default_locale),
NegotiationStrategy::Filtering,
)
.into_iter()
.map(|l| l.to_owned())
.collect()
}
}
impl L10nManager {
/// Create a new localization manager.
///
/// `resources` is a list of file names that contain strings. `base_dir`
/// is a path to a directory that includes per-locale subdirectories.
///
/// This directory should be of the structure `base_dir/{locale}/{resource}`,
/// where '{locale}' is a valid BCP47 language tag, and {resource} is a `.ftl`
/// included in `resources`.
pub fn new(resources: Vec<String>, base_dir: &str) -> Self {
fn get_available_locales(base_dir: &str) -> Result<Vec<LanguageIdentifier>, io::Error> {
let mut locales = vec![];
let res_dir = fs::read_dir(base_dir)?;
for entry in res_dir {
if let Ok(entry) = entry {
let path = entry.path();
if path.is_dir() {
if let Some(name) = path.file_name() {
if let Some(name) = name.to_str() {
let langid: LanguageIdentifier =
name.parse().expect("Parsing failed.");
locales.push(langid);
}
}
}
}
}
Ok(locales)
}
let default_locale: LanguageIdentifier =
"en-US".parse().expect("failed to parse default locale");
let current_locale = Application::get_locale()
.parse()
.unwrap_or_else(|_| default_locale.clone());
let locales = get_available_locales(base_dir).unwrap_or_default();
debug!(
"available locales {}, current {}",
PrintLocales(&locales),
current_locale,
);
let mut path_scheme = base_dir.to_string();
path_scheme.push_str("/{locale}/{res_id}");
let mut res_mgr = ResourceManager {
resources: HashMap::new(),
path_scheme,
default_locale,
locales,
};
let current_bundle = res_mgr.get_bundle(¤t_locale, &resources);
L10nManager {
res_mgr,
current_bundle,
resources,
current_locale,
}
}
/// Fetch a localized string from the current bundle by key.
///
/// In general, this should not be used directly; [`LocalizedString`]
/// should be used for localization, and you should call
/// [`LocalizedString::resolve`] to update the string as required.
///
///[`LocalizedString`]: struct.LocalizedString.html
///[`LocalizedString::resolve`]: struct.LocalizedString.html#method.resolve
pub fn localize<'args>(
&'args self,
key: &str,
args: impl Into<Option<&'args FluentArgs<'args>>>,
) -> Option<String> {
let args = args.into();
let value = match self
.current_bundle
.get_message(key)
.and_then(|msg| msg.value)
{
Some(v) => v,
None => return None,
};
let mut errs = Vec::new();
let result = self
.current_bundle
.format_pattern(key, value, args, &mut errs);
for err in errs {
warn!("localization error {:?}", err);
}
// fluent inserts bidi controls when interpolating, and they can
// cause rendering issues; for now we just strip them.
// https://www.w3.org/International/questions/qa-bidi-unicode-controls#basedirection
const START_ISOLATE: char = '\u{2068}';
const END_ISOLATE: char = '\u{2069}';
if args.is_some() && result.chars().any(|c| c == START_ISOLATE) {
Some(
result
.chars()
.filter(|c| c != &START_ISOLATE && c != &END_ISOLATE)
.collect(),
)
} else {
Some(result)
}
}
//TODO: handle locale change
}
*/ ////
impl<T> LocalizedString<T> {
/// Create a new `LocalizedString` with the given key.
pub const fn new(key: &'static str) -> Self {
LocalizedString {
key,
args: None,
placeholder: None,
resolved: None,
////resolved_lang: None,
}
}
/* ////
/// Add a placeholder value. This will be used if localization fails.
///
/// This is intended for use during prototyping.
pub fn with_placeholder(mut self, placeholder: String) -> Self {
self.placeholder = Some(placeholder);
self
}
*/ ////
/// Return the localized value for this string, or the placeholder, if
/// the localization is missing, or the key if there is no placeholder.
pub fn localized_str(&self) -> &str {
//cortex_m::asm::bkpt(); ////
self.resolved ////
.as_ref()
.expect("not resolved")
.as_str()
/* ////
self.resolved
.as_ref()
.map(|s| s.as_str())
.or_else(|| self.placeholder.as_ref().map(String::as_ref))
.unwrap_or(self.key)
*/ ////
}
}
impl<T: Data> LocalizedString<T> {
/// Add a named argument and a corresponding [`ArgClosure`]. This closure
/// is a function that will return a value for the given key from the current
/// environment and data.
///
/// [`ArgClosure`]: type.ArgClosure.html
pub fn | with_arg | identifier_name |
|
localization.rs | Arg = heapless::consts::U2; //// Max number of localized args
type Vec<T> = heapless::Vec::<T, MaxLocalizedArg>; ///
//////NOTE: instead of a closure, at some point we can use something like a lens for this.
//////TODO: this is an Arc so that it can be clone, which is a bound on things like `Menu`.
/////// A closure that generates a localization value.
type ArgClosure<T> = fn(&T, &Env) -> ArgValue; ////
////type ArgClosure<T> = Arc<dyn Fn(&T, &Env) -> FluentValue<'static> + 'static>;
/// Wraps a closure that generates an argument for localization.
#[derive(Clone)]
struct ArgSource<T>(ArgClosure<T>);
/// A string that can be localized based on the current locale.
///
/// At its simplest, a `LocalizedString` is a key that can be resolved
/// against a map of localized strings for a given locale.
#[derive(Clone)]////
////#[derive(Debug, Clone)]
pub struct LocalizedString<T> {
pub(crate) key: &'static str,
placeholder: Option<String>,
args: Option<Vec<(&'static str, ArgSource<T>)>>,
resolved: Option<String>,
////resolved_lang: Option<LanguageIdentifier>,
}
/* ////
/// A stack of localization resources, used for fallback.
struct BundleStack(Vec<FluentBundle<Arc<FluentResource>>>);
impl BundleStack {
fn get_message(&self, id: &str) -> Option<FluentMessage> {
self.0.iter().flat_map(|b| b.get_message(id)).next()
}
fn format_pattern(
&self,
id: &str,
pattern: &FluentPattern,
args: Option<&FluentArgs>,
errors: &mut Vec<FluentError>,
) -> String {
for bundle in self.0.iter() {
if bundle.has_message(id) {
return bundle.format_pattern(pattern, args, errors).to_string();
}
}
format!("localization failed for key '{}'", id)
}
}
//NOTE: much of this is adapted from https://github.com/projectfluent/fluent-rs/blob/master/fluent-resmgr/src/resource_manager.rs
impl ResourceManager {
/// Loads a new localization resource from disk, as needed.
fn get_resource(&mut self, res_id: &str, locale: &str) -> Arc<FluentResource> {
let path = self
.path_scheme
.replace("{locale}", locale)
.replace("{res_id}", res_id);
if let Some(res) = self.resources.get(&path) {
res.clone()
} else {
let string = fs::read_to_string(&path).unwrap_or_else(|_| {
if (res_id, locale) == ("builtin.ftl", "en-US") {
FALLBACK_STRINGS.to_string()
} else {
error!("missing resouce {}/{}", locale, res_id);
String::new()
}
});
let res = match FluentResource::try_new(string) {
Ok(res) => Arc::new(res),
Err((res, _err)) => Arc::new(res),
};
self.resources.insert(path, res.clone());
res
}
}
/// Return the best localization bundle for the provided `LanguageIdentifier`.
fn get_bundle(&mut self, locale: &LanguageIdentifier, resource_ids: &[String]) -> BundleStack {
let resolved_locales = self.resolve_locales(locale.clone());
debug!("resolved: {}", PrintLocales(resolved_locales.as_slice()));
let mut stack = Vec::new();
for locale in &resolved_locales {
let mut bundle = FluentBundle::new(&resolved_locales);
for res_id in resource_ids {
let res = self.get_resource(&res_id, &locale.to_string());
bundle.add_resource(res).unwrap();
}
stack.push(bundle);
}
BundleStack(stack)
}
/// Given a locale, returns the best set of available locales.
pub(crate) fn resolve_locales(&self, locale: LanguageIdentifier) -> Vec<LanguageIdentifier> {
negotiate_languages(
&[locale],
&self.locales,
Some(&self.default_locale),
NegotiationStrategy::Filtering,
)
.into_iter()
.map(|l| l.to_owned())
.collect()
}
}
impl L10nManager {
/// Create a new localization manager.
///
/// `resources` is a list of file names that contain strings. `base_dir`
/// is a path to a directory that includes per-locale subdirectories.
///
/// This directory should be of the structure `base_dir/{locale}/{resource}`,
/// where '{locale}' is a valid BCP47 language tag, and {resource} is a `.ftl`
/// included in `resources`.
pub fn new(resources: Vec<String>, base_dir: &str) -> Self {
fn get_available_locales(base_dir: &str) -> Result<Vec<LanguageIdentifier>, io::Error> {
let mut locales = vec![];
let res_dir = fs::read_dir(base_dir)?;
for entry in res_dir {
if let Ok(entry) = entry {
let path = entry.path();
if path.is_dir() {
if let Some(name) = path.file_name() {
if let Some(name) = name.to_str() {
let langid: LanguageIdentifier =
name.parse().expect("Parsing failed.");
locales.push(langid);
}
}
}
}
}
Ok(locales)
}
let default_locale: LanguageIdentifier =
"en-US".parse().expect("failed to parse default locale");
let current_locale = Application::get_locale()
.parse()
.unwrap_or_else(|_| default_locale.clone());
let locales = get_available_locales(base_dir).unwrap_or_default();
debug!(
"available locales {}, current {}",
PrintLocales(&locales),
current_locale,
);
let mut path_scheme = base_dir.to_string();
path_scheme.push_str("/{locale}/{res_id}");
let mut res_mgr = ResourceManager {
resources: HashMap::new(),
path_scheme,
default_locale,
locales,
};
let current_bundle = res_mgr.get_bundle(¤t_locale, &resources);
L10nManager {
res_mgr,
current_bundle,
resources,
current_locale,
}
}
/// Fetch a localized string from the current bundle by key.
///
/// In general, this should not be used directly; [`LocalizedString`]
/// should be used for localization, and you should call
/// [`LocalizedString::resolve`] to update the string as required.
///
///[`LocalizedString`]: struct.LocalizedString.html
///[`LocalizedString::resolve`]: struct.LocalizedString.html#method.resolve
pub fn localize<'args>(
&'args self,
key: &str,
args: impl Into<Option<&'args FluentArgs<'args>>>,
) -> Option<String> {
let args = args.into();
let value = match self
.current_bundle
.get_message(key)
.and_then(|msg| msg.value)
{
Some(v) => v,
None => return None,
};
let mut errs = Vec::new();
let result = self
.current_bundle
.format_pattern(key, value, args, &mut errs);
for err in errs {
warn!("localization error {:?}", err);
}
// fluent inserts bidi controls when interpolating, and they can
// cause rendering issues; for now we just strip them.
// https://www.w3.org/International/questions/qa-bidi-unicode-controls#basedirection
const START_ISOLATE: char = '\u{2068}';
const END_ISOLATE: char = '\u{2069}';
if args.is_some() && result.chars().any(|c| c == START_ISOLATE) {
Some(
result
.chars()
.filter(|c| c != &START_ISOLATE && c != &END_ISOLATE)
.collect(),
)
} else {
Some(result)
}
}
//TODO: handle locale change
}
*/ ////
impl<T> LocalizedString<T> {
/// Create a new `LocalizedString` with the given key.
pub const fn new(key: &'static str) -> Self {
LocalizedString {
key,
args: None,
placeholder: None,
resolved: None,
////resolved_lang: None,
}
}
/* ////
/// Add a placeholder value. This will be used if localization fails.
///
/// This is intended for use during prototyping.
pub fn with_placeholder(mut self, placeholder: String) -> Self {
self.placeholder = Some(placeholder);
self
}
*/ ////
/// Return the localized value for this string, or the placeholder, if
/// the localization is missing, or the key if there is no placeholder.
pub fn localized_str(&self) -> &str {
//cortex_m::asm::bkpt(); ////
self.resolved ////
.as_ref()
.expect("not resolved")
.as_str()
/* ////
self.resolved
.as_ref()
.map(|s| s.as_str())
.or_else(|| self.placeholder.as_ref().map(String::as_ref))
.unwrap_or(self.key) | */ //// | random_line_split |
|
localization.rs | "en-US".parse().expect("failed to parse default locale");
let current_locale = Application::get_locale()
.parse()
.unwrap_or_else(|_| default_locale.clone());
let locales = get_available_locales(base_dir).unwrap_or_default();
debug!(
"available locales {}, current {}",
PrintLocales(&locales),
current_locale,
);
let mut path_scheme = base_dir.to_string();
path_scheme.push_str("/{locale}/{res_id}");
let mut res_mgr = ResourceManager {
resources: HashMap::new(),
path_scheme,
default_locale,
locales,
};
let current_bundle = res_mgr.get_bundle(¤t_locale, &resources);
L10nManager {
res_mgr,
current_bundle,
resources,
current_locale,
}
}
/// Fetch a localized string from the current bundle by key.
///
/// In general, this should not be used directly; [`LocalizedString`]
/// should be used for localization, and you should call
/// [`LocalizedString::resolve`] to update the string as required.
///
///[`LocalizedString`]: struct.LocalizedString.html
///[`LocalizedString::resolve`]: struct.LocalizedString.html#method.resolve
pub fn localize<'args>(
&'args self,
key: &str,
args: impl Into<Option<&'args FluentArgs<'args>>>,
) -> Option<String> {
let args = args.into();
let value = match self
.current_bundle
.get_message(key)
.and_then(|msg| msg.value)
{
Some(v) => v,
None => return None,
};
let mut errs = Vec::new();
let result = self
.current_bundle
.format_pattern(key, value, args, &mut errs);
for err in errs {
warn!("localization error {:?}", err);
}
// fluent inserts bidi controls when interpolating, and they can
// cause rendering issues; for now we just strip them.
// https://www.w3.org/International/questions/qa-bidi-unicode-controls#basedirection
const START_ISOLATE: char = '\u{2068}';
const END_ISOLATE: char = '\u{2069}';
if args.is_some() && result.chars().any(|c| c == START_ISOLATE) {
Some(
result
.chars()
.filter(|c| c != &START_ISOLATE && c != &END_ISOLATE)
.collect(),
)
} else {
Some(result)
}
}
//TODO: handle locale change
}
*/ ////
impl<T> LocalizedString<T> {
/// Create a new `LocalizedString` with the given key.
pub const fn new(key: &'static str) -> Self {
LocalizedString {
key,
args: None,
placeholder: None,
resolved: None,
////resolved_lang: None,
}
}
/* ////
/// Add a placeholder value. This will be used if localization fails.
///
/// This is intended for use during prototyping.
pub fn with_placeholder(mut self, placeholder: String) -> Self {
self.placeholder = Some(placeholder);
self
}
*/ ////
/// Return the localized value for this string, or the placeholder, if
/// the localization is missing, or the key if there is no placeholder.
pub fn localized_str(&self) -> &str {
//cortex_m::asm::bkpt(); ////
self.resolved ////
.as_ref()
.expect("not resolved")
.as_str()
/* ////
self.resolved
.as_ref()
.map(|s| s.as_str())
.or_else(|| self.placeholder.as_ref().map(String::as_ref))
.unwrap_or(self.key)
*/ ////
}
}
impl<T: Data> LocalizedString<T> {
/// Add a named argument and a corresponding [`ArgClosure`]. This closure
/// is a function that will return a value for the given key from the current
/// environment and data.
///
/// [`ArgClosure`]: type.ArgClosure.html
pub fn with_arg(
mut self,
key: &'static str,
f: fn(&T, &Env) -> ArgValue, ////
////f: impl Fn(&T, &Env) -> FluentValue<'static> + 'static,
) -> Self {
self.args
.get_or_insert(Vec::new())
.push((key, ArgSource(f)))
.expect("with arg failed"); ////
////.push((key, ArgSource(Arc::new(f))));
self
}
/// Lazily compute the localized value for this string based on the provided
/// environment and data.
///
/// Returns `true` if the current value of the string has changed.
pub fn resolve<'a>(&'a mut self, data: &T, env: &Env) -> bool {
//TODO: this recomputes the string if either the language has changed,
//or *anytime* we have arguments. Ideally we would be using a lens
//to only recompute when our actual data has changed.
if self.args.is_some()
////|| self.resolved_lang.as_ref() != Some(&env.localization_manager().current_locale)
{
//// Resolve all args
let mut args = ArgValues::new();
for arg in self.args.as_ref().expect("resolve fail") {
let (k, v) = arg;
let argvalue = (v.0)(data, env);
args.insert(k, argvalue.clone())
.expect("resolve fail");
//// Convert the first arg to text and exit
self.resolved = Some(argvalue.to_string());
//cortex_m::asm::bkpt(); ////
return true;
}
//// No args to resolve
false
/* ////
let args: Option<FluentArgs> = self
.args
.as_ref()
.map(|a| a.iter().map(|(k, v)| (*k, (v.0)(data, env))).collect());
self.resolved_lang = Some(env.localization_manager().current_locale.clone());
let next = env.localization_manager().localize(self.key, args.as_ref());
let result = next != self.resolved;
self.resolved = next;
result
*/ ////
} else {
false
}
}
}
/* ////
impl<T> std::fmt::Debug for ArgSource<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "Arg Resolver {:p}", self.0)
}
}
/// Helper to impl display for slices of displayable things.
struct PrintLocales<'a, T>(&'a [T]);
impl<'a, T: std::fmt::Display> std::fmt::Display for PrintLocales<'a, T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "[")?;
let mut prev = false;
for l in self.0 {
if prev {
write!(f, ", ")?;
}
prev = true;
write!(f, "{}", l)?;
}
write!(f, "]")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolve() {
let en_us: LanguageIdentifier = "en-US".parse().unwrap();
let en_ca: LanguageIdentifier = "en-CA".parse().unwrap();
let en_gb: LanguageIdentifier = "en-GB".parse().unwrap();
let fr_fr: LanguageIdentifier = "fr-FR".parse().unwrap();
let pt_pt: LanguageIdentifier = "pt-PT".parse().unwrap();
let resmgr = ResourceManager {
resources: HashMap::new(),
locales: vec![en_us.clone(), en_ca.clone(), en_gb.clone(), fr_fr.clone()],
default_locale: en_us.clone(),
path_scheme: String::new(),
};
let en_za: LanguageIdentifier = "en-GB".parse().unwrap();
let cn_hk: LanguageIdentifier = "cn-HK".parse().unwrap();
let fr_ca: LanguageIdentifier = "fr-CA".parse().unwrap();
assert_eq!(
resmgr.resolve_locales(en_ca.clone()),
vec![en_ca.clone(), en_us.clone(), en_gb.clone()]
);
assert_eq!(
resmgr.resolve_locales(en_za.clone()),
vec![en_gb.clone(), en_us.clone(), en_ca.clone()]
);
assert_eq!(
resmgr.resolve_locales(fr_ca.clone()),
vec![fr_fr.clone(), en_us.clone()]
);
assert_eq!(
resmgr.resolve_locales(fr_fr.clone()),
vec![fr_fr.clone(), en_us.clone()]
);
assert_eq!(resmgr.resolve_locales(cn_hk), vec![en_us.clone()]);
assert_eq!(resmgr.resolve_locales(pt_pt), vec![en_us.clone()]);
}
}
*/ ////
/// Implement formatted output for ArgSource
impl<T> core::fmt::Debug for ArgSource<T> { ////
fn fmt(&self, _fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result | {
// TODO
Ok(())
} | identifier_body |
|
cardano_wallet.d.ts | {Uint8Array} salt
* @param {Uint8Array} nonce
* @param {Uint8Array} data
* @returns {any}
*/
export function password_encrypt(password: string, salt: Uint8Array, nonce: Uint8Array, data: Uint8Array): any;
/**
* decrypt the data with the password
*
* @param {string} password
* @param {Uint8Array} encrypted_data
* @returns {any}
*/
export function password_decrypt(password: string, encrypted_data: Uint8Array): any;
/**
*/
export class AccountIndex {
free(): void;
static new(index: number): AccountIndex;
}
/**
*/
export class Address {
free(): void;
to_base58(): string;
static from_base58(s: string): Address;
}
/**
*/
export class AddressKeyIndex {
free(): void;
static new(index: number): AddressKeyIndex;
}
/**
*/
export class Bip44AccountPrivate {
free(): void;
static new(key: PrivateKey, derivation_scheme: DerivationScheme): Bip44AccountPrivate;
public(): Bip44AccountPublic;
address_key(internal: boolean, index: AddressKeyIndex): PrivateKey;
key(): PrivateKey;
}
/**
*/
export class Bip44AccountPublic {
free(): void;
static new(key: PublicKey, derivation_scheme: DerivationScheme): Bip44AccountPublic;
address_key(internal: boolean, index: AddressKeyIndex): PublicKey;
key(): PublicKey;
}
/**
* Root Private Key of a BIP44 HD Wallet
*/
export class Bip44RootPrivateKey {
free(): void;
static new(key: PrivateKey, derivation_scheme: DerivationScheme): Bip44RootPrivateKey;
static recover(entropy: Entropy, password: string): Bip44RootPrivateKey;
bip44_account(index: AccountIndex): Bip44AccountPrivate;
key(): PrivateKey;
}
/**
* setting of the blockchain
*
* This includes the `ProtocolMagic` a discriminant value to differentiate
* different instances of the cardano blockchain (Mainnet, Testnet... ).
*/
export class BlockchainSettings {
free(): void;
to_json(): any;
static from_json(value: any): BlockchainSettings;
static mainnet(): BlockchainSettings;
}
/**
*/
export class Coin {
free(): void;
constructor();
static from_str(s: string): Coin;
to_str(): string;
static from(ada: number, lovelace: number): Coin;
ada(): number;
lovelace(): number;
add(other: Coin): Coin;
}
/**
*/
export class CoinDiff {
free(): void;
is_zero(): boolean;
is_negative(): boolean;
is_positive(): boolean;
value(): Coin;
}
/**
*/
export class DaedalusAddressChecker {
free(): void;
static new(wallet: DaedalusWallet): DaedalusAddressChecker;
check_address(address: Address): DaedalusCheckedAddress;
}
/**
* result value of the check_address function of the DaedalusAddressChecker.
*
* If the address passed to check_address was recognised by the daedalus wallet
* then this object will contain the private key associated to this wallet
* private key necessary to sign transactions
*/
export class DaedalusCheckedAddress {
free(): void;
is_checked(): boolean;
private_key(): PrivateKey;
}
/**
*/
export class DaedalusWallet {
free(): void;
static new(key: PrivateKey): DaedalusWallet;
static recover(entropy: Entropy): DaedalusWallet;
}
/**
* There is a special function to use when deriving Addresses. This function
* has been revised to offer stronger properties. This is why there is a
* V2 derivation scheme. The V1 being the legacy one still used in daedalus
* now a days.
*
* It is strongly advised to use V2 as the V1 is deprecated since April 2018.
* Its support is already provided for backward compatibility with old
* addresses.
*/
export class DerivationScheme {
free(): void;
static v1(): DerivationScheme;
static v2(): DerivationScheme;
}
/**
* the entropy associated to mnemonics. This is a bytes representation of the
* mnemonics the user has to remember how to generate the root key of an
* HD Wallet.
*
* TODO: interface to generate a new entropy
*
* # Security considerations
*
* * do not store this value without encrypting it;
* * do not leak the mnemonics;
* * make sure the user remembers the mnemonics string;
*
*/
export class Entropy {
free(): void;
static from_english_mnemonics(mnemonics: string): Entropy;
to_english_mnemonics(): string;
to_array(): any;
}
/**
*/
export class InputSelectionBuilder {
free(): void;
static first_match_first(): InputSelectionBuilder;
static largest_first(): InputSelectionBuilder;
static blackjack(dust_threshold: Coin): InputSelectionBuilder;
add_input(tx_input: TxInput): void;
add_output(output: TxOut): void;
select_inputs(fee_algorithm: LinearFeeAlgorithm, output_policy: OutputPolicy): InputSelectionResult;
}
/**
*/
export class InputSelectionResult {
free(): void;
is_input(txo_pointer: TxoPointer): boolean;
estimated_fees(): Coin;
estimated_change(): Coin;
}
/**
* This is the linear fee algorithm used buy the current cardano blockchain.
*
* However it is possible the linear fee algorithm may change its settings:
*
* It is currently a function `fee(n) = a * x + b`. `a` and `b` can be
* re-configured by a protocol update. Users of this object need to be aware
* that it may change and that they might need to update its settings.
*
*/
export class LinearFeeAlgorithm {
free(): void;
static default(): LinearFeeAlgorithm;
}
/**
* This is the Output policy for automatic Input selection.
*/
export class OutputPolicy {
free(): void;
static change_to_one_address(address: Address): OutputPolicy;
}
/**
* A given private key. You can use this key to sign transactions.
*
* # security considerations
*
* * do not store this key without encrypting it;
* * if leaked anyone can _spend_ a UTxO (Unspent Transaction Output)
* with it;
*
*/
export class PrivateKey {
free(): void;
static new(entropy: Entropy, password: string): PrivateKey;
static from_hex(hex: string): PrivateKey;
to_hex(): string;
public(): PublicKey;
sign(data: Uint8Array): Signature;
derive(derivation_scheme: DerivationScheme, index: number): PrivateKey;
}
/**
*/
export class PrivateRedeemKey {
free(): void;
static from_bytes(bytes: Uint8Array): PrivateRedeemKey;
static from_hex(hex: string): PrivateRedeemKey;
to_hex(): string;
public(): PublicRedeemKey;
sign(data: Uint8Array): RedeemSignature;
}
/**
* The public key associated to a given private key.
*
* It is not possible to sign (and then spend) with a private key.
* However it is possible to verify a Signature.
*
* # Security Consideration
*
* * it is rather harmless to leak a public key, in the worst case
* only the privacy is leaked;
*
*/
export class PublicKey {
free(): void;
static from_hex(hex: string): PublicKey;
to_hex(): string;
verify(data: Uint8Array, signature: Signature): boolean;
derive(derivation_scheme: DerivationScheme, index: number): PublicKey;
bootstrap_era_address(blockchain_settings: BlockchainSettings): Address;
}
/**
*/
export class | {
free(): void;
static from_hex(hex: string): PublicRedeemKey;
to_hex(): string;
verify(data: Uint8Array, signature: RedeemSignature): boolean;
address(settings: BlockchainSettings): Address;
}
/**
*/
export class RedeemSignature {
free(): void;
static from_hex(hex: string): RedeemSignature;
to_hex(): string;
}
/**
*/
export class Signature {
free(): void;
static from_hex(hex: string): Signature;
to_hex(): string;
}
/**
* a signed transaction, ready to be sent to the network.
*/
export class SignedTransaction {
free(): void;
id(): string;
to_json(): any;
static from_bytes(bytes: Uint8Array): SignedTransaction;
to_hex(): string;
}
/**
* a transaction type, this is not ready for sending to the network. It is only an
* intermediate type to use between the transaction builder and the transaction
* finalizer. It allows separation of concerns:
*
* 1. build the transaction on one side/thread/machine/...;
* 2. sign the transaction on the other/thread/machines/cold-wallet...;
*
*/
export class Transaction {
free(): void;
id(): TransactionId;
to_json(): any;
to_hex(): string;
}
/**
* The transaction builder provides a set of tools to help build
* a valid Transaction.
*/
export class TransactionBuilder {
free(): void;
constructor();
add_input(txo_pointer: TxoPointer, value: Coin): void;
get_input_total(): Coin;
add_output(output: TxOut): void;
apply_output_policy(fee_algorithm: LinearFeeAlgorithm, policy: OutputPolicy): any;
get_output_total(): | PublicRedeemKey | identifier_name |
cardano_wallet.d.ts | {Uint8Array} salt
* @param {Uint8Array} nonce
* @param {Uint8Array} data
* @returns {any}
*/
export function password_encrypt(password: string, salt: Uint8Array, nonce: Uint8Array, data: Uint8Array): any;
/**
* decrypt the data with the password
*
* @param {string} password
* @param {Uint8Array} encrypted_data
* @returns {any}
*/
export function password_decrypt(password: string, encrypted_data: Uint8Array): any;
/**
*/
export class AccountIndex {
free(): void;
static new(index: number): AccountIndex;
}
/**
*/
export class Address {
free(): void;
to_base58(): string;
static from_base58(s: string): Address;
}
/**
*/
export class AddressKeyIndex {
free(): void;
static new(index: number): AddressKeyIndex;
}
/**
*/
export class Bip44AccountPrivate {
free(): void;
static new(key: PrivateKey, derivation_scheme: DerivationScheme): Bip44AccountPrivate;
public(): Bip44AccountPublic;
address_key(internal: boolean, index: AddressKeyIndex): PrivateKey;
key(): PrivateKey;
}
/**
*/
export class Bip44AccountPublic {
free(): void;
static new(key: PublicKey, derivation_scheme: DerivationScheme): Bip44AccountPublic;
address_key(internal: boolean, index: AddressKeyIndex): PublicKey;
key(): PublicKey;
}
/**
* Root Private Key of a BIP44 HD Wallet
*/
export class Bip44RootPrivateKey {
free(): void;
static new(key: PrivateKey, derivation_scheme: DerivationScheme): Bip44RootPrivateKey;
static recover(entropy: Entropy, password: string): Bip44RootPrivateKey;
bip44_account(index: AccountIndex): Bip44AccountPrivate;
key(): PrivateKey;
}
/**
* setting of the blockchain
*
* This includes the `ProtocolMagic` a discriminant value to differentiate
* different instances of the cardano blockchain (Mainnet, Testnet... ).
*/
export class BlockchainSettings {
free(): void;
to_json(): any;
static from_json(value: any): BlockchainSettings;
static mainnet(): BlockchainSettings;
}
/**
*/
export class Coin {
free(): void;
constructor();
static from_str(s: string): Coin;
to_str(): string;
static from(ada: number, lovelace: number): Coin;
ada(): number;
lovelace(): number;
add(other: Coin): Coin;
}
/**
*/
export class CoinDiff {
free(): void;
is_zero(): boolean;
is_negative(): boolean;
is_positive(): boolean;
value(): Coin;
}
/**
*/
export class DaedalusAddressChecker {
free(): void;
static new(wallet: DaedalusWallet): DaedalusAddressChecker;
check_address(address: Address): DaedalusCheckedAddress;
}
/**
* result value of the check_address function of the DaedalusAddressChecker.
*
* If the address passed to check_address was recognised by the daedalus wallet
* then this object will contain the private key associated to this wallet
* private key necessary to sign transactions
*/
export class DaedalusCheckedAddress {
free(): void;
is_checked(): boolean;
private_key(): PrivateKey;
}
/**
*/
export class DaedalusWallet {
free(): void;
static new(key: PrivateKey): DaedalusWallet;
static recover(entropy: Entropy): DaedalusWallet;
}
/**
* There is a special function to use when deriving Addresses. This function
* has been revised to offer stronger properties. This is why there is a
* V2 derivation scheme. The V1 being the legacy one still used in daedalus
* now a days.
*
* It is strongly advised to use V2 as the V1 is deprecated since April 2018.
* Its support is already provided for backward compatibility with old
* addresses.
*/
export class DerivationScheme {
free(): void;
static v1(): DerivationScheme;
static v2(): DerivationScheme;
}
/**
* the entropy associated to mnemonics. This is a bytes representation of the
* mnemonics the user has to remember how to generate the root key of an
* HD Wallet.
*
* TODO: interface to generate a new entropy
*
* # Security considerations
*
* * do not store this value without encrypting it;
* * do not leak the mnemonics;
* * make sure the user remembers the mnemonics string;
* | export class Entropy {
free(): void;
static from_english_mnemonics(mnemonics: string): Entropy;
to_english_mnemonics(): string;
to_array(): any;
}
/**
*/
export class InputSelectionBuilder {
free(): void;
static first_match_first(): InputSelectionBuilder;
static largest_first(): InputSelectionBuilder;
static blackjack(dust_threshold: Coin): InputSelectionBuilder;
add_input(tx_input: TxInput): void;
add_output(output: TxOut): void;
select_inputs(fee_algorithm: LinearFeeAlgorithm, output_policy: OutputPolicy): InputSelectionResult;
}
/**
*/
export class InputSelectionResult {
free(): void;
is_input(txo_pointer: TxoPointer): boolean;
estimated_fees(): Coin;
estimated_change(): Coin;
}
/**
* This is the linear fee algorithm used buy the current cardano blockchain.
*
* However it is possible the linear fee algorithm may change its settings:
*
* It is currently a function `fee(n) = a * x + b`. `a` and `b` can be
* re-configured by a protocol update. Users of this object need to be aware
* that it may change and that they might need to update its settings.
*
*/
export class LinearFeeAlgorithm {
free(): void;
static default(): LinearFeeAlgorithm;
}
/**
* This is the Output policy for automatic Input selection.
*/
export class OutputPolicy {
free(): void;
static change_to_one_address(address: Address): OutputPolicy;
}
/**
* A given private key. You can use this key to sign transactions.
*
* # security considerations
*
* * do not store this key without encrypting it;
* * if leaked anyone can _spend_ a UTxO (Unspent Transaction Output)
* with it;
*
*/
export class PrivateKey {
free(): void;
static new(entropy: Entropy, password: string): PrivateKey;
static from_hex(hex: string): PrivateKey;
to_hex(): string;
public(): PublicKey;
sign(data: Uint8Array): Signature;
derive(derivation_scheme: DerivationScheme, index: number): PrivateKey;
}
/**
*/
export class PrivateRedeemKey {
free(): void;
static from_bytes(bytes: Uint8Array): PrivateRedeemKey;
static from_hex(hex: string): PrivateRedeemKey;
to_hex(): string;
public(): PublicRedeemKey;
sign(data: Uint8Array): RedeemSignature;
}
/**
* The public key associated to a given private key.
*
* It is not possible to sign (and then spend) with a private key.
* However it is possible to verify a Signature.
*
* # Security Consideration
*
* * it is rather harmless to leak a public key, in the worst case
* only the privacy is leaked;
*
*/
export class PublicKey {
free(): void;
static from_hex(hex: string): PublicKey;
to_hex(): string;
verify(data: Uint8Array, signature: Signature): boolean;
derive(derivation_scheme: DerivationScheme, index: number): PublicKey;
bootstrap_era_address(blockchain_settings: BlockchainSettings): Address;
}
/**
*/
export class PublicRedeemKey {
free(): void;
static from_hex(hex: string): PublicRedeemKey;
to_hex(): string;
verify(data: Uint8Array, signature: RedeemSignature): boolean;
address(settings: BlockchainSettings): Address;
}
/**
*/
export class RedeemSignature {
free(): void;
static from_hex(hex: string): RedeemSignature;
to_hex(): string;
}
/**
*/
export class Signature {
free(): void;
static from_hex(hex: string): Signature;
to_hex(): string;
}
/**
* a signed transaction, ready to be sent to the network.
*/
export class SignedTransaction {
free(): void;
id(): string;
to_json(): any;
static from_bytes(bytes: Uint8Array): SignedTransaction;
to_hex(): string;
}
/**
* a transaction type, this is not ready for sending to the network. It is only an
* intermediate type to use between the transaction builder and the transaction
* finalizer. It allows separation of concerns:
*
* 1. build the transaction on one side/thread/machine/...;
* 2. sign the transaction on the other/thread/machines/cold-wallet...;
*
*/
export class Transaction {
free(): void;
id(): TransactionId;
to_json(): any;
to_hex(): string;
}
/**
* The transaction builder provides a set of tools to help build
* a valid Transaction.
*/
export class TransactionBuilder {
free(): void;
constructor();
add_input(txo_pointer: TxoPointer, value: Coin): void;
get_input_total(): Coin;
add_output(output: TxOut): void;
apply_output_policy(fee_algorithm: LinearFeeAlgorithm, policy: OutputPolicy): any;
get_output_total(): Coin | */ | random_line_split |
Upload.js | 500);
}
async readFile(inputFile) {
let readTheData = (ifile, method)=>{
return new Promise((res, rej)=>{
let reader = new FileReader();
reader.onload = (e)=>{
res(e.target.result);
}
reader.onerror = (e)=>{
rej(e);
}
reader.onabort = ()=>{
rej();
}
reader[method](ifile);
});
};
let dims = (ifile)=>{
return new Promise((res,rej)=>{
const img = new Image();
img.onload = function () {
res([this.width, this.height]);
};
img.onerror = function() {
res([100,100]); // ???
};
img.src = ifile.dataURL;
});
};
try {
let ab = await readTheData(inputFile, 'readAsArrayBuffer');
let filename = (''+inputFile.name) || 'undefined';
let ext = (filename.lastIndexOf('.') != -1) ? (filename.substr(filename.lastIndexOf('.') + 1)).toLowerCase() : '';
let fileData = {
ab: ab,
name: inputFile.name,
size: inputFile.size,
filename: filename,
ext: ext,
type: 'doc',
aspectRatio: 1,
};
// nice one. https://stackoverflow.com/a/20732091/1119169 thanks Andrew!
const sizeI = Math.floor( Math.log(fileData.size) / Math.log(1024) );
fileData.sizeHuman = ( fileData.size / Math.pow(1024, sizeI) ).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][sizeI];
fileData.color = ((''+ext+' ').charCodeAt(0) % 8 + 1);
fileData.random = (''+Math.random()).split('.').join('');
let photoExts = ['png', 'jpg', 'jpeg'];
let videoExts = ['mp4', 'mpeg', 'avi', 'mov'];
if (photoExts.indexOf(ext) != -1 && this._uploadingMedia) {
fileData.type = 'photo';
} else if (videoExts.indexOf(ext) != -1 && this._uploadingMedia) {
fileData.type = 'video';
}
if (fileData.type == 'photo') {
// let dataURL = await readTheData(inputFile, 'readAsDataURL'); // ? URL.createObjectURL(file);
fileData.dataURL = URL.createObjectURL(inputFile);
[fileData.width, fileData.height] = await dims(fileData); // parallelize?
} else if (fileData.type == 'video') {
fileData.width = 100;
fileData.height = 100;
}
this._files.push(fileData);
return fileData;
} catch(e) {
// console.log(e);
return false;
}
}
loaded() {
// console.error(this._files);
this.updateTitle();
this.generateUploadPreview();
}
updateTitle() {
let suffix = {
doc: 'File',
video: 'Video',
photo: 'Photo',
};
let title = 'Send '+( (this._files.length > 1) ? this._files.length : '' ) + ' ' + suffix[this._files[0].type] + ( (this._files.length > 1) ? 's' : '' );
this.$('.uploadTitle').innerHTML = title;
}
onAlbumClick(e) {
const base = this.$();
let closest = event.target.closest('.upiRemove');
if (closest && base.contains(closest)) {
const el = closest.parentElement;
if (el) {
const id = el.id.split('uploadPreviewItem_').join('');
let ri = null;
for (let i = 0; i < this._files.length; i++) {
if (this._files[i].random == id) {
ri = i;
}
}
if (ri !== null) {
this._files.splice(ri, 1);
el.remove();
if (!this._files.length) {
this.hide();
} else {
this.doCalcs();
this.updateTitle();
}
}
}
}
}
doCalcs() {
this._layouter = new Layouter(this._files, {maxWidth: 384});
this._files = this._layouter.layout();
for (let file of this._files) {
const el = this.$('#uploadPreviewItem_'+file.random);
if (el) |
}
this.$('#uploadPreviewAlbum').style.height = this._layouter._height+'px';
this.initScrollBarOn(this.$('.uploadPreview'));
}
swapItems(id1, id2) {
if (id1 == id2) {
return;
}
id1 = id1.split('uploadPreviewItem_').join('');
id2 = id2.split('uploadPreviewItem_').join('');
let toMove1 = null;
let i1 = null;
let toMove2 = null;
let i2 = null;
// let insertBeforeI = null;
for (let i = 0; i < this._files.length; i++) {
if (this._files[i].random == id1) {
toMove1 = this._files[i];
i1 = i;
}
if (this._files[i].random == id2) {
toMove2 = this._files[i];
i2 = i;
}
}
this._files[i1] = toMove2;
this._files[i2] = toMove1;
this.doCalcs();
}
async generateVideoPreview(file, tryToSliceLength) {
let respAB = file.ab;
if (tryToSliceLength) {
respAB = file.ab.slice(0, tryToSliceLength);
}
let response = new Response(
respAB,
{
status: 206,
statusText: 'Partial Content',
headers: [
['Content-Type', 'video/mp4'],
['Content-Length', file.ab.byteLength],
['Content-Range', '0-'+(respAB.byteLength - 1)+'/'+file.ab.byteLength ]]
});
let blob = await response.blob();
let blobUrl = URL.createObjectURL(blob);
let promise = new Promise((res, rej)=>{
let video = document.createElement('video');
video.addEventListener('error', function(event) {
rej();
}, true);
video.onloadeddata = (event) => {
let width = video.videoWidth;
let height = video.videoHeight;
let canvas = document.createElement('canvas');
canvas.width = width;
canvas.height = height;
file.aspectRatio = (height ? (width/height) : 1);
file.width = width;
file.height = height;
this.doCalcs();
let ctx = canvas.getContext("2d");
ctx.imageSmoothingEnabled = true;
ctx.drawImage(video, 0, 0, width, height);
let blankCanvas = document.createElement('canvas');
blankCanvas.width = width;
blankCanvas.height = height;
if (canvas.toDataURL() == blankCanvas.toDataURL()) {
rej();
}
canvas.toBlob((canvasBlob)=>{
let canvasBlobUrl = URL.createObjectURL(canvasBlob);
res(canvasBlobUrl);
});
};
video.preload = 'metadata';
video.src = blobUrl;
// Load video in Safari / IE11
video.muted = true;
video.playsInline = true;
video.play();
});
return await promise;
}
generateUploadPreviewForFile(file) {
const closeHTML = this._components.CloseIcon.render({noDOM: true});
if (file.type == 'photo') {
return '<div class="uploadPreviewItem" draggable="true" id="uploadPreviewItem_'+file.random+'" style="background-image: url(\''+file.dataURL+'\'); '+file.style+'"><div class="upiRemove">'+closeHTML+'</div></div>';
} else if (file.type == 'video') {
return '<div class="uploadPreviewItem" draggable="true" id="uploadPreviewItem_'+file.random+'" style="border: 1px solid #eee;"><div class="upiRemove">'+closeHTML+'</div></div>';
} else if (file.type == 'doc') {
return `<div class="uploadDocItem">
<div class="rsDoc">
<div class="rsDocIcon avatarC${file.color}">${file.ext}</div>
<div class="rsDocName">${file.filename}</div>
<div class="rsDocMeta">${file.sizeHuman}</div>
</div>
</div>`;
}
| {
el.style.left = '' + file.pos.left + 'px';
el.style.top = '' + file.pos.top + 'px';
el.style.width = '' + file.pos.width + 'px';
el.style.height = '' + file.pos.height + 'px';
} | conditional_block |
Upload.js | 500);
}
async readFile(inputFile) {
let readTheData = (ifile, method)=>{
return new Promise((res, rej)=>{
let reader = new FileReader();
reader.onload = (e)=>{
res(e.target.result);
}
reader.onerror = (e)=>{
rej(e);
}
reader.onabort = ()=>{
rej();
}
reader[method](ifile);
});
};
let dims = (ifile)=>{
return new Promise((res,rej)=>{
const img = new Image();
img.onload = function () {
res([this.width, this.height]);
};
img.onerror = function() {
res([100,100]); // ???
};
img.src = ifile.dataURL;
});
};
try {
let ab = await readTheData(inputFile, 'readAsArrayBuffer');
let filename = (''+inputFile.name) || 'undefined';
let ext = (filename.lastIndexOf('.') != -1) ? (filename.substr(filename.lastIndexOf('.') + 1)).toLowerCase() : '';
let fileData = {
ab: ab,
name: inputFile.name,
size: inputFile.size,
filename: filename,
ext: ext,
type: 'doc',
aspectRatio: 1,
};
// nice one. https://stackoverflow.com/a/20732091/1119169 thanks Andrew!
const sizeI = Math.floor( Math.log(fileData.size) / Math.log(1024) );
fileData.sizeHuman = ( fileData.size / Math.pow(1024, sizeI) ).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][sizeI];
fileData.color = ((''+ext+' ').charCodeAt(0) % 8 + 1);
fileData.random = (''+Math.random()).split('.').join('');
let photoExts = ['png', 'jpg', 'jpeg'];
let videoExts = ['mp4', 'mpeg', 'avi', 'mov'];
if (photoExts.indexOf(ext) != -1 && this._uploadingMedia) {
fileData.type = 'photo';
} else if (videoExts.indexOf(ext) != -1 && this._uploadingMedia) {
fileData.type = 'video';
}
if (fileData.type == 'photo') {
// let dataURL = await readTheData(inputFile, 'readAsDataURL'); // ? URL.createObjectURL(file);
fileData.dataURL = URL.createObjectURL(inputFile);
[fileData.width, fileData.height] = await dims(fileData); // parallelize?
} else if (fileData.type == 'video') {
fileData.width = 100;
fileData.height = 100;
}
this._files.push(fileData);
return fileData;
} catch(e) {
// console.log(e);
return false;
}
}
loaded() {
// console.error(this._files);
this.updateTitle();
this.generateUploadPreview();
}
updateTitle() {
let suffix = {
doc: 'File',
video: 'Video',
photo: 'Photo', | let title = 'Send '+( (this._files.length > 1) ? this._files.length : '' ) + ' ' + suffix[this._files[0].type] + ( (this._files.length > 1) ? 's' : '' );
this.$('.uploadTitle').innerHTML = title;
}
onAlbumClick(e) {
const base = this.$();
let closest = event.target.closest('.upiRemove');
if (closest && base.contains(closest)) {
const el = closest.parentElement;
if (el) {
const id = el.id.split('uploadPreviewItem_').join('');
let ri = null;
for (let i = 0; i < this._files.length; i++) {
if (this._files[i].random == id) {
ri = i;
}
}
if (ri !== null) {
this._files.splice(ri, 1);
el.remove();
if (!this._files.length) {
this.hide();
} else {
this.doCalcs();
this.updateTitle();
}
}
}
}
}
doCalcs() {
this._layouter = new Layouter(this._files, {maxWidth: 384});
this._files = this._layouter.layout();
for (let file of this._files) {
const el = this.$('#uploadPreviewItem_'+file.random);
if (el) {
el.style.left = '' + file.pos.left + 'px';
el.style.top = '' + file.pos.top + 'px';
el.style.width = '' + file.pos.width + 'px';
el.style.height = '' + file.pos.height + 'px';
}
}
this.$('#uploadPreviewAlbum').style.height = this._layouter._height+'px';
this.initScrollBarOn(this.$('.uploadPreview'));
}
swapItems(id1, id2) {
if (id1 == id2) {
return;
}
id1 = id1.split('uploadPreviewItem_').join('');
id2 = id2.split('uploadPreviewItem_').join('');
let toMove1 = null;
let i1 = null;
let toMove2 = null;
let i2 = null;
// let insertBeforeI = null;
for (let i = 0; i < this._files.length; i++) {
if (this._files[i].random == id1) {
toMove1 = this._files[i];
i1 = i;
}
if (this._files[i].random == id2) {
toMove2 = this._files[i];
i2 = i;
}
}
this._files[i1] = toMove2;
this._files[i2] = toMove1;
this.doCalcs();
}
async generateVideoPreview(file, tryToSliceLength) {
let respAB = file.ab;
if (tryToSliceLength) {
respAB = file.ab.slice(0, tryToSliceLength);
}
let response = new Response(
respAB,
{
status: 206,
statusText: 'Partial Content',
headers: [
['Content-Type', 'video/mp4'],
['Content-Length', file.ab.byteLength],
['Content-Range', '0-'+(respAB.byteLength - 1)+'/'+file.ab.byteLength ]]
});
let blob = await response.blob();
let blobUrl = URL.createObjectURL(blob);
let promise = new Promise((res, rej)=>{
let video = document.createElement('video');
video.addEventListener('error', function(event) {
rej();
}, true);
video.onloadeddata = (event) => {
let width = video.videoWidth;
let height = video.videoHeight;
let canvas = document.createElement('canvas');
canvas.width = width;
canvas.height = height;
file.aspectRatio = (height ? (width/height) : 1);
file.width = width;
file.height = height;
this.doCalcs();
let ctx = canvas.getContext("2d");
ctx.imageSmoothingEnabled = true;
ctx.drawImage(video, 0, 0, width, height);
let blankCanvas = document.createElement('canvas');
blankCanvas.width = width;
blankCanvas.height = height;
if (canvas.toDataURL() == blankCanvas.toDataURL()) {
rej();
}
canvas.toBlob((canvasBlob)=>{
let canvasBlobUrl = URL.createObjectURL(canvasBlob);
res(canvasBlobUrl);
});
};
video.preload = 'metadata';
video.src = blobUrl;
// Load video in Safari / IE11
video.muted = true;
video.playsInline = true;
video.play();
});
return await promise;
}
generateUploadPreviewForFile(file) {
const closeHTML = this._components.CloseIcon.render({noDOM: true});
if (file.type == 'photo') {
return '<div class="uploadPreviewItem" draggable="true" id="uploadPreviewItem_'+file.random+'" style="background-image: url(\''+file.dataURL+'\'); '+file.style+'"><div class="upiRemove">'+closeHTML+'</div></div>';
} else if (file.type == 'video') {
return '<div class="uploadPreviewItem" draggable="true" id="uploadPreviewItem_'+file.random+'" style="border: 1px solid #eee;"><div class="upiRemove">'+closeHTML+'</div></div>';
} else if (file.type == 'doc') {
return `<div class="uploadDocItem">
<div class="rsDoc">
<div class="rsDocIcon avatarC${file.color}">${file.ext}</div>
<div class="rsDocName">${file.filename}</div>
<div class="rsDocMeta">${file.sizeHuman}</div>
</div>
</div>`;
}
}
| };
| random_line_split |
Upload.js | () {
this.$('#uploadTop').style.display = 'block';
this.$('.popupOverlay').classList.add('active');
this.loaded();
this.initScrollBarOn(this.$('.uploadPreview'));
}
hide() {
this.$('.popupOverlay').classList.remove('active');
this.$('.popupOverlay').classList.add('fading');
setTimeout(()=>{
this.$('.popupOverlay').classList.remove('fading');
this.$('#uploadTop').style.display = 'none';
this.buttonLoading(false);
}, 500);
}
async readFile(inputFile) {
let readTheData = (ifile, method)=>{
return new Promise((res, rej)=>{
let reader = new FileReader();
reader.onload = (e)=>{
res(e.target.result);
}
reader.onerror = (e)=>{
rej(e);
}
reader.onabort = ()=>{
rej();
}
reader[method](ifile);
});
};
let dims = (ifile)=>{
return new Promise((res,rej)=>{
const img = new Image();
img.onload = function () {
res([this.width, this.height]);
};
img.onerror = function() {
res([100,100]); // ???
};
img.src = ifile.dataURL;
});
};
try {
let ab = await readTheData(inputFile, 'readAsArrayBuffer');
let filename = (''+inputFile.name) || 'undefined';
let ext = (filename.lastIndexOf('.') != -1) ? (filename.substr(filename.lastIndexOf('.') + 1)).toLowerCase() : '';
let fileData = {
ab: ab,
name: inputFile.name,
size: inputFile.size,
filename: filename,
ext: ext,
type: 'doc',
aspectRatio: 1,
};
// nice one. https://stackoverflow.com/a/20732091/1119169 thanks Andrew!
const sizeI = Math.floor( Math.log(fileData.size) / Math.log(1024) );
fileData.sizeHuman = ( fileData.size / Math.pow(1024, sizeI) ).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][sizeI];
fileData.color = ((''+ext+' ').charCodeAt(0) % 8 + 1);
fileData.random = (''+Math.random()).split('.').join('');
let photoExts = ['png', 'jpg', 'jpeg'];
let videoExts = ['mp4', 'mpeg', 'avi', 'mov'];
if (photoExts.indexOf(ext) != -1 && this._uploadingMedia) {
fileData.type = 'photo';
} else if (videoExts.indexOf(ext) != -1 && this._uploadingMedia) {
fileData.type = 'video';
}
if (fileData.type == 'photo') {
// let dataURL = await readTheData(inputFile, 'readAsDataURL'); // ? URL.createObjectURL(file);
fileData.dataURL = URL.createObjectURL(inputFile);
[fileData.width, fileData.height] = await dims(fileData); // parallelize?
} else if (fileData.type == 'video') {
fileData.width = 100;
fileData.height = 100;
}
this._files.push(fileData);
return fileData;
} catch(e) {
// console.log(e);
return false;
}
}
loaded() {
// console.error(this._files);
this.updateTitle();
this.generateUploadPreview();
}
updateTitle() {
let suffix = {
doc: 'File',
video: 'Video',
photo: 'Photo',
};
let title = 'Send '+( (this._files.length > 1) ? this._files.length : '' ) + ' ' + suffix[this._files[0].type] + ( (this._files.length > 1) ? 's' : '' );
this.$('.uploadTitle').innerHTML = title;
}
onAlbumClick(e) {
const base = this.$();
let closest = event.target.closest('.upiRemove');
if (closest && base.contains(closest)) {
const el = closest.parentElement;
if (el) {
const id = el.id.split('uploadPreviewItem_').join('');
let ri = null;
for (let i = 0; i < this._files.length; i++) {
if (this._files[i].random == id) {
ri = i;
}
}
if (ri !== null) {
this._files.splice(ri, 1);
el.remove();
if (!this._files.length) {
this.hide();
} else {
this.doCalcs();
this.updateTitle();
}
}
}
}
}
doCalcs() {
this._layouter = new Layouter(this._files, {maxWidth: 384});
this._files = this._layouter.layout();
for (let file of this._files) {
const el = this.$('#uploadPreviewItem_'+file.random);
if (el) {
el.style.left = '' + file.pos.left + 'px';
el.style.top = '' + file.pos.top + 'px';
el.style.width = '' + file.pos.width + 'px';
el.style.height = '' + file.pos.height + 'px';
}
}
this.$('#uploadPreviewAlbum').style.height = this._layouter._height+'px';
this.initScrollBarOn(this.$('.uploadPreview'));
}
swapItems(id1, id2) {
if (id1 == id2) {
return;
}
id1 = id1.split('uploadPreviewItem_').join('');
id2 = id2.split('uploadPreviewItem_').join('');
let toMove1 = null;
let i1 = null;
let toMove2 = null;
let i2 = null;
// let insertBeforeI = null;
for (let i = 0; i < this._files.length; i++) {
if (this._files[i].random == id1) {
toMove1 = this._files[i];
i1 = i;
}
if (this._files[i].random == id2) {
toMove2 = this._files[i];
i2 = i;
}
}
this._files[i1] = toMove2;
this._files[i2] = toMove1;
this.doCalcs();
}
async generateVideoPreview(file, tryToSliceLength) {
let respAB = file.ab;
if (tryToSliceLength) {
respAB = file.ab.slice(0, tryToSliceLength);
}
let response = new Response(
respAB,
{
status: 206,
statusText: 'Partial Content',
headers: [
['Content-Type', 'video/mp4'],
['Content-Length', file.ab.byteLength],
['Content-Range', '0-'+(respAB.byteLength - 1)+'/'+file.ab.byteLength ]]
});
let blob = await response.blob();
let blobUrl = URL.createObjectURL(blob);
let promise = new Promise((res, rej)=>{
let video = document.createElement('video');
video.addEventListener('error', function(event) {
rej();
}, true);
video.onloadeddata = (event) => {
let width = video.videoWidth;
let height = video.videoHeight;
let canvas = document.createElement('canvas');
canvas.width = width;
canvas.height = height;
file.aspectRatio = (height ? (width/height) : 1);
file.width = width;
file.height = height;
this.doCalcs();
let ctx = canvas.getContext("2d");
ctx.imageSmoothingEnabled = true;
ctx.drawImage(video, 0, 0, width, height);
let blankCanvas = document.createElement('canvas');
blankCanvas.width = width;
blankCanvas.height = height;
if (canvas.toDataURL() == blankCanvas.toDataURL()) {
rej();
}
canvas.toBlob((canvasBlob)=>{
let canvasBlobUrl = URL.createObjectURL(canvasBlob);
res(canvasBlobUrl);
});
};
video.preload = 'metadata';
video.src = blobUrl;
// Load video in Safari / IE11
video.muted = true;
video.playsInline = true;
video.play();
});
return await promise;
}
generateUploadPreviewForFile(file) {
const closeHTML = this._components.CloseIcon.render({noDOM: true});
if (file.type == 'photo') {
return '<div class="uploadPreviewItem" draggable="true" id="uploadPreviewItem_'+file.random+'" style="background-image: url(\''+file.dataURL+'\'); '+file.style+'"><div class="upiRemove">'+closeHTML+'</div></div>';
} else if (file.type == 'video') {
return '<div class="uploadPreviewItem" draggable="true" id="uploadPreviewItem_'+file.random+'" style="border: 1px solid #eee;">< | show | identifier_name |
|
image_utils.py | n_channels == 1:
curr_image = np.reshape(curr_image, [height, width])
s = io.BytesIO()
matplotlib_pyplot().imsave(s, curr_image, format="png")
img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(),
height=height, width=width,
colorspace=n_channels)
return tf.Summary.Value(tag=tag, image=img_sum)
def convert_predictions_to_image_summaries(hook_args):
"""Optionally converts images from hooks_args to image summaries.
Args:
hook_args: DecodeHookArgs namedtuple
Returns:
summaries: list of tf.Summary values if hook_args.decode_hpara
"""
decode_hparams = hook_args.decode_hparams
if not decode_hparams.display_decoded_images:
return []
predictions = hook_args.predictions[0]
# Display ten random inputs and outputs so that tensorboard does not hang.
all_summaries = []
rand_predictions = np.random.choice(predictions, size=10)
for ind, prediction in enumerate(rand_predictions):
output_summary = image_to_tf_summary_value(
prediction["outputs"], tag="%d_output" % ind)
input_summary = image_to_tf_summary_value(
prediction["inputs"], tag="%d_input" % ind)
all_summaries.append(input_summary)
all_summaries.append(output_summary)
return all_summaries
def resize_by_area(img, size):
"""image resize function used by quite a few image problems."""
return tf.to_int64(
tf.image.resize_images(img, [size, size], tf.image.ResizeMethod.AREA))
def make_multiscale(image, resolutions,
resize_method=tf.image.ResizeMethod.BICUBIC,
num_channels=3):
"""Returns list of scaled images, one for each resolution.
Args:
image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to.
resize_method: tf.image.ResizeMethod.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels].
"""
scaled_images = []
for height in resolutions:
scaled_image = tf.image.resize_images(
image,
size=[height, height], # assuming that height = width
method=resize_method)
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([height, height, num_channels])
scaled_images.append(scaled_image)
return scaled_images
def make_multiscale_dilated(image, resolutions, num_channels=3):
"""Returns list of scaled images, one for each resolution.
Resizes by skipping every nth pixel.
Args:
image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to. The function
assumes VALID padding, so the original image's height must be divisible
by each resolution's height to return the exact resolution size.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels] if resolutions properly
divide the original image's height; otherwise shape height and width is up
to valid skips.
"""
image_height = common_layers.shape_list(image)[0]
scaled_images = []
for height in resolutions:
dilation_rate = image_height // height # assuming height = width
scaled_image = image[::dilation_rate, ::dilation_rate]
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([None, None, num_channels])
scaled_images.append(scaled_image)
return scaled_images
class ImageProblem(problem.Problem):
"""Base class for problems with images."""
@property
def num_channels(self):
"""Number of color channels."""
return 3
@property
def vocab_size(self):
"""Number of pixel values."""
return 256
def example_reading_spec(self):
data_fields = {
"image/encoded": tf.FixedLenFeature((), tf.string),
"image/format": tf.FixedLenFeature((), tf.string),
}
data_items_to_decoders = {
"inputs":
tf.contrib.slim.tfexample_decoder.Image(
image_key="image/encoded",
format_key="image/format",
channels=self.num_channels),
}
return data_fields, data_items_to_decoders
def preprocess_example(self, example, mode, hparams):
if not self._was_reversed:
example["inputs"] = tf.image.per_image_standardization(example["inputs"])
return example
def eval_metrics(self):
eval_metrics = [
metrics.Metrics.ACC, metrics.Metrics.ACC_TOP5,
metrics.Metrics.ACC_PER_SEQ, metrics.Metrics.NEG_LOG_PERPLEXITY
]
if self._was_reversed:
eval_metrics += [metrics.Metrics.IMAGE_SUMMARY]
return eval_metrics
@property
def decode_hooks(self):
return [convert_predictions_to_image_summaries]
class Image2ClassProblem(ImageProblem):
"""Base class for image classification problems."""
@property
def is_small(self):
raise NotImplementedError()
@property
def num_classes(self):
raise NotImplementedError()
@property
def train_shards(self):
raise NotImplementedError()
@property
def dev_shards(self):
return 1
@property
def class_labels(self):
return ["ID_%d" % i for i in range(self.num_classes)]
def feature_encoders(self, data_dir):
del data_dir
return {
"inputs": text_encoder.ImageEncoder(channels=self.num_channels),
"targets": text_encoder.ClassLabelEncoder(self.class_labels)
}
def generator(self, data_dir, tmp_dir, is_training):
raise NotImplementedError()
def example_reading_spec(self):
label_key = "image/class/label"
data_fields, data_items_to_decoders = (
super(Image2ClassProblem, self).example_reading_spec())
data_fields[label_key] = tf.FixedLenFeature((1,), tf.int64)
data_items_to_decoders[
"targets"] = tf.contrib.slim.tfexample_decoder.Tensor(label_key)
return data_fields, data_items_to_decoders
def hparams(self, defaults, unused_model_hparams):
p = defaults
p.modality = {"inputs": modalities.ModalityType.IMAGE,
"targets": modalities.ModalityType.CLASS_LABEL}
p.vocab_size = {"inputs": 256,
"targets": self.num_classes}
p.batch_size_multiplier = 4 if self.is_small else 256
p.loss_multiplier = 3.0 if self.is_small else 1.0
if self._was_reversed:
p.loss_multiplier = 1.0
p.input_space_id = problem.SpaceID.IMAGE
p.target_space_id = problem.SpaceID.IMAGE_LABEL
def generate_data(self, data_dir, tmp_dir, task_id=-1):
generator_utils.generate_dataset_and_shuffle(
self.generator(data_dir, tmp_dir, True),
self.training_filepaths(data_dir, self.train_shards, shuffled=False),
self.generator(data_dir, tmp_dir, False),
self.dev_filepaths(data_dir, self.dev_shards, shuffled=False))
def encode_images_as_png(images):
"""Yield images encoded as pngs."""
if tf.executing_eagerly():
for image in images:
yield tf.image.encode_png(image).numpy()
else:
(height, width, channels) = images[0].shape
with tf.Graph().as_default():
image_t = tf.placeholder(dtype=tf.uint8, shape=(height, width, channels))
encoded_image_t = tf.image.encode_png(image_t)
with tf.Session() as sess:
for image in images:
enc_string = sess.run(encoded_image_t, feed_dict={image_t: image})
yield enc_string
def image_generator(images, labels):
"""Generator for images that takes image and labels lists and creates pngs.
Args:
images: list of images given as [width x height x channels] numpy arrays.
labels: list of ints, same length as images.
Yields:
A dictionary representing the images with the following fields:
* image/encoded: the string encoding the image as PNG,
* image/format: the string "png" representing image format,
* image/class/label: an integer representing the label,
* image/height: an integer representing the height,
* image/width: an integer representing the width.
Every field is actually a singleton list of the corresponding type.
Raises:
ValueError: if images is an empty list.
"""
if not images:
raise ValueError("Must provide some images for the generator.")
width, height, _ = images[0].shape
for (enc_image, label) in zip(encode_images_as_png(images), labels):
|
class Image2TextProblem(ImageProblem):
"""Base class for image-to-text problems."""
@property
def is_character_level(self):
raise NotImplementedError()
@property
def vocab_problem(self):
raise NotImplementedError() # Not needed if self.is_character_level.
@property
def target_space_id | yield {
"image/encoded": [enc_image],
"image/format": ["png"],
"image/class/label": [int(label)],
"image/height": [height],
"image/width": [width]
} | conditional_block |
image_utils.py | n_channels == 1:
curr_image = np.reshape(curr_image, [height, width])
s = io.BytesIO()
matplotlib_pyplot().imsave(s, curr_image, format="png")
img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(),
height=height, width=width,
colorspace=n_channels)
return tf.Summary.Value(tag=tag, image=img_sum)
def convert_predictions_to_image_summaries(hook_args):
"""Optionally converts images from hooks_args to image summaries.
Args:
hook_args: DecodeHookArgs namedtuple
Returns:
summaries: list of tf.Summary values if hook_args.decode_hpara
"""
decode_hparams = hook_args.decode_hparams
if not decode_hparams.display_decoded_images:
return []
predictions = hook_args.predictions[0]
# Display ten random inputs and outputs so that tensorboard does not hang.
all_summaries = []
rand_predictions = np.random.choice(predictions, size=10)
for ind, prediction in enumerate(rand_predictions):
output_summary = image_to_tf_summary_value(
prediction["outputs"], tag="%d_output" % ind)
input_summary = image_to_tf_summary_value(
prediction["inputs"], tag="%d_input" % ind)
all_summaries.append(input_summary)
all_summaries.append(output_summary)
return all_summaries
def resize_by_area(img, size):
"""image resize function used by quite a few image problems."""
return tf.to_int64(
tf.image.resize_images(img, [size, size], tf.image.ResizeMethod.AREA))
def make_multiscale(image, resolutions,
resize_method=tf.image.ResizeMethod.BICUBIC,
num_channels=3):
"""Returns list of scaled images, one for each resolution.
Args:
image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to.
resize_method: tf.image.ResizeMethod.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels].
"""
scaled_images = []
for height in resolutions:
scaled_image = tf.image.resize_images(
image,
size=[height, height], # assuming that height = width
method=resize_method)
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([height, height, num_channels])
scaled_images.append(scaled_image)
return scaled_images
def make_multiscale_dilated(image, resolutions, num_channels=3):
"""Returns list of scaled images, one for each resolution.
Resizes by skipping every nth pixel.
Args:
image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to. The function
assumes VALID padding, so the original image's height must be divisible
by each resolution's height to return the exact resolution size.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels] if resolutions properly
divide the original image's height; otherwise shape height and width is up
to valid skips.
"""
image_height = common_layers.shape_list(image)[0]
scaled_images = []
for height in resolutions:
dilation_rate = image_height // height # assuming height = width
scaled_image = image[::dilation_rate, ::dilation_rate]
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([None, None, num_channels])
scaled_images.append(scaled_image)
return scaled_images
class ImageProblem(problem.Problem):
"""Base class for problems with images."""
@property
def num_channels(self):
"""Number of color channels."""
return 3
@property
def vocab_size(self):
"""Number of pixel values."""
return 256
def example_reading_spec(self):
data_fields = {
"image/encoded": tf.FixedLenFeature((), tf.string),
"image/format": tf.FixedLenFeature((), tf.string),
}
data_items_to_decoders = {
"inputs":
tf.contrib.slim.tfexample_decoder.Image(
image_key="image/encoded",
format_key="image/format",
channels=self.num_channels),
}
return data_fields, data_items_to_decoders
def preprocess_example(self, example, mode, hparams):
if not self._was_reversed:
example["inputs"] = tf.image.per_image_standardization(example["inputs"])
return example
def eval_metrics(self):
eval_metrics = [
metrics.Metrics.ACC, metrics.Metrics.ACC_TOP5,
metrics.Metrics.ACC_PER_SEQ, metrics.Metrics.NEG_LOG_PERPLEXITY
]
if self._was_reversed:
eval_metrics += [metrics.Metrics.IMAGE_SUMMARY]
return eval_metrics
@property
def decode_hooks(self):
return [convert_predictions_to_image_summaries]
class Image2ClassProblem(ImageProblem):
"""Base class for image classification problems."""
@property
def is_small(self):
raise NotImplementedError()
@property
def num_classes(self):
raise NotImplementedError()
@property
def train_shards(self):
raise NotImplementedError()
@property
def dev_shards(self):
return 1
@property
def class_labels(self):
return ["ID_%d" % i for i in range(self.num_classes)]
def feature_encoders(self, data_dir):
del data_dir
return {
"inputs": text_encoder.ImageEncoder(channels=self.num_channels),
"targets": text_encoder.ClassLabelEncoder(self.class_labels)
}
def generator(self, data_dir, tmp_dir, is_training):
raise NotImplementedError()
def example_reading_spec(self):
label_key = "image/class/label"
data_fields, data_items_to_decoders = (
super(Image2ClassProblem, self).example_reading_spec())
data_fields[label_key] = tf.FixedLenFeature((1,), tf.int64)
data_items_to_decoders[
"targets"] = tf.contrib.slim.tfexample_decoder.Tensor(label_key)
return data_fields, data_items_to_decoders
def hparams(self, defaults, unused_model_hparams):
p = defaults
p.modality = {"inputs": modalities.ModalityType.IMAGE,
"targets": modalities.ModalityType.CLASS_LABEL}
p.vocab_size = {"inputs": 256,
"targets": self.num_classes}
p.batch_size_multiplier = 4 if self.is_small else 256
p.loss_multiplier = 3.0 if self.is_small else 1.0
if self._was_reversed:
p.loss_multiplier = 1.0
p.input_space_id = problem.SpaceID.IMAGE
p.target_space_id = problem.SpaceID.IMAGE_LABEL
def generate_data(self, data_dir, tmp_dir, task_id=-1):
generator_utils.generate_dataset_and_shuffle(
self.generator(data_dir, tmp_dir, True),
self.training_filepaths(data_dir, self.train_shards, shuffled=False),
self.generator(data_dir, tmp_dir, False),
self.dev_filepaths(data_dir, self.dev_shards, shuffled=False))
def encode_images_as_png(images):
"""Yield images encoded as pngs."""
if tf.executing_eagerly():
for image in images:
yield tf.image.encode_png(image).numpy()
else:
(height, width, channels) = images[0].shape
with tf.Graph().as_default():
image_t = tf.placeholder(dtype=tf.uint8, shape=(height, width, channels))
encoded_image_t = tf.image.encode_png(image_t)
with tf.Session() as sess:
for image in images:
enc_string = sess.run(encoded_image_t, feed_dict={image_t: image})
yield enc_string
def image_generator(images, labels):
"""Generator for images that takes image and labels lists and creates pngs.
Args:
images: list of images given as [width x height x channels] numpy arrays.
labels: list of ints, same length as images.
Yields:
A dictionary representing the images with the following fields:
* image/encoded: the string encoding the image as PNG,
* image/format: the string "png" representing image format,
* image/class/label: an integer representing the label,
* image/height: an integer representing the height,
* image/width: an integer representing the width.
Every field is actually a singleton list of the corresponding type.
Raises:
ValueError: if images is an empty list.
"""
if not images:
raise ValueError("Must provide some images for the generator.")
width, height, _ = images[0].shape
for (enc_image, label) in zip(encode_images_as_png(images), labels):
yield {
"image/encoded": [enc_image],
"image/format": ["png"],
"image/class/label": [int(label)],
"image/height": [height],
"image/width": [width]
}
class Image2TextProblem(ImageProblem):
"""Base class for image-to-text problems."""
@property
def is_character_level(self):
raise NotImplementedError()
@property
def vocab_problem(self):
raise NotImplementedError() # Not needed if self.is_character_level.
@property
def | target_space_id | identifier_name |
|
image_utils.py | n_channels == 1:
curr_image = np.reshape(curr_image, [height, width])
s = io.BytesIO()
matplotlib_pyplot().imsave(s, curr_image, format="png")
img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(),
height=height, width=width,
colorspace=n_channels)
return tf.Summary.Value(tag=tag, image=img_sum)
def convert_predictions_to_image_summaries(hook_args):
"""Optionally converts images from hooks_args to image summaries.
Args:
hook_args: DecodeHookArgs namedtuple
Returns:
summaries: list of tf.Summary values if hook_args.decode_hpara
"""
decode_hparams = hook_args.decode_hparams
if not decode_hparams.display_decoded_images:
return []
predictions = hook_args.predictions[0]
# Display ten random inputs and outputs so that tensorboard does not hang.
all_summaries = []
rand_predictions = np.random.choice(predictions, size=10)
for ind, prediction in enumerate(rand_predictions):
output_summary = image_to_tf_summary_value(
prediction["outputs"], tag="%d_output" % ind)
input_summary = image_to_tf_summary_value(
prediction["inputs"], tag="%d_input" % ind)
all_summaries.append(input_summary)
all_summaries.append(output_summary)
return all_summaries
def resize_by_area(img, size):
"""image resize function used by quite a few image problems."""
return tf.to_int64(
tf.image.resize_images(img, [size, size], tf.image.ResizeMethod.AREA))
def make_multiscale(image, resolutions,
resize_method=tf.image.ResizeMethod.BICUBIC,
num_channels=3):
"""Returns list of scaled images, one for each resolution.
Args:
image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to.
resize_method: tf.image.ResizeMethod.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels].
"""
scaled_images = []
for height in resolutions:
scaled_image = tf.image.resize_images(
image,
size=[height, height], # assuming that height = width
method=resize_method)
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([height, height, num_channels])
scaled_images.append(scaled_image)
return scaled_images
def make_multiscale_dilated(image, resolutions, num_channels=3):
"""Returns list of scaled images, one for each resolution.
Resizes by skipping every nth pixel.
Args: | assumes VALID padding, so the original image's height must be divisible
by each resolution's height to return the exact resolution size.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels] if resolutions properly
divide the original image's height; otherwise shape height and width is up
to valid skips.
"""
image_height = common_layers.shape_list(image)[0]
scaled_images = []
for height in resolutions:
dilation_rate = image_height // height # assuming height = width
scaled_image = image[::dilation_rate, ::dilation_rate]
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([None, None, num_channels])
scaled_images.append(scaled_image)
return scaled_images
class ImageProblem(problem.Problem):
"""Base class for problems with images."""
@property
def num_channels(self):
"""Number of color channels."""
return 3
@property
def vocab_size(self):
"""Number of pixel values."""
return 256
def example_reading_spec(self):
data_fields = {
"image/encoded": tf.FixedLenFeature((), tf.string),
"image/format": tf.FixedLenFeature((), tf.string),
}
data_items_to_decoders = {
"inputs":
tf.contrib.slim.tfexample_decoder.Image(
image_key="image/encoded",
format_key="image/format",
channels=self.num_channels),
}
return data_fields, data_items_to_decoders
def preprocess_example(self, example, mode, hparams):
if not self._was_reversed:
example["inputs"] = tf.image.per_image_standardization(example["inputs"])
return example
def eval_metrics(self):
eval_metrics = [
metrics.Metrics.ACC, metrics.Metrics.ACC_TOP5,
metrics.Metrics.ACC_PER_SEQ, metrics.Metrics.NEG_LOG_PERPLEXITY
]
if self._was_reversed:
eval_metrics += [metrics.Metrics.IMAGE_SUMMARY]
return eval_metrics
@property
def decode_hooks(self):
return [convert_predictions_to_image_summaries]
class Image2ClassProblem(ImageProblem):
"""Base class for image classification problems."""
@property
def is_small(self):
raise NotImplementedError()
@property
def num_classes(self):
raise NotImplementedError()
@property
def train_shards(self):
raise NotImplementedError()
@property
def dev_shards(self):
return 1
@property
def class_labels(self):
return ["ID_%d" % i for i in range(self.num_classes)]
def feature_encoders(self, data_dir):
del data_dir
return {
"inputs": text_encoder.ImageEncoder(channels=self.num_channels),
"targets": text_encoder.ClassLabelEncoder(self.class_labels)
}
def generator(self, data_dir, tmp_dir, is_training):
raise NotImplementedError()
def example_reading_spec(self):
label_key = "image/class/label"
data_fields, data_items_to_decoders = (
super(Image2ClassProblem, self).example_reading_spec())
data_fields[label_key] = tf.FixedLenFeature((1,), tf.int64)
data_items_to_decoders[
"targets"] = tf.contrib.slim.tfexample_decoder.Tensor(label_key)
return data_fields, data_items_to_decoders
def hparams(self, defaults, unused_model_hparams):
p = defaults
p.modality = {"inputs": modalities.ModalityType.IMAGE,
"targets": modalities.ModalityType.CLASS_LABEL}
p.vocab_size = {"inputs": 256,
"targets": self.num_classes}
p.batch_size_multiplier = 4 if self.is_small else 256
p.loss_multiplier = 3.0 if self.is_small else 1.0
if self._was_reversed:
p.loss_multiplier = 1.0
p.input_space_id = problem.SpaceID.IMAGE
p.target_space_id = problem.SpaceID.IMAGE_LABEL
def generate_data(self, data_dir, tmp_dir, task_id=-1):
generator_utils.generate_dataset_and_shuffle(
self.generator(data_dir, tmp_dir, True),
self.training_filepaths(data_dir, self.train_shards, shuffled=False),
self.generator(data_dir, tmp_dir, False),
self.dev_filepaths(data_dir, self.dev_shards, shuffled=False))
def encode_images_as_png(images):
"""Yield images encoded as pngs."""
if tf.executing_eagerly():
for image in images:
yield tf.image.encode_png(image).numpy()
else:
(height, width, channels) = images[0].shape
with tf.Graph().as_default():
image_t = tf.placeholder(dtype=tf.uint8, shape=(height, width, channels))
encoded_image_t = tf.image.encode_png(image_t)
with tf.Session() as sess:
for image in images:
enc_string = sess.run(encoded_image_t, feed_dict={image_t: image})
yield enc_string
def image_generator(images, labels):
"""Generator for images that takes image and labels lists and creates pngs.
Args:
images: list of images given as [width x height x channels] numpy arrays.
labels: list of ints, same length as images.
Yields:
A dictionary representing the images with the following fields:
* image/encoded: the string encoding the image as PNG,
* image/format: the string "png" representing image format,
* image/class/label: an integer representing the label,
* image/height: an integer representing the height,
* image/width: an integer representing the width.
Every field is actually a singleton list of the corresponding type.
Raises:
ValueError: if images is an empty list.
"""
if not images:
raise ValueError("Must provide some images for the generator.")
width, height, _ = images[0].shape
for (enc_image, label) in zip(encode_images_as_png(images), labels):
yield {
"image/encoded": [enc_image],
"image/format": ["png"],
"image/class/label": [int(label)],
"image/height": [height],
"image/width": [width]
}
class Image2TextProblem(ImageProblem):
"""Base class for image-to-text problems."""
@property
def is_character_level(self):
raise NotImplementedError()
@property
def vocab_problem(self):
raise NotImplementedError() # Not needed if self.is_character_level.
@property
def target_space_id(self):
| image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to. The function | random_line_split |
image_utils.py | n_channels == 1:
curr_image = np.reshape(curr_image, [height, width])
s = io.BytesIO()
matplotlib_pyplot().imsave(s, curr_image, format="png")
img_sum = tf.Summary.Image(encoded_image_string=s.getvalue(),
height=height, width=width,
colorspace=n_channels)
return tf.Summary.Value(tag=tag, image=img_sum)
def convert_predictions_to_image_summaries(hook_args):
"""Optionally converts images from hooks_args to image summaries.
Args:
hook_args: DecodeHookArgs namedtuple
Returns:
summaries: list of tf.Summary values if hook_args.decode_hpara
"""
decode_hparams = hook_args.decode_hparams
if not decode_hparams.display_decoded_images:
return []
predictions = hook_args.predictions[0]
# Display ten random inputs and outputs so that tensorboard does not hang.
all_summaries = []
rand_predictions = np.random.choice(predictions, size=10)
for ind, prediction in enumerate(rand_predictions):
output_summary = image_to_tf_summary_value(
prediction["outputs"], tag="%d_output" % ind)
input_summary = image_to_tf_summary_value(
prediction["inputs"], tag="%d_input" % ind)
all_summaries.append(input_summary)
all_summaries.append(output_summary)
return all_summaries
def resize_by_area(img, size):
"""image resize function used by quite a few image problems."""
return tf.to_int64(
tf.image.resize_images(img, [size, size], tf.image.ResizeMethod.AREA))
def make_multiscale(image, resolutions,
resize_method=tf.image.ResizeMethod.BICUBIC,
num_channels=3):
"""Returns list of scaled images, one for each resolution.
Args:
image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to.
resize_method: tf.image.ResizeMethod.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels].
"""
scaled_images = []
for height in resolutions:
scaled_image = tf.image.resize_images(
image,
size=[height, height], # assuming that height = width
method=resize_method)
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([height, height, num_channels])
scaled_images.append(scaled_image)
return scaled_images
def make_multiscale_dilated(image, resolutions, num_channels=3):
"""Returns list of scaled images, one for each resolution.
Resizes by skipping every nth pixel.
Args:
image: Tensor of shape [height, height, num_channels].
resolutions: List of heights that image's height is resized to. The function
assumes VALID padding, so the original image's height must be divisible
by each resolution's height to return the exact resolution size.
num_channels: Number of channels in image.
Returns:
List of Tensors, one for each resolution with shape given by
[resolutions[i], resolutions[i], num_channels] if resolutions properly
divide the original image's height; otherwise shape height and width is up
to valid skips.
"""
image_height = common_layers.shape_list(image)[0]
scaled_images = []
for height in resolutions:
dilation_rate = image_height // height # assuming height = width
scaled_image = image[::dilation_rate, ::dilation_rate]
scaled_image = tf.to_int64(scaled_image)
scaled_image.set_shape([None, None, num_channels])
scaled_images.append(scaled_image)
return scaled_images
class ImageProblem(problem.Problem):
"""Base class for problems with images."""
@property
def num_channels(self):
"""Number of color channels."""
return 3
@property
def vocab_size(self):
"""Number of pixel values."""
return 256
def example_reading_spec(self):
data_fields = {
"image/encoded": tf.FixedLenFeature((), tf.string),
"image/format": tf.FixedLenFeature((), tf.string),
}
data_items_to_decoders = {
"inputs":
tf.contrib.slim.tfexample_decoder.Image(
image_key="image/encoded",
format_key="image/format",
channels=self.num_channels),
}
return data_fields, data_items_to_decoders
def preprocess_example(self, example, mode, hparams):
if not self._was_reversed:
example["inputs"] = tf.image.per_image_standardization(example["inputs"])
return example
def eval_metrics(self):
eval_metrics = [
metrics.Metrics.ACC, metrics.Metrics.ACC_TOP5,
metrics.Metrics.ACC_PER_SEQ, metrics.Metrics.NEG_LOG_PERPLEXITY
]
if self._was_reversed:
eval_metrics += [metrics.Metrics.IMAGE_SUMMARY]
return eval_metrics
@property
def decode_hooks(self):
return [convert_predictions_to_image_summaries]
class Image2ClassProblem(ImageProblem):
"""Base class for image classification problems."""
@property
def is_small(self):
raise NotImplementedError()
@property
def num_classes(self):
raise NotImplementedError()
@property
def train_shards(self):
raise NotImplementedError()
@property
def dev_shards(self):
return 1
@property
def class_labels(self):
return ["ID_%d" % i for i in range(self.num_classes)]
def feature_encoders(self, data_dir):
del data_dir
return {
"inputs": text_encoder.ImageEncoder(channels=self.num_channels),
"targets": text_encoder.ClassLabelEncoder(self.class_labels)
}
def generator(self, data_dir, tmp_dir, is_training):
raise NotImplementedError()
def example_reading_spec(self):
label_key = "image/class/label"
data_fields, data_items_to_decoders = (
super(Image2ClassProblem, self).example_reading_spec())
data_fields[label_key] = tf.FixedLenFeature((1,), tf.int64)
data_items_to_decoders[
"targets"] = tf.contrib.slim.tfexample_decoder.Tensor(label_key)
return data_fields, data_items_to_decoders
def hparams(self, defaults, unused_model_hparams):
p = defaults
p.modality = {"inputs": modalities.ModalityType.IMAGE,
"targets": modalities.ModalityType.CLASS_LABEL}
p.vocab_size = {"inputs": 256,
"targets": self.num_classes}
p.batch_size_multiplier = 4 if self.is_small else 256
p.loss_multiplier = 3.0 if self.is_small else 1.0
if self._was_reversed:
p.loss_multiplier = 1.0
p.input_space_id = problem.SpaceID.IMAGE
p.target_space_id = problem.SpaceID.IMAGE_LABEL
def generate_data(self, data_dir, tmp_dir, task_id=-1):
generator_utils.generate_dataset_and_shuffle(
self.generator(data_dir, tmp_dir, True),
self.training_filepaths(data_dir, self.train_shards, shuffled=False),
self.generator(data_dir, tmp_dir, False),
self.dev_filepaths(data_dir, self.dev_shards, shuffled=False))
def encode_images_as_png(images):
|
def image_generator(images, labels):
"""Generator for images that takes image and labels lists and creates pngs.
Args:
images: list of images given as [width x height x channels] numpy arrays.
labels: list of ints, same length as images.
Yields:
A dictionary representing the images with the following fields:
* image/encoded: the string encoding the image as PNG,
* image/format: the string "png" representing image format,
* image/class/label: an integer representing the label,
* image/height: an integer representing the height,
* image/width: an integer representing the width.
Every field is actually a singleton list of the corresponding type.
Raises:
ValueError: if images is an empty list.
"""
if not images:
raise ValueError("Must provide some images for the generator.")
width, height, _ = images[0].shape
for (enc_image, label) in zip(encode_images_as_png(images), labels):
yield {
"image/encoded": [enc_image],
"image/format": ["png"],
"image/class/label": [int(label)],
"image/height": [height],
"image/width": [width]
}
class Image2TextProblem(ImageProblem):
"""Base class for image-to-text problems."""
@property
def is_character_level(self):
raise NotImplementedError()
@property
def vocab_problem(self):
raise NotImplementedError() # Not needed if self.is_character_level.
@property
def target_space_id(self | """Yield images encoded as pngs."""
if tf.executing_eagerly():
for image in images:
yield tf.image.encode_png(image).numpy()
else:
(height, width, channels) = images[0].shape
with tf.Graph().as_default():
image_t = tf.placeholder(dtype=tf.uint8, shape=(height, width, channels))
encoded_image_t = tf.image.encode_png(image_t)
with tf.Session() as sess:
for image in images:
enc_string = sess.run(encoded_image_t, feed_dict={image_t: image})
yield enc_string | identifier_body |
congestion.go | ) {
}
func (cc *CongestionControllerDummy) onAckReceived(acks ackRanges, delay time.Duration) {
}
func (cc *CongestionControllerDummy) bytesAllowedToSend() int {
/* return the the maximum int value */
return int(^uint(0) >> 1)
}
func (cc *CongestionControllerDummy) setLostPacketHandler(handler func(pn uint64)) {
}
func (cc *CongestionControllerDummy) rto() time.Duration {
return kMinRTOTimeout
}
/*
* draft-ietf-quic-recovery congestion controller
*/
type CongestionControllerIetf struct {
// Congestion control related
bytesInFlight int
congestionWindow int
endOfRecovery uint64
sstresh int
// Loss detection related
lossDetectionAlarm int //TODO([email protected]) set this to the right type
handshakeCount int
tlpCount int
rtoCount int
largestSendBeforeRto uint64
timeOfLastSentPacket time.Time
largestSendPacket uint64
largestAckedPacket uint64
maxAckDelay time.Duration
minRtt time.Duration
// largestRtt time.Duration
smoothedRtt time.Duration
rttVar time.Duration
smoothedRttTcp time.Duration
rttVarTcp time.Duration
reorderingThreshold int
timeReorderingFraction float32
lossTime time.Time
sentPackets map[uint64]packetEntry
// others
lostPacketHandler func(pn uint64)
conn *Connection
}
type packetEntry struct {
pn uint64
txTime time.Time
bytes int
ackOnly bool
}
func (cc *CongestionControllerIetf) onPacketSent(pn uint64, isAckOnly bool, sentBytes int) {
cc.timeOfLastSentPacket = time.Now()
cc.largestSendPacket = pn
packetData := packetEntry{pn, time.Now(), 0, isAckOnly}
cc.conn.log(logTypeCongestion, "Packet send pn: %d len:%d ackonly: %v\n", pn, sentBytes, isAckOnly)
if !isAckOnly {
cc.onPacketSentCC(sentBytes)
packetData.bytes = sentBytes
cc.setLossDetectionAlarm()
}
cc.sentPackets[pn] = packetData
}
// acks is received to be a sorted list, where the largest packet numbers are at the beginning
func (cc *CongestionControllerIetf) onAckReceived(acks ackRanges, ackDelay time.Duration) {
// keep track of largest packet acked overall
if acks[0].lastPacket > cc.largestAckedPacket {
cc.largestAckedPacket = acks[0].lastPacket
}
// If the largest acked is newly acked update rtt
lastPacket, present := cc.sentPackets[acks[0].lastPacket]
if present {
latestRtt := time.Since(cc.sentPackets[acks[0].lastPacket].txTime)
cc.conn.log(logTypeCongestion, "latestRtt: %v, ackDelay: %v", latestRtt, ackDelay)
cc.updateRttTcp(latestRtt)
// Update the minRtt, but ignore ackDelay.
if latestRtt < cc.minRtt {
cc.minRtt = latestRtt
}
// Now reduce by ackDelay if it doesn't reduce the RTT below the minimum.
if latestRtt-cc.minRtt > ackDelay {
latestRtt -= ackDelay
// And update the maximum observed ACK delay.
if !lastPacket.ackOnly && ackDelay > cc.maxAckDelay {
cc.maxAckDelay = ackDelay
}
}
cc.updateRtt(latestRtt)
}
// find and proccess newly acked packets
for _, ackBlock := range acks {
for pn := ackBlock.lastPacket; pn > (ackBlock.lastPacket - ackBlock.count); pn-- {
cc.conn.log(logTypeCongestion, "Ack for pn %d received", pn)
_, present := cc.sentPackets[pn]
if present {
cc.conn.log(logTypeCongestion, "First ack for pn %d received", pn)
cc.onPacketAcked(pn)
}
}
}
cc.detectLostPackets()
cc.setLossDetectionAlarm()
}
func (cc *CongestionControllerIetf) setLostPacketHandler(handler func(pn uint64)) {
cc.lostPacketHandler = handler
}
func (cc *CongestionControllerIetf) updateRtt(latestRtt time.Duration) {
if cc.smoothedRtt == 0 {
cc.smoothedRtt = latestRtt
cc.rttVar = time.Duration(int64(latestRtt) / 2) | } else {
rttDelta := cc.smoothedRtt - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVar = time.Duration(int64(cc.rttVar)*3/4 + int64(rttDelta)*1/4)
cc.smoothedRtt = time.Duration(int64(cc.smoothedRtt)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT estimate: %v, variance: %v", cc.smoothedRtt, cc.rttVar)
}
func (cc *CongestionControllerIetf) updateRttTcp(latestRtt time.Duration) {
if cc.smoothedRttTcp == 0 {
cc.smoothedRttTcp = latestRtt
cc.rttVarTcp = time.Duration(int64(latestRtt) / 2)
} else {
rttDelta := cc.smoothedRttTcp - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVarTcp = time.Duration(int64(cc.rttVarTcp)*3/4 + int64(rttDelta)*3/4)
cc.smoothedRttTcp = time.Duration(int64(cc.smoothedRttTcp)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT(TCP) estimate: %v, variance: %v", cc.smoothedRttTcp, cc.rttVarTcp)
}
func (cc *CongestionControllerIetf) rto() time.Duration {
// max(SRTT + 4*RTTVAR + MaxAckDelay, minRTO)
rto := cc.smoothedRtt + 4*cc.rttVar + cc.maxAckDelay
if rto < kMinRTOTimeout {
return kMinRTOTimeout
}
return rto
}
func (cc *CongestionControllerIetf) onPacketAcked(pn uint64) {
cc.onPacketAckedCC(pn)
//TODO([email protected]) some RTO stuff here
delete(cc.sentPackets, pn)
}
func (cc *CongestionControllerIetf) setLossDetectionAlarm() {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) onLossDetectionAlarm() {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) detectLostPackets() {
var lostPackets []packetEntry
//TODO([email protected]) implement loss detection different from reorderingThreshold
for _, packet := range cc.sentPackets {
if (cc.largestAckedPacket > packet.pn) &&
(cc.largestAckedPacket-packet.pn > uint64(cc.reorderingThreshold)) {
lostPackets = append(lostPackets, packet)
}
}
if len(lostPackets) > 0 {
cc.onPacketsLost(lostPackets)
}
for _, packet := range lostPackets {
delete(cc.sentPackets, packet.pn)
}
}
func (cc *CongestionControllerIetf) onPacketSentCC(bytes_sent int) {
cc.bytesInFlight += bytes_sent
cc.conn.log(logTypeCongestion, "%d bytes added to bytesInFlight", bytes_sent)
}
func (cc *CongestionControllerIetf) onPacketAckedCC(pn uint64) {
cc.bytesInFlight -= cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "%d bytes from packet %d removed from bytesInFlight", cc.sentPackets[pn].bytes, pn)
if pn < cc.endOfRecovery {
// Do not increase window size during recovery
return
}
if cc.congestionWindow < cc.sstresh {
// Slow start
cc.congestionWindow += cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "PDV Slow Start: increasing window size with %d bytes to %d",
cc.sentPackets[pn].bytes, cc.congestionWindow)
} else {
// Congestion avoidance | random_line_split |
|
congestion.go | {
}
func (cc *CongestionControllerDummy) onAckReceived(acks ackRanges, delay time.Duration) {
}
func (cc *CongestionControllerDummy) bytesAllowedToSend() int {
/* return the the maximum int value */
return int(^uint(0) >> 1)
}
func (cc *CongestionControllerDummy) setLostPacketHandler(handler func(pn uint64)) {
}
func (cc *CongestionControllerDummy) rto() time.Duration |
/*
* draft-ietf-quic-recovery congestion controller
*/
type CongestionControllerIetf struct {
// Congestion control related
bytesInFlight int
congestionWindow int
endOfRecovery uint64
sstresh int
// Loss detection related
lossDetectionAlarm int //TODO([email protected]) set this to the right type
handshakeCount int
tlpCount int
rtoCount int
largestSendBeforeRto uint64
timeOfLastSentPacket time.Time
largestSendPacket uint64
largestAckedPacket uint64
maxAckDelay time.Duration
minRtt time.Duration
// largestRtt time.Duration
smoothedRtt time.Duration
rttVar time.Duration
smoothedRttTcp time.Duration
rttVarTcp time.Duration
reorderingThreshold int
timeReorderingFraction float32
lossTime time.Time
sentPackets map[uint64]packetEntry
// others
lostPacketHandler func(pn uint64)
conn *Connection
}
type packetEntry struct {
pn uint64
txTime time.Time
bytes int
ackOnly bool
}
func (cc *CongestionControllerIetf) onPacketSent(pn uint64, isAckOnly bool, sentBytes int) {
cc.timeOfLastSentPacket = time.Now()
cc.largestSendPacket = pn
packetData := packetEntry{pn, time.Now(), 0, isAckOnly}
cc.conn.log(logTypeCongestion, "Packet send pn: %d len:%d ackonly: %v\n", pn, sentBytes, isAckOnly)
if !isAckOnly {
cc.onPacketSentCC(sentBytes)
packetData.bytes = sentBytes
cc.setLossDetectionAlarm()
}
cc.sentPackets[pn] = packetData
}
// acks is received to be a sorted list, where the largest packet numbers are at the beginning
func (cc *CongestionControllerIetf) onAckReceived(acks ackRanges, ackDelay time.Duration) {
// keep track of largest packet acked overall
if acks[0].lastPacket > cc.largestAckedPacket {
cc.largestAckedPacket = acks[0].lastPacket
}
// If the largest acked is newly acked update rtt
lastPacket, present := cc.sentPackets[acks[0].lastPacket]
if present {
latestRtt := time.Since(cc.sentPackets[acks[0].lastPacket].txTime)
cc.conn.log(logTypeCongestion, "latestRtt: %v, ackDelay: %v", latestRtt, ackDelay)
cc.updateRttTcp(latestRtt)
// Update the minRtt, but ignore ackDelay.
if latestRtt < cc.minRtt {
cc.minRtt = latestRtt
}
// Now reduce by ackDelay if it doesn't reduce the RTT below the minimum.
if latestRtt-cc.minRtt > ackDelay {
latestRtt -= ackDelay
// And update the maximum observed ACK delay.
if !lastPacket.ackOnly && ackDelay > cc.maxAckDelay {
cc.maxAckDelay = ackDelay
}
}
cc.updateRtt(latestRtt)
}
// find and proccess newly acked packets
for _, ackBlock := range acks {
for pn := ackBlock.lastPacket; pn > (ackBlock.lastPacket - ackBlock.count); pn-- {
cc.conn.log(logTypeCongestion, "Ack for pn %d received", pn)
_, present := cc.sentPackets[pn]
if present {
cc.conn.log(logTypeCongestion, "First ack for pn %d received", pn)
cc.onPacketAcked(pn)
}
}
}
cc.detectLostPackets()
cc.setLossDetectionAlarm()
}
func (cc *CongestionControllerIetf) setLostPacketHandler(handler func(pn uint64)) {
cc.lostPacketHandler = handler
}
func (cc *CongestionControllerIetf) updateRtt(latestRtt time.Duration) {
if cc.smoothedRtt == 0 {
cc.smoothedRtt = latestRtt
cc.rttVar = time.Duration(int64(latestRtt) / 2)
} else {
rttDelta := cc.smoothedRtt - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVar = time.Duration(int64(cc.rttVar)*3/4 + int64(rttDelta)*1/4)
cc.smoothedRtt = time.Duration(int64(cc.smoothedRtt)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT estimate: %v, variance: %v", cc.smoothedRtt, cc.rttVar)
}
func (cc *CongestionControllerIetf) updateRttTcp(latestRtt time.Duration) {
if cc.smoothedRttTcp == 0 {
cc.smoothedRttTcp = latestRtt
cc.rttVarTcp = time.Duration(int64(latestRtt) / 2)
} else {
rttDelta := cc.smoothedRttTcp - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVarTcp = time.Duration(int64(cc.rttVarTcp)*3/4 + int64(rttDelta)*3/4)
cc.smoothedRttTcp = time.Duration(int64(cc.smoothedRttTcp)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT(TCP) estimate: %v, variance: %v", cc.smoothedRttTcp, cc.rttVarTcp)
}
func (cc *CongestionControllerIetf) rto() time.Duration {
// max(SRTT + 4*RTTVAR + MaxAckDelay, minRTO)
rto := cc.smoothedRtt + 4*cc.rttVar + cc.maxAckDelay
if rto < kMinRTOTimeout {
return kMinRTOTimeout
}
return rto
}
func (cc *CongestionControllerIetf) onPacketAcked(pn uint64) {
cc.onPacketAckedCC(pn)
//TODO([email protected]) some RTO stuff here
delete(cc.sentPackets, pn)
}
func (cc *CongestionControllerIetf) setLossDetectionAlarm() {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) onLossDetectionAlarm() {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) detectLostPackets() {
var lostPackets []packetEntry
//TODO([email protected]) implement loss detection different from reorderingThreshold
for _, packet := range cc.sentPackets {
if (cc.largestAckedPacket > packet.pn) &&
(cc.largestAckedPacket-packet.pn > uint64(cc.reorderingThreshold)) {
lostPackets = append(lostPackets, packet)
}
}
if len(lostPackets) > 0 {
cc.onPacketsLost(lostPackets)
}
for _, packet := range lostPackets {
delete(cc.sentPackets, packet.pn)
}
}
func (cc *CongestionControllerIetf) onPacketSentCC(bytes_sent int) {
cc.bytesInFlight += bytes_sent
cc.conn.log(logTypeCongestion, "%d bytes added to bytesInFlight", bytes_sent)
}
func (cc *CongestionControllerIetf) onPacketAckedCC(pn uint64) {
cc.bytesInFlight -= cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "%d bytes from packet %d removed from bytesInFlight", cc.sentPackets[pn].bytes, pn)
if pn < cc.endOfRecovery {
// Do not increase window size during recovery
return
}
if cc.congestionWindow < cc.sstresh {
// Slow start
cc.congestionWindow += cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "PDV Slow Start: increasing window size with %d bytes to %d",
cc.sentPackets[pn].bytes, cc.congestionWindow)
} else {
// Congestion | {
return kMinRTOTimeout
} | identifier_body |
congestion.go | ) {
}
func (cc *CongestionControllerDummy) onAckReceived(acks ackRanges, delay time.Duration) {
}
func (cc *CongestionControllerDummy) bytesAllowedToSend() int {
/* return the the maximum int value */
return int(^uint(0) >> 1)
}
func (cc *CongestionControllerDummy) setLostPacketHandler(handler func(pn uint64)) {
}
func (cc *CongestionControllerDummy) rto() time.Duration {
return kMinRTOTimeout
}
/*
* draft-ietf-quic-recovery congestion controller
*/
type CongestionControllerIetf struct {
// Congestion control related
bytesInFlight int
congestionWindow int
endOfRecovery uint64
sstresh int
// Loss detection related
lossDetectionAlarm int //TODO([email protected]) set this to the right type
handshakeCount int
tlpCount int
rtoCount int
largestSendBeforeRto uint64
timeOfLastSentPacket time.Time
largestSendPacket uint64
largestAckedPacket uint64
maxAckDelay time.Duration
minRtt time.Duration
// largestRtt time.Duration
smoothedRtt time.Duration
rttVar time.Duration
smoothedRttTcp time.Duration
rttVarTcp time.Duration
reorderingThreshold int
timeReorderingFraction float32
lossTime time.Time
sentPackets map[uint64]packetEntry
// others
lostPacketHandler func(pn uint64)
conn *Connection
}
type packetEntry struct {
pn uint64
txTime time.Time
bytes int
ackOnly bool
}
func (cc *CongestionControllerIetf) onPacketSent(pn uint64, isAckOnly bool, sentBytes int) {
cc.timeOfLastSentPacket = time.Now()
cc.largestSendPacket = pn
packetData := packetEntry{pn, time.Now(), 0, isAckOnly}
cc.conn.log(logTypeCongestion, "Packet send pn: %d len:%d ackonly: %v\n", pn, sentBytes, isAckOnly)
if !isAckOnly {
cc.onPacketSentCC(sentBytes)
packetData.bytes = sentBytes
cc.setLossDetectionAlarm()
}
cc.sentPackets[pn] = packetData
}
// acks is received to be a sorted list, where the largest packet numbers are at the beginning
func (cc *CongestionControllerIetf) onAckReceived(acks ackRanges, ackDelay time.Duration) {
// keep track of largest packet acked overall
if acks[0].lastPacket > cc.largestAckedPacket {
cc.largestAckedPacket = acks[0].lastPacket
}
// If the largest acked is newly acked update rtt
lastPacket, present := cc.sentPackets[acks[0].lastPacket]
if present {
latestRtt := time.Since(cc.sentPackets[acks[0].lastPacket].txTime)
cc.conn.log(logTypeCongestion, "latestRtt: %v, ackDelay: %v", latestRtt, ackDelay)
cc.updateRttTcp(latestRtt)
// Update the minRtt, but ignore ackDelay.
if latestRtt < cc.minRtt {
cc.minRtt = latestRtt
}
// Now reduce by ackDelay if it doesn't reduce the RTT below the minimum.
if latestRtt-cc.minRtt > ackDelay {
latestRtt -= ackDelay
// And update the maximum observed ACK delay.
if !lastPacket.ackOnly && ackDelay > cc.maxAckDelay {
cc.maxAckDelay = ackDelay
}
}
cc.updateRtt(latestRtt)
}
// find and proccess newly acked packets
for _, ackBlock := range acks {
for pn := ackBlock.lastPacket; pn > (ackBlock.lastPacket - ackBlock.count); pn-- {
cc.conn.log(logTypeCongestion, "Ack for pn %d received", pn)
_, present := cc.sentPackets[pn]
if present {
cc.conn.log(logTypeCongestion, "First ack for pn %d received", pn)
cc.onPacketAcked(pn)
}
}
}
cc.detectLostPackets()
cc.setLossDetectionAlarm()
}
func (cc *CongestionControllerIetf) setLostPacketHandler(handler func(pn uint64)) {
cc.lostPacketHandler = handler
}
func (cc *CongestionControllerIetf) updateRtt(latestRtt time.Duration) {
if cc.smoothedRtt == 0 {
cc.smoothedRtt = latestRtt
cc.rttVar = time.Duration(int64(latestRtt) / 2)
} else {
rttDelta := cc.smoothedRtt - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVar = time.Duration(int64(cc.rttVar)*3/4 + int64(rttDelta)*1/4)
cc.smoothedRtt = time.Duration(int64(cc.smoothedRtt)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT estimate: %v, variance: %v", cc.smoothedRtt, cc.rttVar)
}
func (cc *CongestionControllerIetf) updateRttTcp(latestRtt time.Duration) {
if cc.smoothedRttTcp == 0 {
cc.smoothedRttTcp = latestRtt
cc.rttVarTcp = time.Duration(int64(latestRtt) / 2)
} else {
rttDelta := cc.smoothedRttTcp - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVarTcp = time.Duration(int64(cc.rttVarTcp)*3/4 + int64(rttDelta)*3/4)
cc.smoothedRttTcp = time.Duration(int64(cc.smoothedRttTcp)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT(TCP) estimate: %v, variance: %v", cc.smoothedRttTcp, cc.rttVarTcp)
}
func (cc *CongestionControllerIetf) rto() time.Duration {
// max(SRTT + 4*RTTVAR + MaxAckDelay, minRTO)
rto := cc.smoothedRtt + 4*cc.rttVar + cc.maxAckDelay
if rto < kMinRTOTimeout {
return kMinRTOTimeout
}
return rto
}
func (cc *CongestionControllerIetf) onPacketAcked(pn uint64) {
cc.onPacketAckedCC(pn)
//TODO([email protected]) some RTO stuff here
delete(cc.sentPackets, pn)
}
func (cc *CongestionControllerIetf) setLossDetectionAlarm() {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) | () {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) detectLostPackets() {
var lostPackets []packetEntry
//TODO([email protected]) implement loss detection different from reorderingThreshold
for _, packet := range cc.sentPackets {
if (cc.largestAckedPacket > packet.pn) &&
(cc.largestAckedPacket-packet.pn > uint64(cc.reorderingThreshold)) {
lostPackets = append(lostPackets, packet)
}
}
if len(lostPackets) > 0 {
cc.onPacketsLost(lostPackets)
}
for _, packet := range lostPackets {
delete(cc.sentPackets, packet.pn)
}
}
func (cc *CongestionControllerIetf) onPacketSentCC(bytes_sent int) {
cc.bytesInFlight += bytes_sent
cc.conn.log(logTypeCongestion, "%d bytes added to bytesInFlight", bytes_sent)
}
func (cc *CongestionControllerIetf) onPacketAckedCC(pn uint64) {
cc.bytesInFlight -= cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "%d bytes from packet %d removed from bytesInFlight", cc.sentPackets[pn].bytes, pn)
if pn < cc.endOfRecovery {
// Do not increase window size during recovery
return
}
if cc.congestionWindow < cc.sstresh {
// Slow start
cc.congestionWindow += cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "PDV Slow Start: increasing window size with %d bytes to %d",
cc.sentPackets[pn].bytes, cc.congestionWindow)
} else {
// Congestion | onLossDetectionAlarm | identifier_name |
congestion.go | ) {
}
func (cc *CongestionControllerDummy) onAckReceived(acks ackRanges, delay time.Duration) {
}
func (cc *CongestionControllerDummy) bytesAllowedToSend() int {
/* return the the maximum int value */
return int(^uint(0) >> 1)
}
func (cc *CongestionControllerDummy) setLostPacketHandler(handler func(pn uint64)) {
}
func (cc *CongestionControllerDummy) rto() time.Duration {
return kMinRTOTimeout
}
/*
* draft-ietf-quic-recovery congestion controller
*/
type CongestionControllerIetf struct {
// Congestion control related
bytesInFlight int
congestionWindow int
endOfRecovery uint64
sstresh int
// Loss detection related
lossDetectionAlarm int //TODO([email protected]) set this to the right type
handshakeCount int
tlpCount int
rtoCount int
largestSendBeforeRto uint64
timeOfLastSentPacket time.Time
largestSendPacket uint64
largestAckedPacket uint64
maxAckDelay time.Duration
minRtt time.Duration
// largestRtt time.Duration
smoothedRtt time.Duration
rttVar time.Duration
smoothedRttTcp time.Duration
rttVarTcp time.Duration
reorderingThreshold int
timeReorderingFraction float32
lossTime time.Time
sentPackets map[uint64]packetEntry
// others
lostPacketHandler func(pn uint64)
conn *Connection
}
type packetEntry struct {
pn uint64
txTime time.Time
bytes int
ackOnly bool
}
func (cc *CongestionControllerIetf) onPacketSent(pn uint64, isAckOnly bool, sentBytes int) {
cc.timeOfLastSentPacket = time.Now()
cc.largestSendPacket = pn
packetData := packetEntry{pn, time.Now(), 0, isAckOnly}
cc.conn.log(logTypeCongestion, "Packet send pn: %d len:%d ackonly: %v\n", pn, sentBytes, isAckOnly)
if !isAckOnly {
cc.onPacketSentCC(sentBytes)
packetData.bytes = sentBytes
cc.setLossDetectionAlarm()
}
cc.sentPackets[pn] = packetData
}
// acks is received to be a sorted list, where the largest packet numbers are at the beginning
func (cc *CongestionControllerIetf) onAckReceived(acks ackRanges, ackDelay time.Duration) {
// keep track of largest packet acked overall
if acks[0].lastPacket > cc.largestAckedPacket {
cc.largestAckedPacket = acks[0].lastPacket
}
// If the largest acked is newly acked update rtt
lastPacket, present := cc.sentPackets[acks[0].lastPacket]
if present {
latestRtt := time.Since(cc.sentPackets[acks[0].lastPacket].txTime)
cc.conn.log(logTypeCongestion, "latestRtt: %v, ackDelay: %v", latestRtt, ackDelay)
cc.updateRttTcp(latestRtt)
// Update the minRtt, but ignore ackDelay.
if latestRtt < cc.minRtt {
cc.minRtt = latestRtt
}
// Now reduce by ackDelay if it doesn't reduce the RTT below the minimum.
if latestRtt-cc.minRtt > ackDelay {
latestRtt -= ackDelay
// And update the maximum observed ACK delay.
if !lastPacket.ackOnly && ackDelay > cc.maxAckDelay {
cc.maxAckDelay = ackDelay
}
}
cc.updateRtt(latestRtt)
}
// find and proccess newly acked packets
for _, ackBlock := range acks {
for pn := ackBlock.lastPacket; pn > (ackBlock.lastPacket - ackBlock.count); pn-- {
cc.conn.log(logTypeCongestion, "Ack for pn %d received", pn)
_, present := cc.sentPackets[pn]
if present {
cc.conn.log(logTypeCongestion, "First ack for pn %d received", pn)
cc.onPacketAcked(pn)
}
}
}
cc.detectLostPackets()
cc.setLossDetectionAlarm()
}
func (cc *CongestionControllerIetf) setLostPacketHandler(handler func(pn uint64)) {
cc.lostPacketHandler = handler
}
func (cc *CongestionControllerIetf) updateRtt(latestRtt time.Duration) {
if cc.smoothedRtt == 0 | else {
rttDelta := cc.smoothedRtt - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVar = time.Duration(int64(cc.rttVar)*3/4 + int64(rttDelta)*1/4)
cc.smoothedRtt = time.Duration(int64(cc.smoothedRtt)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT estimate: %v, variance: %v", cc.smoothedRtt, cc.rttVar)
}
func (cc *CongestionControllerIetf) updateRttTcp(latestRtt time.Duration) {
if cc.smoothedRttTcp == 0 {
cc.smoothedRttTcp = latestRtt
cc.rttVarTcp = time.Duration(int64(latestRtt) / 2)
} else {
rttDelta := cc.smoothedRttTcp - latestRtt
if rttDelta < 0 {
rttDelta = -rttDelta
}
cc.rttVarTcp = time.Duration(int64(cc.rttVarTcp)*3/4 + int64(rttDelta)*3/4)
cc.smoothedRttTcp = time.Duration(int64(cc.smoothedRttTcp)*7/8 + int64(latestRtt)*1/8)
}
cc.conn.log(logTypeCongestion, "New RTT(TCP) estimate: %v, variance: %v", cc.smoothedRttTcp, cc.rttVarTcp)
}
func (cc *CongestionControllerIetf) rto() time.Duration {
// max(SRTT + 4*RTTVAR + MaxAckDelay, minRTO)
rto := cc.smoothedRtt + 4*cc.rttVar + cc.maxAckDelay
if rto < kMinRTOTimeout {
return kMinRTOTimeout
}
return rto
}
func (cc *CongestionControllerIetf) onPacketAcked(pn uint64) {
cc.onPacketAckedCC(pn)
//TODO([email protected]) some RTO stuff here
delete(cc.sentPackets, pn)
}
func (cc *CongestionControllerIetf) setLossDetectionAlarm() {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) onLossDetectionAlarm() {
//TODO([email protected])
}
func (cc *CongestionControllerIetf) detectLostPackets() {
var lostPackets []packetEntry
//TODO([email protected]) implement loss detection different from reorderingThreshold
for _, packet := range cc.sentPackets {
if (cc.largestAckedPacket > packet.pn) &&
(cc.largestAckedPacket-packet.pn > uint64(cc.reorderingThreshold)) {
lostPackets = append(lostPackets, packet)
}
}
if len(lostPackets) > 0 {
cc.onPacketsLost(lostPackets)
}
for _, packet := range lostPackets {
delete(cc.sentPackets, packet.pn)
}
}
func (cc *CongestionControllerIetf) onPacketSentCC(bytes_sent int) {
cc.bytesInFlight += bytes_sent
cc.conn.log(logTypeCongestion, "%d bytes added to bytesInFlight", bytes_sent)
}
func (cc *CongestionControllerIetf) onPacketAckedCC(pn uint64) {
cc.bytesInFlight -= cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "%d bytes from packet %d removed from bytesInFlight", cc.sentPackets[pn].bytes, pn)
if pn < cc.endOfRecovery {
// Do not increase window size during recovery
return
}
if cc.congestionWindow < cc.sstresh {
// Slow start
cc.congestionWindow += cc.sentPackets[pn].bytes
cc.conn.log(logTypeCongestion, "PDV Slow Start: increasing window size with %d bytes to %d",
cc.sentPackets[pn].bytes, cc.congestionWindow)
} else {
// Congestion | {
cc.smoothedRtt = latestRtt
cc.rttVar = time.Duration(int64(latestRtt) / 2)
} | conditional_block |
Leanote4MD.py | ['Ok']:
return True
else:
print json_object['Msg']
return False
else:
return True
def req_get(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.get(leanote_host + '/api/' + url, params = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
elif type=='image':
i = Image.open(StringIO(r.content))
return i
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
def req_post(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.post(leanote_host + '/api/' + url, data = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
#ret leanote_token
def login(email, pwd):
param = {
'email': email,
'pwd': pwd,
}
r = req_get('auth/login', param, token=False)
if r:
print 'Login success! Welcome %s (%s)' %(r['Username'], r['Email'])
return r['Token']
else:
print 'Login fail! Start again.'
exit()
def logout():
return req_get('auth/logout')
#ret dict(notebookId: type.Notebook}
def getNotebooks(includeTrash = False):
r = req_get('notebook/getNotebooks')
if r:
if includeTrash:
return {notebook['NotebookId'] : notebook for notebook in r}
else:
return {notebook['NotebookId'] : notebook for notebook in r if not notebook['IsDeleted']}
else:
return none
#ret [type.Note], which contains noteId, and note meta data
def getNotesMeta(notebookId):
param = {
'notebookId': notebookId,
} | def getNoteDetail(noteId):
param = {
'noteId': noteId,
}
return req_get('note/getNoteAndContent', param)
def getImage(fileId):
param = {
'fileId': fileId,
}
return req_get('file/getImage', param, type = 'image')
def addNotebook(title='Import', parentId='', seq=-1):
param = {
'title': title,
'parentNotebookId': parentId,
'seq' : seq
}
return req_post('notebook/addNotebook', param)
def addNote(NotebookId, Title, Content, Tags=[], IsMarkdown = True, Abstract= '', Files=[]):
param = {
'NotebookId': NotebookId,
'Title': Title,
'Content': Content,
'Tags[]': Tags,
'IsMarkdown': IsMarkdown,
'Abstract': Abstract,
#'Files' : seq
}
return req_post('note/addNote', param)
def readFromFile(filename):
import yaml
with open (filename) as file:
file_meta = ''
file_content = ''
meta_flag=False
for line in file:
#print line
if meta_flag:
file_content += line
else:
if line.find('---')>-1:
meta_flag = True
else:
file_meta += line
#print meta
if not meta_flag:
file_content = file_meta
file_meta = ''
if meta_flag:
meta = yaml.load(file_meta)
else:
meta = {}
return file_content, meta
def saveToFile(notes, noteBooks, path = '.'):
unique_noteTitle = set()
for note in notes:
if note['Title'] == '':
filename = note['NoteId']
else:
filename = note['Title']
if filename in unique_noteTitle:
filename='%s_%s' %(filename, note['NoteId'])
else:
unique_noteTitle.add(filename)
if note['IsMarkdown']:
filename += '.md'
else:
filename += '.txt'
try:
with open(path + '/' + filename, 'w') as file:
print 'write file: %s' %filename
file.write('title: %s\n' %note['Title'].encode('utf-8'))
date = dateutil.parser.parse(note['CreatedTime'])
file.write('date: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
date = dateutil.parser.parse(note['UpdatedTime'])
file.write('updated: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
if note['Tags']:
if len(note['Tags']) == 1:
if note['Tags'][0]:
file.write('tags:\n')
for tag in note['Tags']:
file.write('- %s\n' %tag.encode('utf-8'))
category = []
current_notebook = note['NotebookId']
category.append(noteBooks[current_notebook]['Title'])
while noteBooks[current_notebook]['ParentNotebookId'] != '':
category.append(noteBooks[noteBooks[current_notebook]['ParentNotebookId']]['Title'])
current_notebook = noteBooks[current_notebook]['ParentNotebookId']
file.write('categories:\n')
category.reverse()
for cat in category:
file.write('- %s\n' %cat.encode('utf-8'))
file.write('---\n')
file.write('%s' %note['Content'].encode('utf-8'))
file.close()
if note['Files']:
if len(note['Files']) > 0:
for attach in note['Files']:
if not attach['IsAttach']:
i = getImage(attach['FileId'])
print 'saving its image: %s.%s' %(attach['FileId'], i.format)
i.save(attach['FileId'] + '.' + i.format)
except Exception as e:
logging.exception(e)
print "error: ", filename
def LeanoteExportToMD(path = '.'):
print 'Reading your notebooks...'
noteBooks = getNotebooks()
#get not deleted notes list
notes=[]
for notebook in noteBooks.values():
if not notebook['IsDeleted']:
notesMeta = getNotesMeta(notebook['NotebookId'])
for noteMeta in notesMeta:
if not noteMeta['IsTrash']:
note = getNoteDetail(noteMeta['NoteId'])
notes.append(note)
print 'found %d notes' %len(notes)
#write file
saveToFile(notes, noteBooks, path = path)
logout()
print 'all done, bye~'
def LeanoteImportFromMD(path = '.'):
filelist = os.listdir(path)
filelist = [file for file in filelist if file.find('.md')>-1 or file.find('.txt')>-1]
importedNotebookTitleMapID = {}
ret = addNotebook(title='imported_note', parentId='', seq=-1)
if ret:
print 'imporing into a new notebook: %s' %ret['Title']
importedNotebookTitleMapID['import'] = ret['NotebookId']
for filename in filelist:
content, meta = readFromFile(path + '/' + filename)
parentTitle='import'
currentTitle=''
if not meta.get('categories'):
categories=['import']
else:
categories= meta.get('categories')
for cat in categories:
currentTitle=cat
if currentTitle in importedNotebookTitleMapID.keys():
parentTitle=currentTitle
else:
ret = addNotebook(title = currentTitle, parentId = importedNotebookTitleMapID[parentTitle])
importedNotebookTitleMapID[currentTitle] = ret['NotebookId']
parentTitle=currentTitle
if not meta.get('title'):
meta['title'] = filename.replace('.md','').replace('.txt','')
importedNote = addNote(NotebookId=importedNotebookTitleMapID[currentTitle | return req_get('note/getNotes', param)
#ret type.NoteContent | random_line_split |
Leanote4MD.py | Ok']:
return True
else:
print json_object['Msg']
return False
else:
return True
def req_get(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.get(leanote_host + '/api/' + url, params = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
elif type=='image':
i = Image.open(StringIO(r.content))
return i
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
def req_post(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.post(leanote_host + '/api/' + url, data = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
#ret leanote_token
def login(email, pwd):
param = {
'email': email,
'pwd': pwd,
}
r = req_get('auth/login', param, token=False)
if r:
print 'Login success! Welcome %s (%s)' %(r['Username'], r['Email'])
return r['Token']
else:
print 'Login fail! Start again.'
exit()
def logout():
return req_get('auth/logout')
#ret dict(notebookId: type.Notebook}
def getNotebooks(includeTrash = False):
r = req_get('notebook/getNotebooks')
if r:
if includeTrash:
return {notebook['NotebookId'] : notebook for notebook in r}
else:
return {notebook['NotebookId'] : notebook for notebook in r if not notebook['IsDeleted']}
else:
return none
#ret [type.Note], which contains noteId, and note meta data
def getNotesMeta(notebookId):
param = {
'notebookId': notebookId,
}
return req_get('note/getNotes', param)
#ret type.NoteContent
def getNoteDetail(noteId):
param = {
'noteId': noteId,
}
return req_get('note/getNoteAndContent', param)
def getImage(fileId):
param = {
'fileId': fileId,
}
return req_get('file/getImage', param, type = 'image')
def addNotebook(title='Import', parentId='', seq=-1):
param = {
'title': title,
'parentNotebookId': parentId,
'seq' : seq
}
return req_post('notebook/addNotebook', param)
def addNote(NotebookId, Title, Content, Tags=[], IsMarkdown = True, Abstract= '', Files=[]):
param = {
'NotebookId': NotebookId,
'Title': Title,
'Content': Content,
'Tags[]': Tags,
'IsMarkdown': IsMarkdown,
'Abstract': Abstract,
#'Files' : seq
}
return req_post('note/addNote', param)
def readFromFile(filename):
import yaml
with open (filename) as file:
file_meta = ''
file_content = ''
meta_flag=False
for line in file:
#print line
|
if not meta_flag:
file_content = file_meta
file_meta = ''
if meta_flag:
meta = yaml.load(file_meta)
else:
meta = {}
return file_content, meta
def saveToFile(notes, noteBooks, path = '.'):
unique_noteTitle = set()
for note in notes:
if note['Title'] == '':
filename = note['NoteId']
else:
filename = note['Title']
if filename in unique_noteTitle:
filename='%s_%s' %(filename, note['NoteId'])
else:
unique_noteTitle.add(filename)
if note['IsMarkdown']:
filename += '.md'
else:
filename += '.txt'
try:
with open(path + '/' + filename, 'w') as file:
print 'write file: %s' %filename
file.write('title: %s\n' %note['Title'].encode('utf-8'))
date = dateutil.parser.parse(note['CreatedTime'])
file.write('date: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
date = dateutil.parser.parse(note['UpdatedTime'])
file.write('updated: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
if note['Tags']:
if len(note['Tags']) == 1:
if note['Tags'][0]:
file.write('tags:\n')
for tag in note['Tags']:
file.write('- %s\n' %tag.encode('utf-8'))
category = []
current_notebook = note['NotebookId']
category.append(noteBooks[current_notebook]['Title'])
while noteBooks[current_notebook]['ParentNotebookId'] != '':
category.append(noteBooks[noteBooks[current_notebook]['ParentNotebookId']]['Title'])
current_notebook = noteBooks[current_notebook]['ParentNotebookId']
file.write('categories:\n')
category.reverse()
for cat in category:
file.write('- %s\n' %cat.encode('utf-8'))
file.write('---\n')
file.write('%s' %note['Content'].encode('utf-8'))
file.close()
if note['Files']:
if len(note['Files']) > 0:
for attach in note['Files']:
if not attach['IsAttach']:
i = getImage(attach['FileId'])
print 'saving its image: %s.%s' %(attach['FileId'], i.format)
i.save(attach['FileId'] + '.' + i.format)
except Exception as e:
logging.exception(e)
print "error: ", filename
def LeanoteExportToMD(path = '.'):
print 'Reading your notebooks...'
noteBooks = getNotebooks()
#get not deleted notes list
notes=[]
for notebook in noteBooks.values():
if not notebook['IsDeleted']:
notesMeta = getNotesMeta(notebook['NotebookId'])
for noteMeta in notesMeta:
if not noteMeta['IsTrash']:
note = getNoteDetail(noteMeta['NoteId'])
notes.append(note)
print 'found %d notes' %len(notes)
#write file
saveToFile(notes, noteBooks, path = path)
logout()
print 'all done, bye~'
def LeanoteImportFromMD(path = '.'):
filelist = os.listdir(path)
filelist = [file for file in filelist if file.find('.md')>-1 or file.find('.txt')>-1]
importedNotebookTitleMapID = {}
ret = addNotebook(title='imported_note', parentId='', seq=-1)
if ret:
print 'imporing into a new notebook: %s' %ret['Title']
importedNotebookTitleMapID['import'] = ret['NotebookId']
for filename in filelist:
content, meta = readFromFile(path + '/' + filename)
parentTitle='import'
currentTitle=''
if not meta.get('categories'):
categories=['import']
else:
categories= meta.get('categories')
for cat in categories:
currentTitle=cat
if currentTitle in importedNotebookTitleMapID.keys():
parentTitle=currentTitle
else:
ret = addNotebook(title = currentTitle, parentId = importedNotebookTitleMapID[parentTitle])
importedNotebookTitleMapID[currentTitle] = ret['NotebookId']
parentTitle=currentTitle
if not meta.get('title'):
meta['title'] = filename.replace('.md','').replace('.txt','')
importedNote = addNote(NotebookId=importedNotebookTitleMapID[currentTitle | if meta_flag:
file_content += line
else:
if line.find('---')>-1:
meta_flag = True
else:
file_meta += line
#print meta | conditional_block |
Leanote4MD.py | Ok']:
return True
else:
print json_object['Msg']
return False
else:
return True
def req_get(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.get(leanote_host + '/api/' + url, params = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
elif type=='image':
i = Image.open(StringIO(r.content))
return i
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
def req_post(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.post(leanote_host + '/api/' + url, data = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
#ret leanote_token
def login(email, pwd):
param = {
'email': email,
'pwd': pwd,
}
r = req_get('auth/login', param, token=False)
if r:
print 'Login success! Welcome %s (%s)' %(r['Username'], r['Email'])
return r['Token']
else:
print 'Login fail! Start again.'
exit()
def logout():
return req_get('auth/logout')
#ret dict(notebookId: type.Notebook}
def getNotebooks(includeTrash = False):
r = req_get('notebook/getNotebooks')
if r:
if includeTrash:
return {notebook['NotebookId'] : notebook for notebook in r}
else:
return {notebook['NotebookId'] : notebook for notebook in r if not notebook['IsDeleted']}
else:
return none
#ret [type.Note], which contains noteId, and note meta data
def getNotesMeta(notebookId):
param = {
'notebookId': notebookId,
}
return req_get('note/getNotes', param)
#ret type.NoteContent
def getNoteDetail(noteId):
param = {
'noteId': noteId,
}
return req_get('note/getNoteAndContent', param)
def getImage(fileId):
param = {
'fileId': fileId,
}
return req_get('file/getImage', param, type = 'image')
def addNotebook(title='Import', parentId='', seq=-1):
|
def addNote(NotebookId, Title, Content, Tags=[], IsMarkdown = True, Abstract= '', Files=[]):
param = {
'NotebookId': NotebookId,
'Title': Title,
'Content': Content,
'Tags[]': Tags,
'IsMarkdown': IsMarkdown,
'Abstract': Abstract,
#'Files' : seq
}
return req_post('note/addNote', param)
def readFromFile(filename):
import yaml
with open (filename) as file:
file_meta = ''
file_content = ''
meta_flag=False
for line in file:
#print line
if meta_flag:
file_content += line
else:
if line.find('---')>-1:
meta_flag = True
else:
file_meta += line
#print meta
if not meta_flag:
file_content = file_meta
file_meta = ''
if meta_flag:
meta = yaml.load(file_meta)
else:
meta = {}
return file_content, meta
def saveToFile(notes, noteBooks, path = '.'):
unique_noteTitle = set()
for note in notes:
if note['Title'] == '':
filename = note['NoteId']
else:
filename = note['Title']
if filename in unique_noteTitle:
filename='%s_%s' %(filename, note['NoteId'])
else:
unique_noteTitle.add(filename)
if note['IsMarkdown']:
filename += '.md'
else:
filename += '.txt'
try:
with open(path + '/' + filename, 'w') as file:
print 'write file: %s' %filename
file.write('title: %s\n' %note['Title'].encode('utf-8'))
date = dateutil.parser.parse(note['CreatedTime'])
file.write('date: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
date = dateutil.parser.parse(note['UpdatedTime'])
file.write('updated: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
if note['Tags']:
if len(note['Tags']) == 1:
if note['Tags'][0]:
file.write('tags:\n')
for tag in note['Tags']:
file.write('- %s\n' %tag.encode('utf-8'))
category = []
current_notebook = note['NotebookId']
category.append(noteBooks[current_notebook]['Title'])
while noteBooks[current_notebook]['ParentNotebookId'] != '':
category.append(noteBooks[noteBooks[current_notebook]['ParentNotebookId']]['Title'])
current_notebook = noteBooks[current_notebook]['ParentNotebookId']
file.write('categories:\n')
category.reverse()
for cat in category:
file.write('- %s\n' %cat.encode('utf-8'))
file.write('---\n')
file.write('%s' %note['Content'].encode('utf-8'))
file.close()
if note['Files']:
if len(note['Files']) > 0:
for attach in note['Files']:
if not attach['IsAttach']:
i = getImage(attach['FileId'])
print 'saving its image: %s.%s' %(attach['FileId'], i.format)
i.save(attach['FileId'] + '.' + i.format)
except Exception as e:
logging.exception(e)
print "error: ", filename
def LeanoteExportToMD(path = '.'):
print 'Reading your notebooks...'
noteBooks = getNotebooks()
#get not deleted notes list
notes=[]
for notebook in noteBooks.values():
if not notebook['IsDeleted']:
notesMeta = getNotesMeta(notebook['NotebookId'])
for noteMeta in notesMeta:
if not noteMeta['IsTrash']:
note = getNoteDetail(noteMeta['NoteId'])
notes.append(note)
print 'found %d notes' %len(notes)
#write file
saveToFile(notes, noteBooks, path = path)
logout()
print 'all done, bye~'
def LeanoteImportFromMD(path = '.'):
filelist = os.listdir(path)
filelist = [file for file in filelist if file.find('.md')>-1 or file.find('.txt')>-1]
importedNotebookTitleMapID = {}
ret = addNotebook(title='imported_note', parentId='', seq=-1)
if ret:
print 'imporing into a new notebook: %s' %ret['Title']
importedNotebookTitleMapID['import'] = ret['NotebookId']
for filename in filelist:
content, meta = readFromFile(path + '/' + filename)
parentTitle='import'
currentTitle=''
if not meta.get('categories'):
categories=['import']
else:
categories= meta.get('categories')
for cat in categories:
currentTitle=cat
if currentTitle in importedNotebookTitleMapID.keys():
parentTitle=currentTitle
else:
ret = addNotebook(title = currentTitle, parentId = importedNotebookTitleMapID[parentTitle])
importedNotebookTitleMapID[currentTitle] = ret['NotebookId']
parentTitle=currentTitle
if not meta.get('title'):
meta['title'] = filename.replace('.md','').replace('.txt','')
importedNote = addNote(NotebookId=importedNotebookTitleMapID[current | param = {
'title': title,
'parentNotebookId': parentId,
'seq' : seq
}
return req_post('notebook/addNotebook', param) | identifier_body |
Leanote4MD.py | Ok']:
return True
else:
print json_object['Msg']
return False
else:
return True
def req_get(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.get(leanote_host + '/api/' + url, params = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
elif type=='image':
i = Image.open(StringIO(r.content))
return i
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
def req_post(url, param = '', type = 'json', token = True):
if token:
if param:
param.update({'token': leanote_token})
else:
param={'token': leanote_token}
s = requests.Session()
if leanote_host.startswith('https'):
s.mount('https://', SSLAdapter(ssl.PROTOCOL_TLSv1))
r = s.post(leanote_host + '/api/' + url, data = param, verify=False)
if r.status_code == requests.codes.ok:
if type=='json':
if is_ok(r.text):
rj = json.loads(r.text)
# if 'Msg' in rj:
# rj=rj['Msg']
return rj
else:
print '[Err] requests to url %s fail' %(r.url)
return None
else:
print '[Err] connect to url %s fail, error code %d ' %(r.url, r.status_cde)
return None
#ret leanote_token
def login(email, pwd):
param = {
'email': email,
'pwd': pwd,
}
r = req_get('auth/login', param, token=False)
if r:
print 'Login success! Welcome %s (%s)' %(r['Username'], r['Email'])
return r['Token']
else:
print 'Login fail! Start again.'
exit()
def logout():
return req_get('auth/logout')
#ret dict(notebookId: type.Notebook}
def getNotebooks(includeTrash = False):
r = req_get('notebook/getNotebooks')
if r:
if includeTrash:
return {notebook['NotebookId'] : notebook for notebook in r}
else:
return {notebook['NotebookId'] : notebook for notebook in r if not notebook['IsDeleted']}
else:
return none
#ret [type.Note], which contains noteId, and note meta data
def getNotesMeta(notebookId):
param = {
'notebookId': notebookId,
}
return req_get('note/getNotes', param)
#ret type.NoteContent
def getNoteDetail(noteId):
param = {
'noteId': noteId,
}
return req_get('note/getNoteAndContent', param)
def | (fileId):
param = {
'fileId': fileId,
}
return req_get('file/getImage', param, type = 'image')
def addNotebook(title='Import', parentId='', seq=-1):
param = {
'title': title,
'parentNotebookId': parentId,
'seq' : seq
}
return req_post('notebook/addNotebook', param)
def addNote(NotebookId, Title, Content, Tags=[], IsMarkdown = True, Abstract= '', Files=[]):
param = {
'NotebookId': NotebookId,
'Title': Title,
'Content': Content,
'Tags[]': Tags,
'IsMarkdown': IsMarkdown,
'Abstract': Abstract,
#'Files' : seq
}
return req_post('note/addNote', param)
def readFromFile(filename):
import yaml
with open (filename) as file:
file_meta = ''
file_content = ''
meta_flag=False
for line in file:
#print line
if meta_flag:
file_content += line
else:
if line.find('---')>-1:
meta_flag = True
else:
file_meta += line
#print meta
if not meta_flag:
file_content = file_meta
file_meta = ''
if meta_flag:
meta = yaml.load(file_meta)
else:
meta = {}
return file_content, meta
def saveToFile(notes, noteBooks, path = '.'):
unique_noteTitle = set()
for note in notes:
if note['Title'] == '':
filename = note['NoteId']
else:
filename = note['Title']
if filename in unique_noteTitle:
filename='%s_%s' %(filename, note['NoteId'])
else:
unique_noteTitle.add(filename)
if note['IsMarkdown']:
filename += '.md'
else:
filename += '.txt'
try:
with open(path + '/' + filename, 'w') as file:
print 'write file: %s' %filename
file.write('title: %s\n' %note['Title'].encode('utf-8'))
date = dateutil.parser.parse(note['CreatedTime'])
file.write('date: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
date = dateutil.parser.parse(note['UpdatedTime'])
file.write('updated: %s\n' %datetime.strftime(date.astimezone(local_zone), '%Y/%m/%d %H:%M:%S'))
if note['Tags']:
if len(note['Tags']) == 1:
if note['Tags'][0]:
file.write('tags:\n')
for tag in note['Tags']:
file.write('- %s\n' %tag.encode('utf-8'))
category = []
current_notebook = note['NotebookId']
category.append(noteBooks[current_notebook]['Title'])
while noteBooks[current_notebook]['ParentNotebookId'] != '':
category.append(noteBooks[noteBooks[current_notebook]['ParentNotebookId']]['Title'])
current_notebook = noteBooks[current_notebook]['ParentNotebookId']
file.write('categories:\n')
category.reverse()
for cat in category:
file.write('- %s\n' %cat.encode('utf-8'))
file.write('---\n')
file.write('%s' %note['Content'].encode('utf-8'))
file.close()
if note['Files']:
if len(note['Files']) > 0:
for attach in note['Files']:
if not attach['IsAttach']:
i = getImage(attach['FileId'])
print 'saving its image: %s.%s' %(attach['FileId'], i.format)
i.save(attach['FileId'] + '.' + i.format)
except Exception as e:
logging.exception(e)
print "error: ", filename
def LeanoteExportToMD(path = '.'):
print 'Reading your notebooks...'
noteBooks = getNotebooks()
#get not deleted notes list
notes=[]
for notebook in noteBooks.values():
if not notebook['IsDeleted']:
notesMeta = getNotesMeta(notebook['NotebookId'])
for noteMeta in notesMeta:
if not noteMeta['IsTrash']:
note = getNoteDetail(noteMeta['NoteId'])
notes.append(note)
print 'found %d notes' %len(notes)
#write file
saveToFile(notes, noteBooks, path = path)
logout()
print 'all done, bye~'
def LeanoteImportFromMD(path = '.'):
filelist = os.listdir(path)
filelist = [file for file in filelist if file.find('.md')>-1 or file.find('.txt')>-1]
importedNotebookTitleMapID = {}
ret = addNotebook(title='imported_note', parentId='', seq=-1)
if ret:
print 'imporing into a new notebook: %s' %ret['Title']
importedNotebookTitleMapID['import'] = ret['NotebookId']
for filename in filelist:
content, meta = readFromFile(path + '/' + filename)
parentTitle='import'
currentTitle=''
if not meta.get('categories'):
categories=['import']
else:
categories= meta.get('categories')
for cat in categories:
currentTitle=cat
if currentTitle in importedNotebookTitleMapID.keys():
parentTitle=currentTitle
else:
ret = addNotebook(title = currentTitle, parentId = importedNotebookTitleMapID[parentTitle])
importedNotebookTitleMapID[currentTitle] = ret['NotebookId']
parentTitle=currentTitle
if not meta.get('title'):
meta['title'] = filename.replace('.md','').replace('.txt','')
importedNote = addNote(NotebookId=importedNotebookTitleMapID[current | getImage | identifier_name |
AddDoctorForm.js | const doctorImageRef = useRef()
if(!!props.uploadRet){
if(!!props.uploadRet.success){
console.log(props.uploadRet,"props.uploadRet")
props.setImage(props.uploadRet.data)
addToast(props.uploadRet.message, {appearance: 'success', autoDismiss:true})
}else |
props.loadingImageOff()
props.uploadRetClr()
}
if(!!props.addDoctorRet){
if(!!props.addDoctorRet.success){
addToast(props.addDoctorRet.message, {appearance: 'success', autoDismiss:true})
console.log(props.addDoctorRet,"props.addDoctorRet")
props.set_user_info({
...props.prof_data,
doctors:[...props.addDoctorRet.data.doctors]
})
props.clear_data()
}else{
addToast(props.addDoctorRet.message, {appearance: 'error', autoDismiss:true})
}
props.getUserDetails()
props.addDoctorClr()
props.addDoctorLoadingOff()
}
const submitdetails = () => {
if(props.name === '' || props.department === '' ||props.designation==='' || props.experience==="" || props.education==="" || props.specialitie_chosen===" " || (props.services_chosen.length===0) ){
addToast("Enter all the details",{ appearance: 'error', autoDismiss:true })
}else if(!!!props.doctorProfileImage){
addToast("Please provide a profile image",{ appearance: 'error', autoDismiss:true })
}else{
props.submitdetails({
name:props.name,
designation:props.designation,
department:props.department,
experience:props.experience,
education:props.education,
services_chosen:props.services_chosen,
specialitie_chosen:props.specialitie_chosen,
doctorProfileImage:props.doctorProfileImage,
doctorId:get_url_params('id')?get_url_params('id'):undefined
})
}
}
const handleImageClick = ()=>{
let element = document.getElementById('doctorImageInput')
element.click()
}
const handleUploadImage = (e) => {
e.preventDefault();
e.stopPropagation()
var reader = new FileReader();
var file = e.target.files[0];
if(!!file){
if (file.size > 2 * 1024 * 1024) {
addToast('File size should be less than 2MB', {appearance: 'error', autoDismiss:true})
} else {
props.upload({ file: file, field: 'file' })
reader.onloadend = () => {
reader.readAsDataURL(file);
}
}
}else{
addToast('No File Found', {appearance: 'error', autoDismiss:true})
}
}
console.log(props,"props in AddDoctorForm")
return (
<React.Fragment>
<div className="profile_secti">
<div style={{height:'10px',width:'10px',position:'absolute',top:'-10px'}} ref={myRef}></div>
{props.addDoctorLoading && <LoaderComponent />}
<h5 className="pfo_im">Profile Image</h5>
<div className="row">
<div className="col-lg-2 col-md-4 image_wrapper_add_doctor position-relative">
{props.laodingImage && <LoaderComponent />}
<input
style={{display:'inline',display:'none'}}
id="doctorImageInput"
type="file" accept="image/jpe ,image/png, image/jpeg"
onChange ={(e)=>handleUploadImage(e)}
ref = {doctorImageRef}
/>
<img src={!!props.doctorProfileImage?props.doctorProfileImage:'/account.svg'} className="accout"/>
<img onClick={(e)=>handleImageClick(e)} src="/camera.svg" className=" profile_camera_rish cursor-pointer" />
</div>
<div className="col-lg-3">
<h6 className="fil_nm">{!!props.doctorImageName?props.doctorImageName:'File Name'}</h6>
<button onClick={(e)=>handleImageClick(e)} className="upld common-button">Upload</button>
</div>
</div>
<form class="shake" role="form" method="post" id="contactForm" name="contact-form" data-toggle="validator">
<div class="form-group label-floating">
<label class="control-label control_label_ris" for="name">Name</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.name} onChange={props.handleChange} id="name" type="text" name="name" required data-error="Please enter your name" />
<div class="help-block with-errors"></div>
</div>
<div class="form-group label-floating">
<label class="control-label control_label_ris" for="education">Education Qualification</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.education} onChange={props.handleChange} id="educationqua" type="education" name="education" required data-error="Please enter your education qulification" />
<div class="help-block with-errors"></div>
</div>
<div class="form-group label-floating">
<label class="control-label control_label_ris" for="education">Department</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.department} onChange={props.handleChange} id="department" name="department" required data-error="Please enter your education qulification" />
<div class="help-block with-errors"></div>
</div>
<div class="form-group label-floating">
<label class="control-label control_label_ris">Designation</label>
<input class="form-control no_padding_ris btm_in_bdr" id="msg_Designation" value= {props.designation} onChange={props.handleChange} type="text" name="designation" required data-error="Please enter your message Designation" />
<div class="help-block with-errors"></div>
</div>
<div className="row form-group label-floating">
<div class="col-lg-6 col-12">
<Select
options = {props.specialities}
handleChange = {props.handleSelectChange}
value = {props.specialitie_chosen}
multiple ={false}
name = "specialitie_chosen"
label = "Speciality"
placeholder = "Choose Spectiality"
/>
</div>
<div class="col-lg-6 col-12">
<Select
options = {props.services}
handleChange = {props.handleSelectChange}
value = {props.services_chosen}
name = "services_chosen"
label = "Service"
placeholder = "Choose Servives"
/>
</div>
</div>
<div class="form-group label-floating">
<label for="message" class="control-label control_label_ris">Experience</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.experience} onChange={props.handleChange} id="msg_Experience" type="number" name="experience" required data-error="Please enter your message Experience" />
<div class="help-block with-errors"></div>
</div>
</form>
</div>
<div className="time_she">
<h3 className="abaily text-center">Availability</h3>
<div className="row text-center">
<div className="col-lg-2"><h4>All</h4></div>
<div className="col-lg-4"><h4>From - To</h4></div>
<div className="col-lg-4"><h4>From - To</h4></div>
<div className="col-lg-2"><h4>Closed</h4></div>
</div>
{props.slots.map((item,i)=>(
<div className="row text-center">
<div className="col-lg-2"><p className="m">{item.day.charAt(0).toUpperCase()}</p></div>
<div className="col-lg-4"><p><span onClick={()=>props.slotClicked(item.slots.morning,'morning','from', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.morning.from)}</span><span onClick={()=>props.slotClicked(item.slots.morning,'morning','to', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.morning.to)}</span></p></div>
<div className="col-lg-4"><p><span onClick={()=>props.slotClicked(item.slots.evening,'evening','from', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.evening.from)}</span><span onClick={()=>props.slotClicked(item.slots.evening,'evening','to', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.evening.to)}</span></p></div>
<div className="col-lg-2">
<div
onClick = {(e)=>props.handleCloseDay(item,i,e)}
className='circul_rund'>
<label className={item.closed | {
addToast(props.uploadRet.message, {appearance: 'success', autoDismiss:true})
} | conditional_block |
AddDoctorForm.js | const doctorImageRef = useRef()
if(!!props.uploadRet){
if(!!props.uploadRet.success){
console.log(props.uploadRet,"props.uploadRet")
props.setImage(props.uploadRet.data)
addToast(props.uploadRet.message, {appearance: 'success', autoDismiss:true})
}else{
addToast(props.uploadRet.message, {appearance: 'success', autoDismiss:true})
}
props.loadingImageOff()
props.uploadRetClr()
}
if(!!props.addDoctorRet){
if(!!props.addDoctorRet.success){
addToast(props.addDoctorRet.message, {appearance: 'success', autoDismiss:true})
console.log(props.addDoctorRet,"props.addDoctorRet")
props.set_user_info({
...props.prof_data,
doctors:[...props.addDoctorRet.data.doctors]
})
props.clear_data()
}else{
addToast(props.addDoctorRet.message, {appearance: 'error', autoDismiss:true})
}
props.getUserDetails()
props.addDoctorClr()
props.addDoctorLoadingOff()
}
const submitdetails = () => {
if(props.name === '' || props.department === '' ||props.designation==='' || props.experience==="" || props.education==="" || props.specialitie_chosen===" " || (props.services_chosen.length===0) ){
addToast("Enter all the details",{ appearance: 'error', autoDismiss:true })
}else if(!!!props.doctorProfileImage){
addToast("Please provide a profile image",{ appearance: 'error', autoDismiss:true })
}else{
props.submitdetails({
name:props.name,
designation:props.designation,
department:props.department,
experience:props.experience,
education:props.education,
services_chosen:props.services_chosen,
specialitie_chosen:props.specialitie_chosen,
doctorProfileImage:props.doctorProfileImage,
doctorId:get_url_params('id')?get_url_params('id'):undefined
})
}
}
const handleImageClick = ()=>{
let element = document.getElementById('doctorImageInput')
element.click()
}
const handleUploadImage = (e) => {
e.preventDefault();
e.stopPropagation()
var reader = new FileReader();
var file = e.target.files[0];
if(!!file){
if (file.size > 2 * 1024 * 1024) {
addToast('File size should be less than 2MB', {appearance: 'error', autoDismiss:true})
} else {
props.upload({ file: file, field: 'file' })
reader.onloadend = () => {
reader.readAsDataURL(file);
}
}
}else{
addToast('No File Found', {appearance: 'error', autoDismiss:true})
}
}
console.log(props,"props in AddDoctorForm")
return (
<React.Fragment>
<div className="profile_secti">
<div style={{height:'10px',width:'10px',position:'absolute',top:'-10px'}} ref={myRef}></div>
{props.addDoctorLoading && <LoaderComponent />}
<h5 className="pfo_im">Profile Image</h5>
<div className="row">
<div className="col-lg-2 col-md-4 image_wrapper_add_doctor position-relative">
{props.laodingImage && <LoaderComponent />}
<input
style={{display:'inline',display:'none'}}
id="doctorImageInput"
type="file" accept="image/jpe ,image/png, image/jpeg"
onChange ={(e)=>handleUploadImage(e)}
ref = {doctorImageRef}
/>
<img src={!!props.doctorProfileImage?props.doctorProfileImage:'/account.svg'} className="accout"/>
<img onClick={(e)=>handleImageClick(e)} src="/camera.svg" className=" profile_camera_rish cursor-pointer" />
</div>
<div className="col-lg-3">
<h6 className="fil_nm">{!!props.doctorImageName?props.doctorImageName:'File Name'}</h6>
<button onClick={(e)=>handleImageClick(e)} className="upld common-button">Upload</button>
</div>
</div>
<form class="shake" role="form" method="post" id="contactForm" name="contact-form" data-toggle="validator">
<div class="form-group label-floating">
<label class="control-label control_label_ris" for="name">Name</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.name} onChange={props.handleChange} id="name" type="text" name="name" required data-error="Please enter your name" />
<div class="help-block with-errors"></div>
</div>
<div class="form-group label-floating">
<label class="control-label control_label_ris" for="education">Education Qualification</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.education} onChange={props.handleChange} id="educationqua" type="education" name="education" required data-error="Please enter your education qulification" />
<div class="help-block with-errors"></div>
</div>
<div class="form-group label-floating">
<label class="control-label control_label_ris" for="education">Department</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.department} onChange={props.handleChange} id="department" name="department" required data-error="Please enter your education qulification" />
<div class="help-block with-errors"></div>
</div>
<div class="form-group label-floating">
<label class="control-label control_label_ris">Designation</label>
<input class="form-control no_padding_ris btm_in_bdr" id="msg_Designation" value= {props.designation} onChange={props.handleChange} type="text" name="designation" required data-error="Please enter your message Designation" />
<div class="help-block with-errors"></div>
</div>
<div className="row form-group label-floating">
<div class="col-lg-6 col-12">
<Select
options = {props.specialities}
handleChange = {props.handleSelectChange}
value = {props.specialitie_chosen}
multiple ={false}
name = "specialitie_chosen"
label = "Speciality"
placeholder = "Choose Spectiality"
/>
</div>
<div class="col-lg-6 col-12">
<Select
options = {props.services}
handleChange = {props.handleSelectChange}
value = {props.services_chosen}
name = "services_chosen"
label = "Service"
placeholder = "Choose Servives"
/>
</div>
</div>
<div class="form-group label-floating">
<label for="message" class="control-label control_label_ris">Experience</label>
<input class="form-control no_padding_ris btm_in_bdr" value= {props.experience} onChange={props.handleChange} id="msg_Experience" type="number" name="experience" required data-error="Please enter your message Experience" />
<div class="help-block with-errors"></div>
</div>
</form>
</div>
<div className="time_she">
<h3 className="abaily text-center">Availability</h3>
<div className="row text-center">
<div className="col-lg-2"><h4>All</h4></div>
<div className="col-lg-4"><h4>From - To</h4></div>
<div className="col-lg-4"><h4>From - To</h4></div>
<div className="col-lg-2"><h4>Closed</h4></div>
</div>
{props.slots.map((item,i)=>(
<div className="row text-center">
<div className="col-lg-2"><p className="m">{item.day.charAt(0).toUpperCase()}</p></div>
<div className="col-lg-4"><p><span onClick={()=>props.slotClicked(item.slots.morning,'morning','from', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.morning.from)}</span><span onClick={()=>props.slotClicked(item.slots.morning,'morning','to', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.morning.to)}</span></p></div>
<div className="col-lg-4"><p><span onClick={()=>props.slotClicked(item.slots.evening,'evening','from', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.evening.from)}</span><span onClick={()=>props.slotClicked(item.slots.evening,'evening','to', item)} className="time_bor cursor-pointer">{props.timeToString(item.slots.evening.to)}</span></p></div>
<div className="col-lg-2"> | <div
onClick = {(e)=>props.handleCloseDay(item,i,e)}
className='circul_rund'>
<label className={item.closed?' | random_line_split |
|
io_file_browser_search.py | This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ***** END GPL LICENCE BLOCK *****
bl_info = {
"name": "File Browser Search",
"author": "Jakub Zolcik",
"version": (0, 1, 1),
"blender": (2, 6, 2),
"api": 35622,
"location": "File Browser",
"description": "Allows You to find files in File Browser by name.",
"warning": "",
"wiki_url": "http://wiki.blender.org/index.php/User:Sftd/Extensions:2.6/Py/Scripts/Import-Export/File_Browser_Search",
"tracker_url": "http://projects.blender.org/tracker/?func=detail&aid=30386&group_id=153&atid=467",
"category": "Import-Export"}
"""
Usage:
Launches in File Browser
"""
import bpy
import os
import re
class FilteredFileItem(bpy.types.PropertyGroup):
name = bpy.props.StringProperty(name="File name", default="")
dname = bpy.props.StringProperty(name="Display name", default="")
def fileSearch(self, context):
# print("file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
pattern = ""
special = ('\\', '.', '^', '$', '*', '+', '?', '{', '}', '[', ']', '|', '(', ')')
for c in special:
filter = filter.replace(c, '\\' + c)
if ('*' in filter):
filter = filter.replace('\*', '.*')
pattern = ('^' + filter.lower() + '$')
else:
if(len(filter) < 3):
pattern = ('^' + filter.lower() + r".*\..*" + '$')
else:
pattern = ('^' + r".*" + filter.lower() + r".*\..*" + '$')
prog = re.compile(pattern)
maxf = 100
cf = 0
dlen = len(directory)
maxd = 100
cd = 0
if context.window_manager.file_searchtree:
for path, dirs, files in os.walk(directory):
cd += 1
if cd > maxd:
break
for filename in files:
filename = (os.path.join(path, filename))[dlen:]
# rfilename = (os.path.join(path, filename))[dlen:]
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
# p.name = rfilename
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
cf += 1
if(cf >= maxf):
break
if(cf >= maxf):
break
else:
filesList = os.listdir(directory)
for filename in filesList:
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
return None
def blendDataFromFile(file, part):
with bpy.data.libraries.load(file) as (data_from, data_to):
if (part == "Action"):
return data_from.actions
elif part == "Armature":
return data_from.brushes
elif part == "Brush":
return data_from.brushes
elif part == "Camera":
return data_from.cameras
elif part == "Curve":
return data_from.curves
elif part == "Font":
return data_from.fonts
elif part == "Group":
return data_from.groups
elif part == "Image":
return data_from.images
elif part == "Lamp":
return data_from.lamps
elif part == "Lattice":
return data_from.lattices
elif part == "Library":
return data_from.libraries
elif part == "FreestyleLineStyle":
return data_from.linestyles
elif part == "Mask":
return data_from.masks
elif part == "Material":
return data_from.materials
elif part == "Mesh":
return data_from.meshes
elif part == "NodeTree":
return data_from.node_groups
elif part == "Object":
return data_from.objects
elif part == "Particle":
return data_from.particles
elif part == "Scene":
return data_from.scenes
elif part == "Screen":
return data_from.screens
elif part == "Script":
return data_from.scripts
elif part == "Sound":
return data_from.sounds
elif part == "Speaker":
return data_from.speakers
elif part == "Text":
return data_from.texts
elif part == "Texture":
return data_from.textures
elif part == "World":
return data_from.worlds
else:
return None
def notFileSearch(self, context):
# print("not file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
ind_e = directory.find(".blend")
if(ind_e == -1):
return None
ind_e = ind_e + 6
file = directory[0:ind_e]
part = directory[ind_e + 1:-1]
if (part == ""):
return None
data = None
data = blendDataFromFile(file, part)
pattern = ""
if(len(filter) < 3):
pattern = (filter.lower() + r".*")
else:
pattern = (r".*" + filter.lower() + r".*")
prog = re.compile(pattern)
for name in data:
if prog.match(name.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = name
p.dname = name
return None
def filteredSearchFunc(self, context):
if(context.active_operator.bl_idname == "WM_OT_link_append"):
return notFileSearch(self, context)
else: |
class FilteredFileSelectOperator(bpy.types.Operator):
bl_idname = "file.filtered_file_select"
bl_label = "Select File"
fname = bpy.props.StringProperty()
fexec = bpy.props.BoolProperty()
def execute(self, context):
context.space_data.params.filename = self.fname
if self.fexec:
bpy.ops.file.execute('INVOKE_DEFAULT')
return {'FINISHED'}
class FilteredSearchPanel(bpy.types.Panel):
bl_idname = "FILE_PT_filteredsearch"
bl_label = "Search:"
bl_space_type = 'FILE_BROWSER'
bl_region_type = 'CHANNELS'
@classmethod
def poll(cls, context):
return (context.space_data.params is not None)
def draw(self, context):
layout = self.layout
directory = context.space_data.params.directory
if context.window_manager.last_directory_prop != directory:
context.window_manager.last_directory_prop = directory
filteredSearchFunc(self, context)
layout.prop(context.window_manager, "filtered_search_prop", "")
box = layout.box()
length = len(context.window_manager.filtered_files_prop)
incolumn = int(length / context.blend_data.scenes[0].file_columnsnumber)
r = length % context.blend_data.scenes[0].file_columnsnumber
row = box.row()
col = row.column()
it = 0
tr = 0
for f in context.window_manager.filtered_files_prop:
op = col.operator("file.filtered_file_select", text=f.dname, emboss=False)
op.fname = f.name
op.fexec = context.blend_data.scenes[0].file_autoexecute
it += 1
if tr < r:
if it % (incolumn + 1) == 0:
tr += 1
if(it < length):
col = row.column()
else:
if (it - tr) % incolumn == 0:
if(it < length):
col = row.column()
layout.prop(context.blend_data.scenes[0], "file_autoexecute")
layout.prop(context.window_manager, "file_searchtree")
layout.prop(context.blend_data.scenes[0], "file_hideextensions")
layout.prop(context.blend_data.scenes[0 | return fileSearch(self, context) | random_line_split |
io_file_browser_search.py | This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ***** END GPL LICENCE BLOCK *****
bl_info = {
"name": "File Browser Search",
"author": "Jakub Zolcik",
"version": (0, 1, 1),
"blender": (2, 6, 2),
"api": 35622,
"location": "File Browser",
"description": "Allows You to find files in File Browser by name.",
"warning": "",
"wiki_url": "http://wiki.blender.org/index.php/User:Sftd/Extensions:2.6/Py/Scripts/Import-Export/File_Browser_Search",
"tracker_url": "http://projects.blender.org/tracker/?func=detail&aid=30386&group_id=153&atid=467",
"category": "Import-Export"}
"""
Usage:
Launches in File Browser
"""
import bpy
import os
import re
class FilteredFileItem(bpy.types.PropertyGroup):
name = bpy.props.StringProperty(name="File name", default="")
dname = bpy.props.StringProperty(name="Display name", default="")
def fileSearch(self, context):
# print("file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
pattern = ""
special = ('\\', '.', '^', '$', '*', '+', '?', '{', '}', '[', ']', '|', '(', ')')
for c in special:
filter = filter.replace(c, '\\' + c)
if ('*' in filter):
filter = filter.replace('\*', '.*')
pattern = ('^' + filter.lower() + '$')
else:
if(len(filter) < 3):
pattern = ('^' + filter.lower() + r".*\..*" + '$')
else:
pattern = ('^' + r".*" + filter.lower() + r".*\..*" + '$')
prog = re.compile(pattern)
maxf = 100
cf = 0
dlen = len(directory)
maxd = 100
cd = 0
if context.window_manager.file_searchtree:
for path, dirs, files in os.walk(directory):
cd += 1
if cd > maxd:
break
for filename in files:
filename = (os.path.join(path, filename))[dlen:]
# rfilename = (os.path.join(path, filename))[dlen:]
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
# p.name = rfilename
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
cf += 1
if(cf >= maxf):
break
if(cf >= maxf):
break
else:
filesList = os.listdir(directory)
for filename in filesList:
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
return None
def blendDataFromFile(file, part):
with bpy.data.libraries.load(file) as (data_from, data_to):
if (part == "Action"):
return data_from.actions
elif part == "Armature":
return data_from.brushes
elif part == "Brush":
return data_from.brushes
elif part == "Camera":
return data_from.cameras
elif part == "Curve":
return data_from.curves
elif part == "Font":
return data_from.fonts
elif part == "Group":
return data_from.groups
elif part == "Image":
return data_from.images
elif part == "Lamp":
return data_from.lamps
elif part == "Lattice":
return data_from.lattices
elif part == "Library":
return data_from.libraries
elif part == "FreestyleLineStyle":
return data_from.linestyles
elif part == "Mask":
return data_from.masks
elif part == "Material":
return data_from.materials
elif part == "Mesh":
return data_from.meshes
elif part == "NodeTree":
return data_from.node_groups
elif part == "Object":
return data_from.objects
elif part == "Particle":
return data_from.particles
elif part == "Scene":
return data_from.scenes
elif part == "Screen":
return data_from.screens
elif part == "Script":
return data_from.scripts
elif part == "Sound":
return data_from.sounds
elif part == "Speaker":
return data_from.speakers
elif part == "Text":
return data_from.texts
elif part == "Texture":
return data_from.textures
elif part == "World":
return data_from.worlds
else:
return None
def notFileSearch(self, context):
# print("not file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
ind_e = directory.find(".blend")
if(ind_e == -1):
return None
ind_e = ind_e + 6
file = directory[0:ind_e]
part = directory[ind_e + 1:-1]
if (part == ""):
return None
data = None
data = blendDataFromFile(file, part)
pattern = ""
if(len(filter) < 3):
pattern = (filter.lower() + r".*")
else:
pattern = (r".*" + filter.lower() + r".*")
prog = re.compile(pattern)
for name in data:
if prog.match(name.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = name
p.dname = name
return None
def filteredSearchFunc(self, context):
if(context.active_operator.bl_idname == "WM_OT_link_append"):
return notFileSearch(self, context)
else:
return fileSearch(self, context)
class | (bpy.types.Operator):
bl_idname = "file.filtered_file_select"
bl_label = "Select File"
fname = bpy.props.StringProperty()
fexec = bpy.props.BoolProperty()
def execute(self, context):
context.space_data.params.filename = self.fname
if self.fexec:
bpy.ops.file.execute('INVOKE_DEFAULT')
return {'FINISHED'}
class FilteredSearchPanel(bpy.types.Panel):
bl_idname = "FILE_PT_filteredsearch"
bl_label = "Search:"
bl_space_type = 'FILE_BROWSER'
bl_region_type = 'CHANNELS'
@classmethod
def poll(cls, context):
return (context.space_data.params is not None)
def draw(self, context):
layout = self.layout
directory = context.space_data.params.directory
if context.window_manager.last_directory_prop != directory:
context.window_manager.last_directory_prop = directory
filteredSearchFunc(self, context)
layout.prop(context.window_manager, "filtered_search_prop", "")
box = layout.box()
length = len(context.window_manager.filtered_files_prop)
incolumn = int(length / context.blend_data.scenes[0].file_columnsnumber)
r = length % context.blend_data.scenes[0].file_columnsnumber
row = box.row()
col = row.column()
it = 0
tr = 0
for f in context.window_manager.filtered_files_prop:
op = col.operator("file.filtered_file_select", text=f.dname, emboss=False)
op.fname = f.name
op.fexec = context.blend_data.scenes[0].file_autoexecute
it += 1
if tr < r:
if it % (incolumn + 1) == 0:
tr += 1
if(it < length):
col = row.column()
else:
if (it - tr) % incolumn == 0:
if(it < length):
col = row.column()
layout.prop(context.blend_data.scenes[0], "file_autoexecute")
layout.prop(context.window_manager, "file_searchtree")
layout.prop(context.blend_data.scenes[0], "file_hideextensions")
layout.prop(context.blend_data.scenes[0], | FilteredFileSelectOperator | identifier_name |
io_file_browser_search.py | "api": 35622,
"location": "File Browser",
"description": "Allows You to find files in File Browser by name.",
"warning": "",
"wiki_url": "http://wiki.blender.org/index.php/User:Sftd/Extensions:2.6/Py/Scripts/Import-Export/File_Browser_Search",
"tracker_url": "http://projects.blender.org/tracker/?func=detail&aid=30386&group_id=153&atid=467",
"category": "Import-Export"}
"""
Usage:
Launches in File Browser
"""
import bpy
import os
import re
class FilteredFileItem(bpy.types.PropertyGroup):
name = bpy.props.StringProperty(name="File name", default="")
dname = bpy.props.StringProperty(name="Display name", default="")
def fileSearch(self, context):
# print("file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
pattern = ""
special = ('\\', '.', '^', '$', '*', '+', '?', '{', '}', '[', ']', '|', '(', ')')
for c in special:
filter = filter.replace(c, '\\' + c)
if ('*' in filter):
filter = filter.replace('\*', '.*')
pattern = ('^' + filter.lower() + '$')
else:
if(len(filter) < 3):
pattern = ('^' + filter.lower() + r".*\..*" + '$')
else:
pattern = ('^' + r".*" + filter.lower() + r".*\..*" + '$')
prog = re.compile(pattern)
maxf = 100
cf = 0
dlen = len(directory)
maxd = 100
cd = 0
if context.window_manager.file_searchtree:
for path, dirs, files in os.walk(directory):
cd += 1
if cd > maxd:
break
for filename in files:
filename = (os.path.join(path, filename))[dlen:]
# rfilename = (os.path.join(path, filename))[dlen:]
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
# p.name = rfilename
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
cf += 1
if(cf >= maxf):
break
if(cf >= maxf):
break
else:
filesList = os.listdir(directory)
for filename in filesList:
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
return None
def blendDataFromFile(file, part):
with bpy.data.libraries.load(file) as (data_from, data_to):
if (part == "Action"):
return data_from.actions
elif part == "Armature":
return data_from.brushes
elif part == "Brush":
return data_from.brushes
elif part == "Camera":
return data_from.cameras
elif part == "Curve":
return data_from.curves
elif part == "Font":
return data_from.fonts
elif part == "Group":
return data_from.groups
elif part == "Image":
return data_from.images
elif part == "Lamp":
return data_from.lamps
elif part == "Lattice":
return data_from.lattices
elif part == "Library":
return data_from.libraries
elif part == "FreestyleLineStyle":
return data_from.linestyles
elif part == "Mask":
return data_from.masks
elif part == "Material":
return data_from.materials
elif part == "Mesh":
return data_from.meshes
elif part == "NodeTree":
return data_from.node_groups
elif part == "Object":
return data_from.objects
elif part == "Particle":
return data_from.particles
elif part == "Scene":
return data_from.scenes
elif part == "Screen":
return data_from.screens
elif part == "Script":
return data_from.scripts
elif part == "Sound":
return data_from.sounds
elif part == "Speaker":
return data_from.speakers
elif part == "Text":
return data_from.texts
elif part == "Texture":
return data_from.textures
elif part == "World":
return data_from.worlds
else:
return None
def notFileSearch(self, context):
# print("not file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
ind_e = directory.find(".blend")
if(ind_e == -1):
return None
ind_e = ind_e + 6
file = directory[0:ind_e]
part = directory[ind_e + 1:-1]
if (part == ""):
return None
data = None
data = blendDataFromFile(file, part)
pattern = ""
if(len(filter) < 3):
pattern = (filter.lower() + r".*")
else:
pattern = (r".*" + filter.lower() + r".*")
prog = re.compile(pattern)
for name in data:
if prog.match(name.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = name
p.dname = name
return None
def filteredSearchFunc(self, context):
if(context.active_operator.bl_idname == "WM_OT_link_append"):
return notFileSearch(self, context)
else:
return fileSearch(self, context)
class FilteredFileSelectOperator(bpy.types.Operator):
bl_idname = "file.filtered_file_select"
bl_label = "Select File"
fname = bpy.props.StringProperty()
fexec = bpy.props.BoolProperty()
def execute(self, context):
context.space_data.params.filename = self.fname
if self.fexec:
bpy.ops.file.execute('INVOKE_DEFAULT')
return {'FINISHED'}
class FilteredSearchPanel(bpy.types.Panel):
bl_idname = "FILE_PT_filteredsearch"
bl_label = "Search:"
bl_space_type = 'FILE_BROWSER'
bl_region_type = 'CHANNELS'
@classmethod
def poll(cls, context):
return (context.space_data.params is not None)
def draw(self, context):
layout = self.layout
directory = context.space_data.params.directory
if context.window_manager.last_directory_prop != directory:
context.window_manager.last_directory_prop = directory
filteredSearchFunc(self, context)
layout.prop(context.window_manager, "filtered_search_prop", "")
box = layout.box()
length = len(context.window_manager.filtered_files_prop)
incolumn = int(length / context.blend_data.scenes[0].file_columnsnumber)
r = length % context.blend_data.scenes[0].file_columnsnumber
row = box.row()
col = row.column()
it = 0
tr = 0
for f in context.window_manager.filtered_files_prop:
op = col.operator("file.filtered_file_select", text=f.dname, emboss=False)
op.fname = f.name
op.fexec = context.blend_data.scenes[0].file_autoexecute
it += 1
if tr < r:
if it % (incolumn + 1) == 0:
tr += 1
if(it < length):
col = row.column()
else:
if (it - tr) % incolumn == 0:
if(it < length):
col = row.column()
layout.prop(context.blend_data.scenes[0], "file_autoexecute")
layout.prop(context.window_manager, "file_searchtree")
layout.prop(context.blend_data.scenes[0], "file_hideextensions")
layout.prop(context.blend_data.scenes[0], "file_columnsnumber")
def register():
| bpy.utils.register_module(__name__)
bpy.types.WindowManager.filtered_search_prop = bpy.props.StringProperty(update=filteredSearchFunc)
bpy.types.WindowManager.last_directory_prop = bpy.props.StringProperty()
bpy.types.Scene.file_autoexecute = bpy.props.BoolProperty(name="Open Automatically", default=True)
bpy.types.Scene.file_hideextensions = bpy.props.BoolProperty(name="Hide Extensions", update=filteredSearchFunc)
bpy.types.WindowManager.file_searchtree = bpy.props.BoolProperty(name="Search Subdirectories", update=filteredSearchFunc)
bpy.types.Scene.file_columnsnumber = bpy.props.IntProperty(name="Number of Columns", default=2, min=1, max=15, update=filteredSearchFunc)
bpy.types.WindowManager.filtered_files_prop = bpy.props.CollectionProperty(type=FilteredFileItem) | identifier_body |
|
io_file_browser_search.py | This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ***** END GPL LICENCE BLOCK *****
bl_info = {
"name": "File Browser Search",
"author": "Jakub Zolcik",
"version": (0, 1, 1),
"blender": (2, 6, 2),
"api": 35622,
"location": "File Browser",
"description": "Allows You to find files in File Browser by name.",
"warning": "",
"wiki_url": "http://wiki.blender.org/index.php/User:Sftd/Extensions:2.6/Py/Scripts/Import-Export/File_Browser_Search",
"tracker_url": "http://projects.blender.org/tracker/?func=detail&aid=30386&group_id=153&atid=467",
"category": "Import-Export"}
"""
Usage:
Launches in File Browser
"""
import bpy
import os
import re
class FilteredFileItem(bpy.types.PropertyGroup):
name = bpy.props.StringProperty(name="File name", default="")
dname = bpy.props.StringProperty(name="Display name", default="")
def fileSearch(self, context):
# print("file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
pattern = ""
special = ('\\', '.', '^', '$', '*', '+', '?', '{', '}', '[', ']', '|', '(', ')')
for c in special:
filter = filter.replace(c, '\\' + c)
if ('*' in filter):
filter = filter.replace('\*', '.*')
pattern = ('^' + filter.lower() + '$')
else:
if(len(filter) < 3):
pattern = ('^' + filter.lower() + r".*\..*" + '$')
else:
pattern = ('^' + r".*" + filter.lower() + r".*\..*" + '$')
prog = re.compile(pattern)
maxf = 100
cf = 0
dlen = len(directory)
maxd = 100
cd = 0
if context.window_manager.file_searchtree:
for path, dirs, files in os.walk(directory):
cd += 1
if cd > maxd:
break
for filename in files:
filename = (os.path.join(path, filename))[dlen:]
# rfilename = (os.path.join(path, filename))[dlen:]
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
# p.name = rfilename
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
cf += 1
if(cf >= maxf):
|
if(cf >= maxf):
break
else:
filesList = os.listdir(directory)
for filename in filesList:
if prog.match(filename.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = filename
if context.blend_data.scenes[0].file_hideextensions:
ind = filename.rfind(".")
if ind > -1:
filename = filename[0:ind]
p.dname = filename
return None
def blendDataFromFile(file, part):
with bpy.data.libraries.load(file) as (data_from, data_to):
if (part == "Action"):
return data_from.actions
elif part == "Armature":
return data_from.brushes
elif part == "Brush":
return data_from.brushes
elif part == "Camera":
return data_from.cameras
elif part == "Curve":
return data_from.curves
elif part == "Font":
return data_from.fonts
elif part == "Group":
return data_from.groups
elif part == "Image":
return data_from.images
elif part == "Lamp":
return data_from.lamps
elif part == "Lattice":
return data_from.lattices
elif part == "Library":
return data_from.libraries
elif part == "FreestyleLineStyle":
return data_from.linestyles
elif part == "Mask":
return data_from.masks
elif part == "Material":
return data_from.materials
elif part == "Mesh":
return data_from.meshes
elif part == "NodeTree":
return data_from.node_groups
elif part == "Object":
return data_from.objects
elif part == "Particle":
return data_from.particles
elif part == "Scene":
return data_from.scenes
elif part == "Screen":
return data_from.screens
elif part == "Script":
return data_from.scripts
elif part == "Sound":
return data_from.sounds
elif part == "Speaker":
return data_from.speakers
elif part == "Text":
return data_from.texts
elif part == "Texture":
return data_from.textures
elif part == "World":
return data_from.worlds
else:
return None
def notFileSearch(self, context):
# print("not file")
filter = context.window_manager.filtered_search_prop
directory = context.window_manager.last_directory_prop
filecol = context.window_manager.filtered_files_prop
for fname in filecol:
filecol.remove(0)
if filter == "":
return None
ind_e = directory.find(".blend")
if(ind_e == -1):
return None
ind_e = ind_e + 6
file = directory[0:ind_e]
part = directory[ind_e + 1:-1]
if (part == ""):
return None
data = None
data = blendDataFromFile(file, part)
pattern = ""
if(len(filter) < 3):
pattern = (filter.lower() + r".*")
else:
pattern = (r".*" + filter.lower() + r".*")
prog = re.compile(pattern)
for name in data:
if prog.match(name.lower()) != None:
p = context.window_manager.filtered_files_prop.add()
p.name = name
p.dname = name
return None
def filteredSearchFunc(self, context):
if(context.active_operator.bl_idname == "WM_OT_link_append"):
return notFileSearch(self, context)
else:
return fileSearch(self, context)
class FilteredFileSelectOperator(bpy.types.Operator):
bl_idname = "file.filtered_file_select"
bl_label = "Select File"
fname = bpy.props.StringProperty()
fexec = bpy.props.BoolProperty()
def execute(self, context):
context.space_data.params.filename = self.fname
if self.fexec:
bpy.ops.file.execute('INVOKE_DEFAULT')
return {'FINISHED'}
class FilteredSearchPanel(bpy.types.Panel):
bl_idname = "FILE_PT_filteredsearch"
bl_label = "Search:"
bl_space_type = 'FILE_BROWSER'
bl_region_type = 'CHANNELS'
@classmethod
def poll(cls, context):
return (context.space_data.params is not None)
def draw(self, context):
layout = self.layout
directory = context.space_data.params.directory
if context.window_manager.last_directory_prop != directory:
context.window_manager.last_directory_prop = directory
filteredSearchFunc(self, context)
layout.prop(context.window_manager, "filtered_search_prop", "")
box = layout.box()
length = len(context.window_manager.filtered_files_prop)
incolumn = int(length / context.blend_data.scenes[0].file_columnsnumber)
r = length % context.blend_data.scenes[0].file_columnsnumber
row = box.row()
col = row.column()
it = 0
tr = 0
for f in context.window_manager.filtered_files_prop:
op = col.operator("file.filtered_file_select", text=f.dname, emboss=False)
op.fname = f.name
op.fexec = context.blend_data.scenes[0].file_autoexecute
it += 1
if tr < r:
if it % (incolumn + 1) == 0:
tr += 1
if(it < length):
col = row.column()
else:
if (it - tr) % incolumn == 0:
if(it < length):
col = row.column()
layout.prop(context.blend_data.scenes[0], "file_autoexecute")
layout.prop(context.window_manager, "file_searchtree")
layout.prop(context.blend_data.scenes[0], "file_hideextensions")
layout.prop(context.blend_data.scenes[0], | break | conditional_block |
node_dir_ops.go | err = nametransform.WriteDirIVAt(dirfd2)
syscall.Close(dirfd2)
}
if err != nil {
// Delete inconsistent directory (missing gocryptfs.diriv!)
err2 := syscallcompat.Unlinkat(dirfd, cName, unix.AT_REMOVEDIR)
if err2 != nil {
tlog.Warn.Printf("mkdirWithIv: rollback failed: %v", err2)
}
}
return err
}
// Mkdir - FUSE call. Create a directory at "newPath" with permissions "mode".
//
// Symlink-safe through use of Mkdirat().
func (n *Node) Mkdir(ctx context.Context, name string, mode uint32, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
dirfd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 {
return nil, errno
}
defer syscall.Close(dirfd)
rn := n.rootNode()
var context *fuse.Context
if rn.args.PreserveOwner {
context = toFuseCtx(ctx)
}
var st syscall.Stat_t
if rn.args.PlaintextNames {
err := syscallcompat.MkdiratUser(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
var ust unix.Stat_t
err = syscallcompat.Fstatat(dirfd, cName, &ust, unix.AT_SYMLINK_NOFOLLOW)
if err != nil {
return nil, fs.ToErrno(err)
}
st = syscallcompat.Unix2syscall(ust)
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// We need write and execute permissions to create gocryptfs.diriv.
// Also, we need read permissions to open the directory (to avoid
// race-conditions between getting and setting the mode).
origMode := mode
mode = mode | 0700
// Handle long file name
if nametransform.IsLongContent(cName) {
// Create ".name"
err := rn.nameTransform.WriteLongNameAt(dirfd, cName, name)
if err != nil {
return nil, fs.ToErrno(err)
}
// Create directory & rollback .name file on error
err = rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
nametransform.DeleteLongNameAt(dirfd, cName)
return nil, fs.ToErrno(err)
}
} else {
err := rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
}
// Fill `st`
fd, err := syscallcompat.Openat(dirfd, cName,
syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Openat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
err = syscall.Fstat(fd, &st)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fstat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
// Fix permissions
if origMode != mode {
// Preserve SGID bit if it was set due to inheritance.
origMode = uint32(st.Mode&^0777) | origMode
err = syscall.Fchmod(fd, origMode)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fchmod %#o -> %#o failed: %v", cName, mode, origMode, err)
}
}
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// Readdir - FUSE call.
//
// This function is symlink-safe through use of openBackingDir() and
// ReadDirIVAt().
func (n *Node) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
parentDirFd, cDirName, errno := n.prepareAtSyscallMyself()
if errno != 0 {
return nil, errno
}
defer syscall.Close(parentDirFd)
// Read ciphertext directory
fd, err := syscallcompat.Openat(parentDirFd, cDirName, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
cipherEntries, specialEntries, err := syscallcompat.GetdentsSpecial(fd)
if err != nil {
return nil, fs.ToErrno(err)
}
// Get DirIV (stays nil if PlaintextNames is used)
var cachedIV []byte
rn := n.rootNode()
if !rn.args.PlaintextNames {
// Read the DirIV from disk
cachedIV, err = rn.nameTransform.ReadDirIVAt(fd)
if err != nil {
tlog.Warn.Printf("OpenDir %q: could not read %s: %v", cDirName, nametransform.DirIVFilename, err)
return nil, syscall.EIO
}
}
// Decrypted directory entries
var plain []fuse.DirEntry
// Add "." and ".."
plain = append(plain, specialEntries...)
// Filter and decrypt filenames
for i := range cipherEntries {
cName := cipherEntries[i].Name
if n.IsRoot() && cName == configfile.ConfDefaultName {
// silently ignore "gocryptfs.conf" in the top level dir
continue
}
if rn.args.PlaintextNames {
plain = append(plain, cipherEntries[i])
continue
}
if !rn.args.DeterministicNames && cName == nametransform.DirIVFilename {
// silently ignore "gocryptfs.diriv" everywhere if dirIV is enabled
continue
}
// Handle long file name
isLong := nametransform.LongNameNone
if rn.args.LongNames {
isLong = nametransform.NameType(cName)
}
if isLong == nametransform.LongNameContent {
cNameLong, err := nametransform.ReadLongNameAt(fd, cName)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: Could not read .name: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
cName = cNameLong
} else if isLong == nametransform.LongNameFilename {
// ignore "gocryptfs.longname.*.name"
continue
}
name, err := rn.nameTransform.DecryptName(cName, cachedIV)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
// Override the ciphertext name with the plaintext name but reuse the rest
// of the structure
cipherEntries[i].Name = name
plain = append(plain, cipherEntries[i])
}
return fs.NewListDirStream(plain), 0
}
// Rmdir - FUSE call.
//
// Symlink-safe through Unlinkat() + AT_REMOVEDIR.
func (n *Node) Rmdir(ctx context.Context, name string) (code syscall.Errno) {
rn := n.rootNode()
parentDirFd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 |
defer syscall.Close(parentDirFd)
if rn.args.PlaintextNames {
// Unlinkat with AT_REMOVEDIR is equivalent to Rmdir
err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR)
return fs.ToErrno(err)
}
if rn.args.DeterministicNames {
if err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR); err != nil {
return fs.ToErrno(err)
}
if nametransform.IsLongContent(cName) {
nametransform.DeleteLongNameAt(parentDirFd, cName)
}
return 0
}
// Unless we are running as root, we need read, write and execute permissions
// to handle gocryptfs.diriv.
permWorkaround := false
var origMode uint32
if !rn.args.PreserveOwner {
var st unix.Stat_t
err := syscallcompat.Fstatat(parentDirFd, cName, &st, unix.AT_SYMLINK_NOFOLLOW)
if err != nil {
return fs.ToErrno(err)
}
if st.Mode&0700 != 0700 {
tlog.Debug.Printf("Rmdir: permWorkaround")
permWorkaround = true
// This cast is needed on Darwin, where st.Mode is uint1 | {
return errno
} | conditional_block |
node_dir_ops.go | err = nametransform.WriteDirIVAt(dirfd2)
syscall.Close(dirfd2)
}
if err != nil {
// Delete inconsistent directory (missing gocryptfs.diriv!)
err2 := syscallcompat.Unlinkat(dirfd, cName, unix.AT_REMOVEDIR)
if err2 != nil {
tlog.Warn.Printf("mkdirWithIv: rollback failed: %v", err2)
}
}
return err
}
// Mkdir - FUSE call. Create a directory at "newPath" with permissions "mode".
//
// Symlink-safe through use of Mkdirat().
func (n *Node) Mkdir(ctx context.Context, name string, mode uint32, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
dirfd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 {
return nil, errno
}
defer syscall.Close(dirfd)
rn := n.rootNode()
var context *fuse.Context
if rn.args.PreserveOwner {
context = toFuseCtx(ctx)
}
var st syscall.Stat_t
if rn.args.PlaintextNames {
err := syscallcompat.MkdiratUser(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
var ust unix.Stat_t
err = syscallcompat.Fstatat(dirfd, cName, &ust, unix.AT_SYMLINK_NOFOLLOW)
if err != nil {
return nil, fs.ToErrno(err)
}
st = syscallcompat.Unix2syscall(ust)
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// We need write and execute permissions to create gocryptfs.diriv.
// Also, we need read permissions to open the directory (to avoid
// race-conditions between getting and setting the mode).
origMode := mode
mode = mode | 0700
// Handle long file name
if nametransform.IsLongContent(cName) {
// Create ".name"
err := rn.nameTransform.WriteLongNameAt(dirfd, cName, name)
if err != nil {
return nil, fs.ToErrno(err)
}
// Create directory & rollback .name file on error
err = rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
nametransform.DeleteLongNameAt(dirfd, cName)
return nil, fs.ToErrno(err)
}
} else {
err := rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
}
// Fill `st`
fd, err := syscallcompat.Openat(dirfd, cName,
syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Openat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
err = syscall.Fstat(fd, &st)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fstat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
// Fix permissions
if origMode != mode {
// Preserve SGID bit if it was set due to inheritance.
origMode = uint32(st.Mode&^0777) | origMode
err = syscall.Fchmod(fd, origMode)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fchmod %#o -> %#o failed: %v", cName, mode, origMode, err)
}
}
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// Readdir - FUSE call.
//
// This function is symlink-safe through use of openBackingDir() and
// ReadDirIVAt().
func (n *Node) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
parentDirFd, cDirName, errno := n.prepareAtSyscallMyself()
if errno != 0 {
return nil, errno
}
defer syscall.Close(parentDirFd)
// Read ciphertext directory
fd, err := syscallcompat.Openat(parentDirFd, cDirName, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
cipherEntries, specialEntries, err := syscallcompat.GetdentsSpecial(fd)
if err != nil {
return nil, fs.ToErrno(err)
}
// Get DirIV (stays nil if PlaintextNames is used)
var cachedIV []byte
rn := n.rootNode()
if !rn.args.PlaintextNames {
// Read the DirIV from disk
cachedIV, err = rn.nameTransform.ReadDirIVAt(fd)
if err != nil {
tlog.Warn.Printf("OpenDir %q: could not read %s: %v", cDirName, nametransform.DirIVFilename, err)
return nil, syscall.EIO
}
}
// Decrypted directory entries
var plain []fuse.DirEntry
// Add "." and ".."
plain = append(plain, specialEntries...)
// Filter and decrypt filenames
for i := range cipherEntries {
cName := cipherEntries[i].Name
if n.IsRoot() && cName == configfile.ConfDefaultName {
// silently ignore "gocryptfs.conf" in the top level dir
continue
}
if rn.args.PlaintextNames {
plain = append(plain, cipherEntries[i])
continue
}
if !rn.args.DeterministicNames && cName == nametransform.DirIVFilename {
// silently ignore "gocryptfs.diriv" everywhere if dirIV is enabled
continue
}
// Handle long file name
isLong := nametransform.LongNameNone
if rn.args.LongNames {
isLong = nametransform.NameType(cName)
}
if isLong == nametransform.LongNameContent {
cNameLong, err := nametransform.ReadLongNameAt(fd, cName)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: Could not read .name: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
cName = cNameLong
} else if isLong == nametransform.LongNameFilename {
// ignore "gocryptfs.longname.*.name"
continue
}
name, err := rn.nameTransform.DecryptName(cName, cachedIV)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
// Override the ciphertext name with the plaintext name but reuse the rest
// of the structure
cipherEntries[i].Name = name
plain = append(plain, cipherEntries[i])
}
return fs.NewListDirStream(plain), 0
}
// Rmdir - FUSE call.
//
// Symlink-safe through Unlinkat() + AT_REMOVEDIR.
func (n *Node) Rmdir(ctx context.Context, name string) (code syscall.Errno) | }
// Unless we are running as root, we need read, write and execute permissions
// to handle gocryptfs.diriv.
permWorkaround := false
var origMode uint32
if !rn.args.PreserveOwner {
var st unix.Stat_t
err := syscallcompat.Fstatat(parentDirFd, cName, &st, unix.AT_SYMLINK_NOFOLLOW)
if err != nil {
return fs.ToErrno(err)
}
if st.Mode&0700 != 0700 {
tlog.Debug.Printf("Rmdir: permWorkaround")
permWorkaround = true
// This cast is needed on Darwin, where st.Mode is uint16 | {
rn := n.rootNode()
parentDirFd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 {
return errno
}
defer syscall.Close(parentDirFd)
if rn.args.PlaintextNames {
// Unlinkat with AT_REMOVEDIR is equivalent to Rmdir
err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR)
return fs.ToErrno(err)
}
if rn.args.DeterministicNames {
if err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR); err != nil {
return fs.ToErrno(err)
}
if nametransform.IsLongContent(cName) {
nametransform.DeleteLongNameAt(parentDirFd, cName)
}
return 0 | identifier_body |
node_dir_ops.go | (dirfd int, cName string, mode uint32, context *fuse.Context) error {
rn := n.rootNode()
if rn.args.DeterministicNames {
return syscallcompat.MkdiratUser(dirfd, cName, mode, context)
}
// Between the creation of the directory and the creation of gocryptfs.diriv
// the directory is inconsistent. Take the lock to prevent other readers
// from seeing it.
rn.dirIVLock.Lock()
defer rn.dirIVLock.Unlock()
err := syscallcompat.MkdiratUser(dirfd, cName, mode, context)
if err != nil {
return err
}
dirfd2, err := syscallcompat.Openat(dirfd, cName, syscall.O_DIRECTORY|syscall.O_NOFOLLOW|syscallcompat.O_PATH, 0)
if err == nil {
// Create gocryptfs.diriv
err = nametransform.WriteDirIVAt(dirfd2)
syscall.Close(dirfd2)
}
if err != nil {
// Delete inconsistent directory (missing gocryptfs.diriv!)
err2 := syscallcompat.Unlinkat(dirfd, cName, unix.AT_REMOVEDIR)
if err2 != nil {
tlog.Warn.Printf("mkdirWithIv: rollback failed: %v", err2)
}
}
return err
}
// Mkdir - FUSE call. Create a directory at "newPath" with permissions "mode".
//
// Symlink-safe through use of Mkdirat().
func (n *Node) Mkdir(ctx context.Context, name string, mode uint32, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
dirfd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 {
return nil, errno
}
defer syscall.Close(dirfd)
rn := n.rootNode()
var context *fuse.Context
if rn.args.PreserveOwner {
context = toFuseCtx(ctx)
}
var st syscall.Stat_t
if rn.args.PlaintextNames {
err := syscallcompat.MkdiratUser(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
var ust unix.Stat_t
err = syscallcompat.Fstatat(dirfd, cName, &ust, unix.AT_SYMLINK_NOFOLLOW)
if err != nil {
return nil, fs.ToErrno(err)
}
st = syscallcompat.Unix2syscall(ust)
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// We need write and execute permissions to create gocryptfs.diriv.
// Also, we need read permissions to open the directory (to avoid
// race-conditions between getting and setting the mode).
origMode := mode
mode = mode | 0700
// Handle long file name
if nametransform.IsLongContent(cName) {
// Create ".name"
err := rn.nameTransform.WriteLongNameAt(dirfd, cName, name)
if err != nil {
return nil, fs.ToErrno(err)
}
// Create directory & rollback .name file on error
err = rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
nametransform.DeleteLongNameAt(dirfd, cName)
return nil, fs.ToErrno(err)
}
} else {
err := rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
}
// Fill `st`
fd, err := syscallcompat.Openat(dirfd, cName,
syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Openat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
err = syscall.Fstat(fd, &st)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fstat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
// Fix permissions
if origMode != mode {
// Preserve SGID bit if it was set due to inheritance.
origMode = uint32(st.Mode&^0777) | origMode
err = syscall.Fchmod(fd, origMode)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fchmod %#o -> %#o failed: %v", cName, mode, origMode, err)
}
}
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// Readdir - FUSE call.
//
// This function is symlink-safe through use of openBackingDir() and
// ReadDirIVAt().
func (n *Node) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
parentDirFd, cDirName, errno := n.prepareAtSyscallMyself()
if errno != 0 {
return nil, errno
}
defer syscall.Close(parentDirFd)
// Read ciphertext directory
fd, err := syscallcompat.Openat(parentDirFd, cDirName, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
cipherEntries, specialEntries, err := syscallcompat.GetdentsSpecial(fd)
if err != nil {
return nil, fs.ToErrno(err)
}
// Get DirIV (stays nil if PlaintextNames is used)
var cachedIV []byte
rn := n.rootNode()
if !rn.args.PlaintextNames {
// Read the DirIV from disk
cachedIV, err = rn.nameTransform.ReadDirIVAt(fd)
if err != nil {
tlog.Warn.Printf("OpenDir %q: could not read %s: %v", cDirName, nametransform.DirIVFilename, err)
return nil, syscall.EIO
}
}
// Decrypted directory entries
var plain []fuse.DirEntry
// Add "." and ".."
plain = append(plain, specialEntries...)
// Filter and decrypt filenames
for i := range cipherEntries {
cName := cipherEntries[i].Name
if n.IsRoot() && cName == configfile.ConfDefaultName {
// silently ignore "gocryptfs.conf" in the top level dir
continue
}
if rn.args.PlaintextNames {
plain = append(plain, cipherEntries[i])
continue
}
if !rn.args.DeterministicNames && cName == nametransform.DirIVFilename {
// silently ignore "gocryptfs.diriv" everywhere if dirIV is enabled
continue
}
// Handle long file name
isLong := nametransform.LongNameNone
if rn.args.LongNames {
isLong = nametransform.NameType(cName)
}
if isLong == nametransform.LongNameContent {
cNameLong, err := nametransform.ReadLongNameAt(fd, cName)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: Could not read .name: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
cName = cNameLong
} else if isLong == nametransform.LongNameFilename {
// ignore "gocryptfs.longname.*.name"
continue
}
name, err := rn.nameTransform.DecryptName(cName, cachedIV)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
// Override the ciphertext name with the plaintext name but reuse the rest
// of the structure
cipherEntries[i].Name = name
plain = append(plain, cipherEntries[i])
}
return fs.NewListDirStream(plain), 0
}
// Rmdir - FUSE call.
//
// Symlink-safe through Unlinkat() + AT_REMOVEDIR.
func (n *Node) Rmdir(ctx context.Context, name string) (code syscall.Errno) {
rn := n.rootNode()
parentDirFd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 {
return errno
}
defer syscall.Close(parentDirFd)
if rn.args.PlaintextNames {
// Unlinkat with AT_REMOVEDIR is equivalent to Rmdir
err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR)
return fs.ToErrno(err)
}
if rn.args.DeterministicNames {
if err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR); err != nil {
return fs.ToErrno(err)
}
if nametrans | mkdirWithIv | identifier_name |
|
node_dir_ops.go | err = nametransform.WriteDirIVAt(dirfd2)
syscall.Close(dirfd2)
}
if err != nil { | // Delete inconsistent directory (missing gocryptfs.diriv!)
err2 := syscallcompat.Unlinkat(dirfd, cName, unix.AT_REMOVEDIR)
if err2 != nil {
tlog.Warn.Printf("mkdirWithIv: rollback failed: %v", err2)
}
}
return err
}
// Mkdir - FUSE call. Create a directory at "newPath" with permissions "mode".
//
// Symlink-safe through use of Mkdirat().
func (n *Node) Mkdir(ctx context.Context, name string, mode uint32, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
dirfd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 {
return nil, errno
}
defer syscall.Close(dirfd)
rn := n.rootNode()
var context *fuse.Context
if rn.args.PreserveOwner {
context = toFuseCtx(ctx)
}
var st syscall.Stat_t
if rn.args.PlaintextNames {
err := syscallcompat.MkdiratUser(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
var ust unix.Stat_t
err = syscallcompat.Fstatat(dirfd, cName, &ust, unix.AT_SYMLINK_NOFOLLOW)
if err != nil {
return nil, fs.ToErrno(err)
}
st = syscallcompat.Unix2syscall(ust)
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// We need write and execute permissions to create gocryptfs.diriv.
// Also, we need read permissions to open the directory (to avoid
// race-conditions between getting and setting the mode).
origMode := mode
mode = mode | 0700
// Handle long file name
if nametransform.IsLongContent(cName) {
// Create ".name"
err := rn.nameTransform.WriteLongNameAt(dirfd, cName, name)
if err != nil {
return nil, fs.ToErrno(err)
}
// Create directory & rollback .name file on error
err = rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
nametransform.DeleteLongNameAt(dirfd, cName)
return nil, fs.ToErrno(err)
}
} else {
err := rn.mkdirWithIv(dirfd, cName, mode, context)
if err != nil {
return nil, fs.ToErrno(err)
}
}
// Fill `st`
fd, err := syscallcompat.Openat(dirfd, cName,
syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Openat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
err = syscall.Fstat(fd, &st)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fstat failed: %v", cName, err)
return nil, fs.ToErrno(err)
}
// Fix permissions
if origMode != mode {
// Preserve SGID bit if it was set due to inheritance.
origMode = uint32(st.Mode&^0777) | origMode
err = syscall.Fchmod(fd, origMode)
if err != nil {
tlog.Warn.Printf("Mkdir %q: Fchmod %#o -> %#o failed: %v", cName, mode, origMode, err)
}
}
// Create child node & return
ch := n.newChild(ctx, &st, out)
return ch, 0
}
// Readdir - FUSE call.
//
// This function is symlink-safe through use of openBackingDir() and
// ReadDirIVAt().
func (n *Node) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
parentDirFd, cDirName, errno := n.prepareAtSyscallMyself()
if errno != 0 {
return nil, errno
}
defer syscall.Close(parentDirFd)
// Read ciphertext directory
fd, err := syscallcompat.Openat(parentDirFd, cDirName, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW, 0)
if err != nil {
return nil, fs.ToErrno(err)
}
defer syscall.Close(fd)
cipherEntries, specialEntries, err := syscallcompat.GetdentsSpecial(fd)
if err != nil {
return nil, fs.ToErrno(err)
}
// Get DirIV (stays nil if PlaintextNames is used)
var cachedIV []byte
rn := n.rootNode()
if !rn.args.PlaintextNames {
// Read the DirIV from disk
cachedIV, err = rn.nameTransform.ReadDirIVAt(fd)
if err != nil {
tlog.Warn.Printf("OpenDir %q: could not read %s: %v", cDirName, nametransform.DirIVFilename, err)
return nil, syscall.EIO
}
}
// Decrypted directory entries
var plain []fuse.DirEntry
// Add "." and ".."
plain = append(plain, specialEntries...)
// Filter and decrypt filenames
for i := range cipherEntries {
cName := cipherEntries[i].Name
if n.IsRoot() && cName == configfile.ConfDefaultName {
// silently ignore "gocryptfs.conf" in the top level dir
continue
}
if rn.args.PlaintextNames {
plain = append(plain, cipherEntries[i])
continue
}
if !rn.args.DeterministicNames && cName == nametransform.DirIVFilename {
// silently ignore "gocryptfs.diriv" everywhere if dirIV is enabled
continue
}
// Handle long file name
isLong := nametransform.LongNameNone
if rn.args.LongNames {
isLong = nametransform.NameType(cName)
}
if isLong == nametransform.LongNameContent {
cNameLong, err := nametransform.ReadLongNameAt(fd, cName)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: Could not read .name: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
cName = cNameLong
} else if isLong == nametransform.LongNameFilename {
// ignore "gocryptfs.longname.*.name"
continue
}
name, err := rn.nameTransform.DecryptName(cName, cachedIV)
if err != nil {
tlog.Warn.Printf("OpenDir %q: invalid entry %q: %v",
cDirName, cName, err)
rn.reportMitigatedCorruption(cName)
continue
}
// Override the ciphertext name with the plaintext name but reuse the rest
// of the structure
cipherEntries[i].Name = name
plain = append(plain, cipherEntries[i])
}
return fs.NewListDirStream(plain), 0
}
// Rmdir - FUSE call.
//
// Symlink-safe through Unlinkat() + AT_REMOVEDIR.
func (n *Node) Rmdir(ctx context.Context, name string) (code syscall.Errno) {
rn := n.rootNode()
parentDirFd, cName, errno := n.prepareAtSyscall(name)
if errno != 0 {
return errno
}
defer syscall.Close(parentDirFd)
if rn.args.PlaintextNames {
// Unlinkat with AT_REMOVEDIR is equivalent to Rmdir
err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR)
return fs.ToErrno(err)
}
if rn.args.DeterministicNames {
if err := unix.Unlinkat(parentDirFd, cName, unix.AT_REMOVEDIR); err != nil {
return fs.ToErrno(err)
}
if nametransform.IsLongContent(cName) {
nametransform.DeleteLongNameAt(parentDirFd, cName)
}
return 0
}
// Unless we are running as root, we need read, write and execute permissions
// to handle gocryptfs.diriv.
permWorkaround := false
var origMode uint32
if !rn.args.PreserveOwner {
var st unix.Stat_t
err := syscallcompat.Fstatat(parentDirFd, cName, &st, unix.AT_SYMLINK_NOFOLLOW)
if err != nil {
return fs.ToErrno(err)
}
if st.Mode&0700 != 0700 {
tlog.Debug.Printf("Rmdir: permWorkaround")
permWorkaround = true
// This cast is needed on Darwin, where st.Mode is uint16 | random_line_split |
|
engine.py | * self.margin):
# we use the same coef as the noise coef
#cell.diffusive_mass += val * self.environment.sigma
def log_status(self):
if self.datalog == None:
return
row = []
#row.append(self.iteration)
dm = [cell.diffusive_mass for cell in self.cells if cell]
row.append(sum(dm))
cm = [cell.crystal_mass for cell in self.cells if cell]
row.append(sum(cm))
bm = [cell.boundary_mass for cell in self.cells if cell]
row.append(sum(bm))
acnt = len([cell for cell in self.cells if cell and cell.attached])
row.append(acnt)
bcnt = len([cell for cell in self.cells if cell and cell.boundary])
row.append(bcnt)
d = self.snowflake_radius()
row.append(d)
row.append(self.environment.beta)
row.append(self.environment.theta)
row.append(self.environment.alpha)
row.append(self.environment.kappa)
row.append(self.environment.mu)
row.append(self.environment.upsilon)
#row.append(self.environment.sigma)
#row.append(self.environment.gamma)
self.datalog.append(row)
# log the cells
self.celllog.append((self.iteration, dm, cm))
def write_log(self):
self.write_datalog()
self.write_celllog()
def write_datalog(self):
if self.datalog == None:
return
logfn = "datalog.csv"
msg = "Saving runtime data to %s" % logfn
log(msg)
f = open(logfn, 'w')
txt = ''
txt += str.join(',', self.LogHeader) + '\n'
for row in self.datalog:
txt += str.join(',', map(str, row)) + '\n'
f.write(txt)
def write_celllog(self):
if not self.celllog:
return
logfn = "cell_log_%d.pickle" % self.iteration
f = open(logfn, 'wb')
pickle.dump(self.celllog, f, protocol=-1)
self.celllog = []
def print_status(self):
dm = sum([cell.diffusive_mass for cell in self.cells if cell])
cm = sum([cell.crystal_mass for cell in self.cells if cell])
bm = sum([cell.boundary_mass for cell in self.cells if cell])
acnt = len([cell for cell in self.cells if cell and cell.attached])
bcnt = len([cell for cell in self.cells if cell and cell.boundary])
#msg = "Step #%d, %d attached, %d boundary, %.2f dM, %.2f bM, %.2f cM, tot %.2f M" % (self.iteration, acnt, bcnt, dm, bm, cm, dm + cm + bm)
d = self.snowflake_radius()
msg = "Step #%d/%dp (%.2f%% scl), %d/%d (%.2f%%), %.2f dM, %.2f bM, %.2f cM, tot %.2f M" % (self.iteration, d, (float(d * 2 * X_SCALE_FACTOR) / self.iteration) * 100, acnt, bcnt, (float(bcnt) / acnt) * 100, dm, bm, cm, dm + cm + bm)
log(msg)
def step(self):
self.log_status()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_one()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_two()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_three()
# run curves
self.iteration += 1
self.environment.step(self.iteration)
def translate_xy(self, xy):
(x, y) = xy
x = int(round(x * X_SCALE_FACTOR))
return (x, y)
def polar_to_xy(self, args):
(angle, distance) = args
half = self.size / 2.0
angle = math.radians(angle)
y = int(round(half - (math.sin(angle) * distance)))
x = int(round(half + (math.cos(angle) * distance)))
return (x, y)
def xy_to_polar(self, args):
(x, y) = args
half = self.size / 2.0
x -= half
y += half
angle = math.degrees(math.atan2(y, x))
distance = math.hypot(x, y)
return (angle, distance)
def snowflake_radius(self, angle=135):
# we cast a ray on the 135 degeree axis
radius = 0
half = self.size / 2.0
while radius < half:
radius += 1
xy = self.polar_to_xy((angle, radius))
cell = self.cells[self._cell_index(xy)]
if cell.attached or cell.boundary:
continue
return radius
# uhh
return int(round(half))
def crop_snowflake(self, margin=None):
def scale(val):
return int(round(X_SCALE_FACTOR * val))
if margin == None:
margin = 15
half = self.size / 2
radius = scale(self.snowflake_radius())
distance = min(radius + margin, half)
half_s = scale(half)
distance_s = scale(distance)
box = (half_s - distance, half - distance, half_s + distance, half + distance)
return box
def headroom(self, margin=None):
if self.max_steps and self.iteration >= self.max_steps:
return False
if margin == None:
margin = self.margin
assert margin > 0 and margin <= 1
cutoff = int(round(margin * (self.size / 2.0)))
radius = self.snowflake_radius()
if radius > cutoff:
return False
return True
def grow(self):
while True:
if self.debug:
self.print_status()
self.step()
if self.iteration % 50 == 0:
self.write_celllog()
if not self.debug:
self.print_status()
if not self.headroom():
break
if self.debug:
self.print_status()
def save_image(self, fn, **kw):
import sfgen
r = sfgen.RenderSnowflake(self)
r.save_image(fn, **kw)
class SnowflakeCell(object):
def __init__(self, xy, lattice):
self.xy = xy
self.lattice = lattice
self.env = lattice.environment
self.diffusive_mass = self.env.gamma
self.boundary_mass = 0.0
self.crystal_mass = 0.0
self.attached = False
self.age = 0
self.boundary = 0
self.attached_neighbors = []
self.__neighbors = None
def __getstate__(self):
return (self.xy, self.diffusive_mass, self.boundary_mass, self.crystal_mass, self.attached, self.age)
def __setstate__(self, state):
self.xy = state[0]
self.diffusive_mass = state[1]
self.boundary_mass = state[2]
self.crystal_mass = state[3]
self.attached = state[4]
# 0.2 -> 0.3
try:
self.age = state[5]
except IndexError:
self.age = 0
self.__neighbors = None
self.lattice = None
self.env = None
def reality_check(self):
assert len(self.neighbors)
for neighbor in self.neighbors:
assert self in neighbor.neighbors, "%s not in %s" % (str(self), str(neighbor.neighbors))
def __repr__(self):
return "(%d,%d)" % self.xy
@property
def neighbors(self):
if self.__neighbors == None:
self.__neighbors = self.lattice.get_neighbors(self.xy)
return self.__neighbors
#@property
#def attached_neighbors(self):
# return [cell for cell in self.neighbors if cell.attached]
#@property
#def boundary(self):
# return (not self.attached) and any([cell.attached for cell in self.neighbors])
def update_boundary(self):
self.boundary = (not self.attached) and any([cell.attached for cell in self.neighbors])
def step_one(self):
self.update_boundary()
if self.boundary:
self.attached_neighbors = [cell for cell in self.neighbors if cell.attached]
self._next_dm = self.diffusion_calc()
def step_two(self):
self.diffusive_mass = self._next_dm
self.attachment_flag = self.attached
self.freezing_step()
self.attachment_flag = self.attachment_step()
self.melting_step()
def step_three(self):
if self.boundary and self.attachment_flag:
self.attach()
self.noise_step()
def diffusion_calc(self):
next_dm = self.diffusive_mass | if self.attached:
return next_dm
self.age += 1
for cell in self.neighbors: | random_line_split |
|
engine.py | .cells[idx] = cell
self.reality_check()
center_pt = self._cell_index((self.size / 2, self.size / 2))
self.cells[center_pt].attach(1)
# fun experiments
#self.cells[center_pt+4].attach(1)
#self.cells[center_pt-4].attach(1)
def _xy_ok(self, xy):
(x, y) = xy
return (x >= 0 and x < self.size and y >= 0 and y < self.size)
def _cell_index(self, xy):
(x, y) = xy
return int(round(y * self.size + x))
def _cell_xy(self, idx):
y = idx / self.size
x = idx % self.size
return (x, y)
def adjust_humidity(self, val):
val = abs(val)
for cell in self.cells:
if cell.attached or cell.boundary:
continue
cell.diffusive_mass += val * self.environment.sigma
# only mutate the cells outside our margin
#if self.xy_to_polar(cell.xy)[1] > (self.size * self.margin):
# we use the same coef as the noise coef
#cell.diffusive_mass += val * self.environment.sigma
def log_status(self):
if self.datalog == None:
return
row = []
#row.append(self.iteration)
dm = [cell.diffusive_mass for cell in self.cells if cell]
row.append(sum(dm))
cm = [cell.crystal_mass for cell in self.cells if cell]
row.append(sum(cm))
bm = [cell.boundary_mass for cell in self.cells if cell]
row.append(sum(bm))
acnt = len([cell for cell in self.cells if cell and cell.attached])
row.append(acnt)
bcnt = len([cell for cell in self.cells if cell and cell.boundary])
row.append(bcnt)
d = self.snowflake_radius()
row.append(d)
row.append(self.environment.beta)
row.append(self.environment.theta)
row.append(self.environment.alpha)
row.append(self.environment.kappa)
row.append(self.environment.mu)
row.append(self.environment.upsilon)
#row.append(self.environment.sigma)
#row.append(self.environment.gamma)
self.datalog.append(row)
# log the cells
self.celllog.append((self.iteration, dm, cm))
def write_log(self):
self.write_datalog()
self.write_celllog()
def write_datalog(self):
if self.datalog == None:
return
logfn = "datalog.csv"
msg = "Saving runtime data to %s" % logfn
log(msg)
f = open(logfn, 'w')
txt = ''
txt += str.join(',', self.LogHeader) + '\n'
for row in self.datalog:
txt += str.join(',', map(str, row)) + '\n'
f.write(txt)
def write_celllog(self):
if not self.celllog:
return
logfn = "cell_log_%d.pickle" % self.iteration
f = open(logfn, 'wb')
pickle.dump(self.celllog, f, protocol=-1)
self.celllog = []
def print_status(self):
dm = sum([cell.diffusive_mass for cell in self.cells if cell])
cm = sum([cell.crystal_mass for cell in self.cells if cell])
bm = sum([cell.boundary_mass for cell in self.cells if cell])
acnt = len([cell for cell in self.cells if cell and cell.attached])
bcnt = len([cell for cell in self.cells if cell and cell.boundary])
#msg = "Step #%d, %d attached, %d boundary, %.2f dM, %.2f bM, %.2f cM, tot %.2f M" % (self.iteration, acnt, bcnt, dm, bm, cm, dm + cm + bm)
d = self.snowflake_radius()
msg = "Step #%d/%dp (%.2f%% scl), %d/%d (%.2f%%), %.2f dM, %.2f bM, %.2f cM, tot %.2f M" % (self.iteration, d, (float(d * 2 * X_SCALE_FACTOR) / self.iteration) * 100, acnt, bcnt, (float(bcnt) / acnt) * 100, dm, bm, cm, dm + cm + bm)
log(msg)
def step(self):
self.log_status()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_one()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_two()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_three()
# run curves
self.iteration += 1
self.environment.step(self.iteration)
def translate_xy(self, xy):
(x, y) = xy
x = int(round(x * X_SCALE_FACTOR))
return (x, y)
def polar_to_xy(self, args):
(angle, distance) = args
half = self.size / 2.0
angle = math.radians(angle)
y = int(round(half - (math.sin(angle) * distance)))
x = int(round(half + (math.cos(angle) * distance)))
return (x, y)
def xy_to_polar(self, args):
(x, y) = args
half = self.size / 2.0
x -= half
y += half
angle = math.degrees(math.atan2(y, x))
distance = math.hypot(x, y)
return (angle, distance)
def snowflake_radius(self, angle=135):
# we cast a ray on the 135 degeree axis
radius = 0
half = self.size / 2.0
while radius < half:
radius += 1
xy = self.polar_to_xy((angle, radius))
cell = self.cells[self._cell_index(xy)]
if cell.attached or cell.boundary:
continue
return radius
# uhh
return int(round(half))
def crop_snowflake(self, margin=None):
def scale(val):
return int(round(X_SCALE_FACTOR * val))
if margin == None:
margin = 15
half = self.size / 2
radius = scale(self.snowflake_radius())
distance = min(radius + margin, half)
half_s = scale(half)
distance_s = scale(distance)
box = (half_s - distance, half - distance, half_s + distance, half + distance)
return box
def headroom(self, margin=None):
if self.max_steps and self.iteration >= self.max_steps:
return False
if margin == None:
margin = self.margin
assert margin > 0 and margin <= 1
cutoff = int(round(margin * (self.size / 2.0)))
radius = self.snowflake_radius()
if radius > cutoff:
return False
return True
def grow(self):
while True:
if self.debug:
self.print_status()
self.step()
if self.iteration % 50 == 0:
self.write_celllog()
if not self.debug:
self.print_status()
if not self.headroom():
break
if self.debug:
self.print_status()
def save_image(self, fn, **kw):
import sfgen
r = sfgen.RenderSnowflake(self)
r.save_image(fn, **kw)
class SnowflakeCell(object):
def __init__(self, xy, lattice):
self.xy = xy
self.lattice = lattice
self.env = lattice.environment
self.diffusive_mass = self.env.gamma
self.boundary_mass = 0.0
self.crystal_mass = 0.0
self.attached = False
self.age = 0
self.boundary = 0
self.attached_neighbors = []
self.__neighbors = None
def __getstate__(self):
return (self.xy, self.diffusive_mass, self.boundary_mass, self.crystal_mass, self.attached, self.age)
def __setstate__(self, state):
self.xy = state[0]
self.diffusive_mass = state[1]
self.boundary_mass = state[2]
self.crystal_mass = state[3]
self.attached = state[4]
# 0.2 -> 0.3
try:
self.age = state[5]
except IndexError:
self.age = 0
self.__neighbors = None
self.lattice = None
self.env = None
def reality_check(self):
assert len(self.neighbors)
for neighbor in self.neighbors:
assert self in neighbor.neighbors, "%s not in %s" % (str(self), str(neighbor.neighbors))
def __repr__(self):
return "(%d,%d)" % self.xy
@property
def neighbors(self):
if self.__neighbors == None:
| self.__neighbors = self.lattice.get_neighbors(self.xy) | conditional_block |
|
engine.py |
def step(self, x):
if self.curves == None:
return
for key in self.curves:
self[key] = self.curves[key][x]
@classmethod
def build_env(self, name, steps, min_gamma=0.45, max_gamma=0.85):
curves = {
"beta": (1.3, 2),
"theta": (0.01, 0.04),
"alpha": (0.02, 0.1),
"kappa": (0.001, 0.01),
"mu": (0.01, 0.1),
"upilson": (0.00001, 0.0001),
"sigma": (0.00001, 0.000001),
}
cs = CurveSet(name, steps, curves)
cs.run_graph()
env = {key: cs[key][0] for key in curves}
env["gamma"] = random.random() * (max_gamma - min_gamma) + min_gamma
return CrystalEnvironment(curves=cs, **env)
def get_default(self, key):
return self.factory_settings[key]
def randomize(self):
for key in self:
if key == "sigma":
continue
if key == "gamma":
self[key] += 1.0 / random.randint(100, 1000)
else:
self[key] += random.choice([1.0, -1.0]) / random.randint(100, 1000)
self.set_factory_settings()
def _init_defaults(self):
# (3a)
# "A boundary site with 1 or 2 attached neighbors needs boundary mass at least beta to join the crystal
# This is the case when the local mesoscopic geometry near x corresponds to a tip or flat spot of the crystal.
# (Distinguishing the two cases turns out to be of minor significance.) In our simulations, beta is typically
# between about 1.05 and 3. We assume beta > 1 since 1 is the basic threshold of the case to follow next.
self["beta"] = 1.3
# (3b)
# "A boundary site with 3 attached neighbors joins the crystal if either it has boundary mass >= 1,
# or it has diffusive mass < theta in its neighborhood and it has boundary mass >= alpha"
self["theta"] = 0.025
self["alpha"] = 0.08
# (2)
# "Proportion kappa of the diffusive mass at each boundary site crystallizes.
# The remainder (proportion 1 - kappa) becomes boundary mass."
self["kappa"] = 0.003
# (4)
# "Proportion mu of the boundary mass and proportion upsilon of the crystal mass at each boundary site become diffusive mass.
# Melting represents mass flow at the boundary from ice and quasi-liquid back to vapor, reverse
# effects from the freezing of step ii. Typically mu is small and upsilon extremely small."
self["mu"] = 0.07
self["upsilon"] = 0.00005
# (5)
# "The diffusive mass at each site undergoes an independent random perturbation of proportion sigma"
self["sigma"] = 0.00001
# initial diffusion
self["gamma"] = 0.5
def _init_special(self):
pass
# class RenderMovie(object) moved to movie.py
# 2018-0212
# class LatticeReplay(object) moved to movie.py
# 2018-0212
class CrystalLattice(object):
LogHeader = ["dm", "cm", "bm", "acnt", "bcnt", "width", "beta", "theta", "alpha", "kappa", "mu", "upsilon"]
def __init__(self, size, environment=None, celltype=None, max_steps=0, margin=None, curves=None, datalog=False, debug=False):
self.size = size
if environment == None:
environment = CrystalEnvironment()
self.environment = environment
self.datalog = None
self.celllog = None
if datalog:
self.datalog = []
self.celllog = []
if celltype == None:
celltype = SnowflakeCell
self.debug = debug
self.celltype = celltype
self.iteration = 1
assert margin > 0 and margin <= 1.0
self.margin = margin
self.curves = curves
self.max_steps = max_steps
self._init_cells()
def __setstate__(self, state):
# 0.1->0.2 format changes
if "radius" in state:
state["size"] = state["radius"]
del state["radius"]
if "angle" in state:
del state["angle"]
self.__dict__.update(state)
def save_lattice(self, fn):
msg = "Saving %s..." % fn
log(msg)
f = open(fn, 'wb')
pickle.dump(self, f, protocol=-1)
@classmethod
def load_lattice(cls, fn):
msg = "Loading %s..." % fn
log(msg)
f = open(fn, 'rb')
obj = pickle.load(f)
for cell in obj.cells:
cell.lattice = obj
cell.env = obj.environment
cell.update_boundary()
return obj
def get_neighbors(self, xy):
(x, y) = xy
nlist = [(x, y + 1), (x, y - 1), (x - 1, y), (x + 1, y), (x - 1, y - 1), (x + 1, y + 1)]
nlist = map(self._cell_index, filter(self._xy_ok, nlist))
res = tuple([self.cells[nidx] for nidx in nlist if self.cells[nidx] != None])
return res
def reality_check(self):
for cell in self.cells:
cell.reality_check()
def _init_cells(self):
self.cells = [None] * (self.size * self.size)
for x in range(self.size):
for y in range(self.size):
xy = (x, y)
cell = self.celltype(xy, self)
idx = self._cell_index(xy)
self.cells[idx] = cell
self.reality_check()
center_pt = self._cell_index((self.size / 2, self.size / 2))
self.cells[center_pt].attach(1)
# fun experiments
#self.cells[center_pt+4].attach(1)
#self.cells[center_pt-4].attach(1)
def _xy_ok(self, xy):
(x, y) = xy
return (x >= 0 and x < self.size and y >= 0 and y < self.size)
def _cell_index(self, xy):
(x, y) = xy
return int(round(y * self.size + x))
def _cell_xy(self, idx):
y = idx / self.size
x = idx % self.size
return (x, y)
def adjust_humidity(self, val):
val = abs(val)
for cell in self.cells:
if cell.attached or cell.boundary:
continue
cell.diffusive_mass += val * self.environment.sigma
# only mutate the cells outside our margin
#if self.xy_to_polar(cell.xy)[1] > (self.size * self.margin):
# we use the same coef as the noise coef
#cell.diffusive_mass += val * self.environment.sigma
def log_status(self):
if self.datalog == None:
return
row = []
#row.append(self.iteration)
dm = [cell.diffusive_mass for cell in self.cells if cell]
row.append(sum(dm))
cm = [cell.crystal_mass for cell in self.cells if cell]
row.append(sum(cm))
bm = [cell.boundary_mass for cell in self.cells if cell]
row.append(sum(bm))
acnt = len([cell for cell in self.cells if cell and cell.attached])
row.append(acnt)
bcnt = len([cell for cell in self.cells if cell and cell.boundary])
row.append(bcnt)
d = self.snowflake_radius()
row.append(d)
row.append(self.environment.beta)
row.append(self.environment.theta)
row.append(self.environment.alpha)
row.append(self.environment.kappa)
row.append(self.environment.mu)
row.append(self.environment.upsilon)
#row.append(self.environment.sigma)
#row.append(self.environment.gamma)
self.datalog.append(row)
# log the cells
self.celllog.append((self.iter | if type(state) == dict:
self.update(state)
self.curves = None
self.set_factory_settings()
else:
self.curves = state[0]
self.factory_settings = state[1]
self.update(state[2]) | identifier_body |
|
engine.py | cell for cell in self.cells if cell and cell.boundary])
row.append(bcnt)
d = self.snowflake_radius()
row.append(d)
row.append(self.environment.beta)
row.append(self.environment.theta)
row.append(self.environment.alpha)
row.append(self.environment.kappa)
row.append(self.environment.mu)
row.append(self.environment.upsilon)
#row.append(self.environment.sigma)
#row.append(self.environment.gamma)
self.datalog.append(row)
# log the cells
self.celllog.append((self.iteration, dm, cm))
def write_log(self):
self.write_datalog()
self.write_celllog()
def write_datalog(self):
if self.datalog == None:
return
logfn = "datalog.csv"
msg = "Saving runtime data to %s" % logfn
log(msg)
f = open(logfn, 'w')
txt = ''
txt += str.join(',', self.LogHeader) + '\n'
for row in self.datalog:
txt += str.join(',', map(str, row)) + '\n'
f.write(txt)
def write_celllog(self):
if not self.celllog:
return
logfn = "cell_log_%d.pickle" % self.iteration
f = open(logfn, 'wb')
pickle.dump(self.celllog, f, protocol=-1)
self.celllog = []
def print_status(self):
dm = sum([cell.diffusive_mass for cell in self.cells if cell])
cm = sum([cell.crystal_mass for cell in self.cells if cell])
bm = sum([cell.boundary_mass for cell in self.cells if cell])
acnt = len([cell for cell in self.cells if cell and cell.attached])
bcnt = len([cell for cell in self.cells if cell and cell.boundary])
#msg = "Step #%d, %d attached, %d boundary, %.2f dM, %.2f bM, %.2f cM, tot %.2f M" % (self.iteration, acnt, bcnt, dm, bm, cm, dm + cm + bm)
d = self.snowflake_radius()
msg = "Step #%d/%dp (%.2f%% scl), %d/%d (%.2f%%), %.2f dM, %.2f bM, %.2f cM, tot %.2f M" % (self.iteration, d, (float(d * 2 * X_SCALE_FACTOR) / self.iteration) * 100, acnt, bcnt, (float(bcnt) / acnt) * 100, dm, bm, cm, dm + cm + bm)
log(msg)
def step(self):
self.log_status()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_one()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_two()
for cell in self.cells:
if cell == None or cell.attached:
continue
cell.step_three()
# run curves
self.iteration += 1
self.environment.step(self.iteration)
def translate_xy(self, xy):
(x, y) = xy
x = int(round(x * X_SCALE_FACTOR))
return (x, y)
def polar_to_xy(self, args):
(angle, distance) = args
half = self.size / 2.0
angle = math.radians(angle)
y = int(round(half - (math.sin(angle) * distance)))
x = int(round(half + (math.cos(angle) * distance)))
return (x, y)
def xy_to_polar(self, args):
(x, y) = args
half = self.size / 2.0
x -= half
y += half
angle = math.degrees(math.atan2(y, x))
distance = math.hypot(x, y)
return (angle, distance)
def snowflake_radius(self, angle=135):
# we cast a ray on the 135 degeree axis
radius = 0
half = self.size / 2.0
while radius < half:
radius += 1
xy = self.polar_to_xy((angle, radius))
cell = self.cells[self._cell_index(xy)]
if cell.attached or cell.boundary:
continue
return radius
# uhh
return int(round(half))
def crop_snowflake(self, margin=None):
def scale(val):
return int(round(X_SCALE_FACTOR * val))
if margin == None:
margin = 15
half = self.size / 2
radius = scale(self.snowflake_radius())
distance = min(radius + margin, half)
half_s = scale(half)
distance_s = scale(distance)
box = (half_s - distance, half - distance, half_s + distance, half + distance)
return box
def headroom(self, margin=None):
if self.max_steps and self.iteration >= self.max_steps:
return False
if margin == None:
margin = self.margin
assert margin > 0 and margin <= 1
cutoff = int(round(margin * (self.size / 2.0)))
radius = self.snowflake_radius()
if radius > cutoff:
return False
return True
def grow(self):
while True:
if self.debug:
self.print_status()
self.step()
if self.iteration % 50 == 0:
self.write_celllog()
if not self.debug:
self.print_status()
if not self.headroom():
break
if self.debug:
self.print_status()
def save_image(self, fn, **kw):
import sfgen
r = sfgen.RenderSnowflake(self)
r.save_image(fn, **kw)
class SnowflakeCell(object):
def __init__(self, xy, lattice):
self.xy = xy
self.lattice = lattice
self.env = lattice.environment
self.diffusive_mass = self.env.gamma
self.boundary_mass = 0.0
self.crystal_mass = 0.0
self.attached = False
self.age = 0
self.boundary = 0
self.attached_neighbors = []
self.__neighbors = None
def __getstate__(self):
return (self.xy, self.diffusive_mass, self.boundary_mass, self.crystal_mass, self.attached, self.age)
def __setstate__(self, state):
self.xy = state[0]
self.diffusive_mass = state[1]
self.boundary_mass = state[2]
self.crystal_mass = state[3]
self.attached = state[4]
# 0.2 -> 0.3
try:
self.age = state[5]
except IndexError:
self.age = 0
self.__neighbors = None
self.lattice = None
self.env = None
def reality_check(self):
assert len(self.neighbors)
for neighbor in self.neighbors:
assert self in neighbor.neighbors, "%s not in %s" % (str(self), str(neighbor.neighbors))
def __repr__(self):
return "(%d,%d)" % self.xy
@property
def neighbors(self):
if self.__neighbors == None:
self.__neighbors = self.lattice.get_neighbors(self.xy)
return self.__neighbors
#@property
#def attached_neighbors(self):
# return [cell for cell in self.neighbors if cell.attached]
#@property
#def boundary(self):
# return (not self.attached) and any([cell.attached for cell in self.neighbors])
def update_boundary(self):
self.boundary = (not self.attached) and any([cell.attached for cell in self.neighbors])
def step_one(self):
self.update_boundary()
if self.boundary:
self.attached_neighbors = [cell for cell in self.neighbors if cell.attached]
self._next_dm = self.diffusion_calc()
def step_two(self):
self.diffusive_mass = self._next_dm
self.attachment_flag = self.attached
self.freezing_step()
self.attachment_flag = self.attachment_step()
self.melting_step()
def step_three(self):
if self.boundary and self.attachment_flag:
self.attach()
self.noise_step()
def diffusion_calc(self):
next_dm = self.diffusive_mass
if self.attached:
return next_dm
self.age += 1
for cell in self.neighbors:
if cell.attached:
next_dm += self.diffusive_mass
else:
next_dm += cell.diffusive_mass
return float(next_dm) / (len(self.neighbors) + 1)
def attach(self, offset=0.0):
self.crystal_mass = self.boundary_mass + self.crystal_mass + offset
self.boundary_mass = 0
self.attached = True
def freezing_step(self):
if not self.boundary:
return
self.boundary_mass += (1 - self.env.kappa) * self.diffusive_mass
self.crystal_mass += (self.env.kappa * self.diffusive_mass)
self.diffusive_mass = 0
def | attachment_step | identifier_name |
|
rcparser.py |
class DialogDef:
name = ""
id = 0
style = 0
styleEx = None
caption = ""
font = "MS Sans Serif"
fontSize = 8
x = 0
y = 0
w = 0
h = 0
template = None
def __init__(self, n, i):
self.name = n
self.id = i
self.styles = []
self.stylesEx = []
self.controls = []
def createDialogTemplate(self):
t = None
self.template = [[self.caption, (self.x,self.y,self.w,self.h), self.style, self.styleEx, (self.fontSize, self.font)]]
for control in self.controls:
self.template.append(control.createDialogTemplate())
return self.template
class ControlDef:
id = ""
controlType = ""
subType = ""
idNum = 0
style = defaultControlStyle
label = ""
x = 0
y = 0
w = 0
h = 0
def __init__(self):
self.styles = []
def toString(self):
s = "<Control id:"+self.id+" controlType:"+self.controlType+" subType:"+self.subType\
+" idNum:"+str(self.idNum)+" style:"+str(self.style)+" styles:"+str(self.styles)+" label:"+self.label\
+" x:"+str(self.x)+" y:"+str(self.y)+" w:"+str(self.w)+" h:"+str(self.h)+">"
return s
def createDialogTemplate(self):
ct = self.controlType
if "CONTROL"==ct:
ct = self.subType
if ct in _addDefaults:
self.style |= _addDefaults[ct]
if ct in _controlMap:
ct = _controlMap[ct]
t = [ct, self.label, self.idNum, (self.x, self.y, self.w, self.h), self.style]
return t
class gt_str(str):
"""Change a string to a gettext version of itself."""
def __repr__(self):
if len(self) > 0:
return "_(" + super(gt_str, self).__repr__() + ")"
else:
return super(gt_str, self).__repr__()
class RCParser:
next_id = 1001
dialogs = {}
_dialogs = {}
debugEnabled = False
token = ""
def __init__(self):
self.ids = {"IDOK":1, "IDCANCEL":2, "IDC_STATIC": -1}
self.names = {1:"IDOK", 2:"IDCANCEL", -1:"IDC_STATIC"}
self.bitmaps = {}
self.gettexted = False
def debug(self, *args):
if self.debugEnabled:
print(args)
def | (self):
self.token = self.lex.get_token()
self.debug("getToken returns:", self.token)
if self.token=="":
self.token = None
return self.token
def getCommaToken(self):
tok = self.getToken()
assert tok == ",", "Token '%s' should be a comma!" % tok
def loadDialogs(self, rcFileName):
"""
RCParser.loadDialogs(rcFileName) -> None
Load the dialog information into the parser. Dialog Definations can then be accessed
using the "dialogs" dictionary member (name->DialogDef). The "ids" member contains the dictionary of id->name.
The "names" member contains the dictionary of name->id
"""
hFileName = rcFileName[:-2]+"h"
if not os.path.exists(hFileName):
hFileName = os.path.join(os.path.dirname(__file__),
os.path.basename(hFileName))
try:
h = open(hFileName, "rU")
self.parseH(h)
h.close()
except IOError:
print("No .h file. ignoring.")
f = open(rcFileName)
self.open(f)
self.getToken()
while self.token!=None:
self.parse()
self.getToken()
f.close()
def open(self, file):
self.lex = shlex.shlex(file)
self.lex.commenters = "//#"
def parseH(self, file):
lex = shlex.shlex(file)
lex.commenters = "//"
token = " "
while token is not None:
token = lex.get_token()
if token == "" or token is None:
token = None
else:
if token=='define':
n = lex.get_token()
i = int(lex.get_token())
self.ids[n] = i
if i in self.names:
if not n.startswith("_APS_"):
print("Duplicate id",i,"for",n,"is", self.names[i])
else:
self.names[i] = n
if self.next_id<=i:
self.next_id = i+1
def parse(self):
deep = 0
if self.token == None:
more == None
elif "BEGIN" == self.token:
deep = 1
while deep!=0:
self.getToken()
if "BEGIN" == self.token:
deep += 1
elif "END" == self.token:
deep -= 1
elif "IDD_" == self.token[:4]:
possibleDlgName = self.token
self.getToken()
if "DIALOG" == self.token or "DIALOGEX" == self.token:
self.dialog(possibleDlgName)
elif "IDB_" == self.token[:4]:
possibleBitmap = self.token
self.getToken()
if "BITMAP" == self.token:
self.getToken()
if self.token=="MOVEABLE":
self.getToken() # PURE
self.getToken() # bmpname
bmf = self.token[1:-1] # quotes
self.bitmaps[possibleBitmap] = bmf
print("BITMAP", possibleBitmap, bmf)
def addId(self, id_name):
if id_name in self.ids:
id = self.ids[id_name]
else:
id = self.next_id
self.next_id += 1
self.ids[id_name] = id
self.names[id] = id_name
return id
def lang(self):
while self.token[0:4]=="LANG" or self.token[0:7]=="SUBLANG" or self.token==',':
self.getToken();
def dialog(self, name):
dlg = DialogDef(name,self.addId(name))
assert len(dlg.controls)==0
self._dialogs[name] = dlg
extras = []
self.getToken()
while not self.token.isdigit():
self.debug("extra", self.token)
extras.append(self.token)
self.getToken()
dlg.x = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.y = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.w = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.h = int(self.token)
self.getToken()
while not (self.token==None or self.token=="" or self.token=="END"):
if self.token=="STYLE":
self.dialogStyle(dlg)
elif self.token=="EXSTYLE":
self.dialogExStyle(dlg)
elif self.token=="CAPTION":
self.dialogCaption(dlg)
elif self.token=="FONT":
self.dialogFont(dlg)
elif self.token=="BEGIN":
self.controls(dlg)
else:
break
self.dialogs[name] = dlg.createDialogTemplate()
def dialogStyle(self, dlg):
dlg.style, dlg.styles = self.styles( [], win32con.WS_VISIBLE | win32con.DS_SETFONT)
def dialogExStyle(self, dlg):
self.getToken()
dlg.styleEx, dlg.stylesEx = self.styles( [], 0)
def styles(self, defaults, defaultStyle):
list = defaults
style = defaultStyle
if "STYLE"==self.token:
self.getToken()
i = 0
Not = False
while ((i%2==1 and ("|"==self.token or "NOT"==self.token)) or (i%2==0)) and not self.token==None:
Not = False;
if "NOT"==self.token:
Not = True
self.getToken()
i += 1
if self.token!="|":
if self.token in win32con.__dict__:
value = getattr(win32con,self.token)
else:
if self.token in commctrl.__dict__:
value = getattr(commctrl,self.token)
else:
value = 0
if Not:
list.append("NOT "+self.token)
self.debug("styles add Not",self.token, value)
style &= ~value
else:
list.append(self.token)
self.debug("styles add", self.token, value)
style |= value
self.getToken()
self.debug("style is ",style)
return style, list
def dialogCaption(self, dlg):
if "CAPTION"==self.token:
self.getToken()
self.token = self.token[1:-1]
self.debug("Caption is:",self.token)
if self.gettexted:
dlg.caption = gt_str(self.token)
else:
dlg.caption = self.token
self.getToken()
def dialogFont | getToken | identifier_name |
rcparser.py |
class DialogDef:
name = ""
id = 0
style = 0
styleEx = None
caption = ""
font = "MS Sans Serif"
fontSize = 8
x = 0
y = 0
w = 0
h = 0
template = None
def __init__(self, n, i):
self.name = n
self.id = i
self.styles = []
self.stylesEx = []
self.controls = []
def createDialogTemplate(self):
t = None
self.template = [[self.caption, (self.x,self.y,self.w,self.h), self.style, self.styleEx, (self.fontSize, self.font)]]
for control in self.controls:
self.template.append(control.createDialogTemplate())
return self.template
class ControlDef:
id = ""
controlType = ""
subType = ""
idNum = 0
style = defaultControlStyle
label = ""
x = 0
y = 0
w = 0
h = 0
def __init__(self):
self.styles = []
def toString(self):
s = "<Control id:"+self.id+" controlType:"+self.controlType+" subType:"+self.subType\
+" idNum:"+str(self.idNum)+" style:"+str(self.style)+" styles:"+str(self.styles)+" label:"+self.label\
+" x:"+str(self.x)+" y:"+str(self.y)+" w:"+str(self.w)+" h:"+str(self.h)+">"
return s
def createDialogTemplate(self):
ct = self.controlType
if "CONTROL"==ct:
ct = self.subType
if ct in _addDefaults:
self.style |= _addDefaults[ct]
if ct in _controlMap:
ct = _controlMap[ct]
t = [ct, self.label, self.idNum, (self.x, self.y, self.w, self.h), self.style]
return t
class gt_str(str):
"""Change a string to a gettext version of itself."""
def __repr__(self):
if len(self) > 0:
return "_(" + super(gt_str, self).__repr__() + ")"
else:
return super(gt_str, self).__repr__()
class RCParser:
next_id = 1001
dialogs = {}
_dialogs = {}
debugEnabled = False
token = ""
def __init__(self):
self.ids = {"IDOK":1, "IDCANCEL":2, "IDC_STATIC": -1}
self.names = {1:"IDOK", 2:"IDCANCEL", -1:"IDC_STATIC"}
self.bitmaps = {}
self.gettexted = False
def debug(self, *args):
if self.debugEnabled:
print(args)
def getToken(self):
self.token = self.lex.get_token()
self.debug("getToken returns:", self.token)
if self.token=="":
self.token = None
return self.token
def getCommaToken(self):
tok = self.getToken()
assert tok == ",", "Token '%s' should be a comma!" % tok
def loadDialogs(self, rcFileName):
"""
RCParser.loadDialogs(rcFileName) -> None
Load the dialog information into the parser. Dialog Definations can then be accessed
using the "dialogs" dictionary member (name->DialogDef). The "ids" member contains the dictionary of id->name.
The "names" member contains the dictionary of name->id
"""
hFileName = rcFileName[:-2]+"h"
if not os.path.exists(hFileName):
hFileName = os.path.join(os.path.dirname(__file__),
os.path.basename(hFileName))
try:
h = open(hFileName, "rU")
self.parseH(h)
h.close()
except IOError:
print("No .h file. ignoring.")
f = open(rcFileName)
self.open(f)
self.getToken()
while self.token!=None:
self.parse()
self.getToken()
f.close()
def open(self, file):
self.lex = shlex.shlex(file)
self.lex.commenters = "//#"
def parseH(self, file):
lex = shlex.shlex(file)
lex.commenters = "//"
token = " "
while token is not None:
token = lex.get_token()
if token == "" or token is None:
token = None
else:
if token=='define':
n = lex.get_token()
i = int(lex.get_token())
self.ids[n] = i
if i in self.names:
if not n.startswith("_APS_"):
print("Duplicate id",i,"for",n,"is", self.names[i])
else:
self.names[i] = n
if self.next_id<=i:
self.next_id = i+1
def parse(self):
deep = 0
if self.token == None:
more == None
elif "BEGIN" == self.token:
deep = 1
while deep!=0:
self.getToken()
if "BEGIN" == self.token:
deep += 1
elif "END" == self.token:
deep -= 1
elif "IDD_" == self.token[:4]:
possibleDlgName = self.token
self.getToken()
if "DIALOG" == self.token or "DIALOGEX" == self.token:
self.dialog(possibleDlgName)
elif "IDB_" == self.token[:4]:
possibleBitmap = self.token
self.getToken()
if "BITMAP" == self.token:
self.getToken()
if self.token=="MOVEABLE":
self.getToken() # PURE
self.getToken() # bmpname
bmf = self.token[1:-1] # quotes
self.bitmaps[possibleBitmap] = bmf
print("BITMAP", possibleBitmap, bmf)
def addId(self, id_name):
if id_name in self.ids:
id = self.ids[id_name]
else:
id = self.next_id
self.next_id += 1
self.ids[id_name] = id
self.names[id] = id_name
return id
def lang(self):
while self.token[0:4]=="LANG" or self.token[0:7]=="SUBLANG" or self.token==',':
self.getToken();
def dialog(self, name):
dlg = DialogDef(name,self.addId(name))
assert len(dlg.controls)==0
self._dialogs[name] = dlg
extras = []
self.getToken()
while not self.token.isdigit():
self.debug("extra", self.token)
extras.append(self.token)
self.getToken()
dlg.x = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.y = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.w = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.h = int(self.token)
self.getToken()
while not (self.token==None or self.token=="" or self.token=="END"):
|
self.dialogs[name] = dlg.createDialogTemplate()
def dialogStyle(self, dlg):
dlg.style, dlg.styles = self.styles( [], win32con.WS_VISIBLE | win32con.DS_SETFONT)
def dialogExStyle(self, dlg):
self.getToken()
dlg.styleEx, dlg.stylesEx = self.styles( [], 0)
def styles(self, defaults, defaultStyle):
list = defaults
style = defaultStyle
if "STYLE"==self.token:
self.getToken()
i = 0
Not = False
while ((i%2==1 and ("|"==self.token or "NOT"==self.token)) or (i%2==0)) and not self.token==None:
Not = False;
if "NOT"==self.token:
Not = True
self.getToken()
i += 1
if self.token!="|":
if self.token in win32con.__dict__:
value = getattr(win32con,self.token)
else:
if self.token in commctrl.__dict__:
value = getattr(commctrl,self.token)
else:
value = 0
if Not:
list.append("NOT "+self.token)
self.debug("styles add Not",self.token, value)
style &= ~value
else:
list.append(self.token)
self.debug("styles add", self.token, value)
style |= value
self.getToken()
self.debug("style is ",style)
return style, list
def dialogCaption(self, dlg):
if "CAPTION"==self.token:
self.getToken()
self.token = self.token[1:-1]
self.debug("Caption is:",self.token)
if self.gettexted:
dlg.caption = gt_str(self.token)
else:
dlg.caption = self.token
self.getToken()
def dialogFont(self | if self.token=="STYLE":
self.dialogStyle(dlg)
elif self.token=="EXSTYLE":
self.dialogExStyle(dlg)
elif self.token=="CAPTION":
self.dialogCaption(dlg)
elif self.token=="FONT":
self.dialogFont(dlg)
elif self.token=="BEGIN":
self.controls(dlg)
else:
break | conditional_block |
rcparser.py |
class DialogDef:
name = ""
id = 0
style = 0
styleEx = None
caption = ""
font = "MS Sans Serif"
fontSize = 8
x = 0
y = 0
w = 0
h = 0
template = None
def __init__(self, n, i):
self.name = n
self.id = i
self.styles = []
self.stylesEx = []
self.controls = []
def createDialogTemplate(self):
t = None
self.template = [[self.caption, (self.x,self.y,self.w,self.h), self.style, self.styleEx, (self.fontSize, self.font)]]
for control in self.controls:
self.template.append(control.createDialogTemplate())
return self.template
class ControlDef:
id = ""
controlType = ""
subType = ""
idNum = 0
style = defaultControlStyle
label = ""
x = 0
y = 0
w = 0
h = 0
def __init__(self):
self.styles = []
def toString(self):
s = "<Control id:"+self.id+" controlType:"+self.controlType+" subType:"+self.subType\
+" idNum:"+str(self.idNum)+" style:"+str(self.style)+" styles:"+str(self.styles)+" label:"+self.label\
+" x:"+str(self.x)+" y:"+str(self.y)+" w:"+str(self.w)+" h:"+str(self.h)+">"
return s
def createDialogTemplate(self):
ct = self.controlType
if "CONTROL"==ct:
ct = self.subType
if ct in _addDefaults:
self.style |= _addDefaults[ct]
if ct in _controlMap:
ct = _controlMap[ct]
t = [ct, self.label, self.idNum, (self.x, self.y, self.w, self.h), self.style]
return t
class gt_str(str):
"""Change a string to a gettext version of itself."""
def __repr__(self):
if len(self) > 0:
return "_(" + super(gt_str, self).__repr__() + ")"
else:
return super(gt_str, self).__repr__()
class RCParser:
next_id = 1001
dialogs = {}
_dialogs = {}
debugEnabled = False
token = ""
def __init__(self):
self.ids = {"IDOK":1, "IDCANCEL":2, "IDC_STATIC": -1}
self.names = {1:"IDOK", 2:"IDCANCEL", -1:"IDC_STATIC"}
self.bitmaps = {}
self.gettexted = False
def debug(self, *args):
if self.debugEnabled:
print(args)
def getToken(self):
self.token = self.lex.get_token()
self.debug("getToken returns:", self.token)
if self.token=="":
self.token = None
return self.token
def getCommaToken(self):
tok = self.getToken()
assert tok == ",", "Token '%s' should be a comma!" % tok
def loadDialogs(self, rcFileName):
"""
RCParser.loadDialogs(rcFileName) -> None
Load the dialog information into the parser. Dialog Definations can then be accessed
using the "dialogs" dictionary member (name->DialogDef). The "ids" member contains the dictionary of id->name.
The "names" member contains the dictionary of name->id
"""
hFileName = rcFileName[:-2]+"h"
if not os.path.exists(hFileName):
hFileName = os.path.join(os.path.dirname(__file__),
os.path.basename(hFileName))
try:
h = open(hFileName, "rU")
self.parseH(h)
h.close()
except IOError:
print("No .h file. ignoring.")
f = open(rcFileName)
self.open(f)
self.getToken()
while self.token!=None:
self.parse()
self.getToken()
f.close()
def open(self, file):
self.lex = shlex.shlex(file)
self.lex.commenters = "//#"
def parseH(self, file):
lex = shlex.shlex(file)
lex.commenters = "//"
token = " "
while token is not None:
token = lex.get_token()
if token == "" or token is None:
token = None
else:
if token=='define':
n = lex.get_token()
i = int(lex.get_token())
self.ids[n] = i
if i in self.names:
if not n.startswith("_APS_"):
print("Duplicate id",i,"for",n,"is", self.names[i])
else:
self.names[i] = n
if self.next_id<=i:
self.next_id = i+1
def parse(self):
deep = 0
if self.token == None:
more == None
elif "BEGIN" == self.token:
deep = 1
while deep!=0:
self.getToken()
if "BEGIN" == self.token:
deep += 1
elif "END" == self.token:
deep -= 1
elif "IDD_" == self.token[:4]:
possibleDlgName = self.token
self.getToken()
if "DIALOG" == self.token or "DIALOGEX" == self.token:
self.dialog(possibleDlgName)
elif "IDB_" == self.token[:4]:
possibleBitmap = self.token
self.getToken()
if "BITMAP" == self.token:
self.getToken()
if self.token=="MOVEABLE":
self.getToken() # PURE
self.getToken() # bmpname
bmf = self.token[1:-1] # quotes
self.bitmaps[possibleBitmap] = bmf
print("BITMAP", possibleBitmap, bmf)
def addId(self, id_name):
if id_name in self.ids:
id = self.ids[id_name]
else:
id = self.next_id
self.next_id += 1
self.ids[id_name] = id
self.names[id] = id_name
return id
def lang(self):
while self.token[0:4]=="LANG" or self.token[0:7]=="SUBLANG" or self.token==',':
self.getToken();
def dialog(self, name):
dlg = DialogDef(name,self.addId(name))
assert len(dlg.controls)==0
self._dialogs[name] = dlg
extras = []
self.getToken()
while not self.token.isdigit():
self.debug("extra", self.token)
extras.append(self.token)
self.getToken()
dlg.x = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.y = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.w = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.h = int(self.token)
self.getToken()
while not (self.token==None or self.token=="" or self.token=="END"):
if self.token=="STYLE":
self.dialogStyle(dlg)
elif self.token=="EXSTYLE":
self.dialogExStyle(dlg)
elif self.token=="CAPTION":
self.dialogCaption(dlg)
elif self.token=="FONT":
self.dialogFont(dlg)
elif self.token=="BEGIN":
self.controls(dlg)
else:
break
self.dialogs[name] = dlg.createDialogTemplate()
def dialogStyle(self, dlg):
dlg.style, dlg.styles = self.styles( [], win32con.WS_VISIBLE | win32con.DS_SETFONT)
def dialogExStyle(self, dlg):
self.getToken()
dlg.styleEx, dlg.stylesEx = self.styles( [], 0)
def styles(self, defaults, defaultStyle):
list = defaults
style = defaultStyle
if "STYLE"==self.token:
self.getToken()
i = 0
Not = False
while ((i%2==1 and ("|"==self.token or "NOT"==self.token)) or (i%2==0)) and not self.token==None:
Not = False;
if "NOT"==self.token:
Not = True
self.getToken()
i += 1
if self.token!="|":
if self.token in win32con.__dict__:
value = getattr(win32con,self.token)
else:
if self.token in commctrl.__dict__:
value = getattr(commctrl,self.token)
else:
value = 0
if Not:
list.append("NOT "+self.token)
self.debug("styles add Not",self.token, value)
style &= ~value
else:
list.append(self.token)
self.debug("styles add", self.token, value)
style |= value
self.getToken()
self.debug("style is ",style)
return style, list
def dialogCaption(self, dlg):
|
def dialogFont | if "CAPTION"==self.token:
self.getToken()
self.token = self.token[1:-1]
self.debug("Caption is:",self.token)
if self.gettexted:
dlg.caption = gt_str(self.token)
else:
dlg.caption = self.token
self.getToken() | identifier_body |
rcparser.py | _VISIBLE
class DialogDef:
name = ""
id = 0
style = 0
styleEx = None
caption = ""
font = "MS Sans Serif"
fontSize = 8
x = 0
y = 0
w = 0
h = 0
template = None
def __init__(self, n, i):
self.name = n
self.id = i
self.styles = []
self.stylesEx = []
self.controls = []
def createDialogTemplate(self):
t = None
self.template = [[self.caption, (self.x,self.y,self.w,self.h), self.style, self.styleEx, (self.fontSize, self.font)]]
for control in self.controls:
self.template.append(control.createDialogTemplate())
return self.template
class ControlDef:
id = ""
controlType = ""
subType = "" | label = ""
x = 0
y = 0
w = 0
h = 0
def __init__(self):
self.styles = []
def toString(self):
s = "<Control id:"+self.id+" controlType:"+self.controlType+" subType:"+self.subType\
+" idNum:"+str(self.idNum)+" style:"+str(self.style)+" styles:"+str(self.styles)+" label:"+self.label\
+" x:"+str(self.x)+" y:"+str(self.y)+" w:"+str(self.w)+" h:"+str(self.h)+">"
return s
def createDialogTemplate(self):
ct = self.controlType
if "CONTROL"==ct:
ct = self.subType
if ct in _addDefaults:
self.style |= _addDefaults[ct]
if ct in _controlMap:
ct = _controlMap[ct]
t = [ct, self.label, self.idNum, (self.x, self.y, self.w, self.h), self.style]
return t
class gt_str(str):
"""Change a string to a gettext version of itself."""
def __repr__(self):
if len(self) > 0:
return "_(" + super(gt_str, self).__repr__() + ")"
else:
return super(gt_str, self).__repr__()
class RCParser:
next_id = 1001
dialogs = {}
_dialogs = {}
debugEnabled = False
token = ""
def __init__(self):
self.ids = {"IDOK":1, "IDCANCEL":2, "IDC_STATIC": -1}
self.names = {1:"IDOK", 2:"IDCANCEL", -1:"IDC_STATIC"}
self.bitmaps = {}
self.gettexted = False
def debug(self, *args):
if self.debugEnabled:
print(args)
def getToken(self):
self.token = self.lex.get_token()
self.debug("getToken returns:", self.token)
if self.token=="":
self.token = None
return self.token
def getCommaToken(self):
tok = self.getToken()
assert tok == ",", "Token '%s' should be a comma!" % tok
def loadDialogs(self, rcFileName):
"""
RCParser.loadDialogs(rcFileName) -> None
Load the dialog information into the parser. Dialog Definations can then be accessed
using the "dialogs" dictionary member (name->DialogDef). The "ids" member contains the dictionary of id->name.
The "names" member contains the dictionary of name->id
"""
hFileName = rcFileName[:-2]+"h"
if not os.path.exists(hFileName):
hFileName = os.path.join(os.path.dirname(__file__),
os.path.basename(hFileName))
try:
h = open(hFileName, "rU")
self.parseH(h)
h.close()
except IOError:
print("No .h file. ignoring.")
f = open(rcFileName)
self.open(f)
self.getToken()
while self.token!=None:
self.parse()
self.getToken()
f.close()
def open(self, file):
self.lex = shlex.shlex(file)
self.lex.commenters = "//#"
def parseH(self, file):
lex = shlex.shlex(file)
lex.commenters = "//"
token = " "
while token is not None:
token = lex.get_token()
if token == "" or token is None:
token = None
else:
if token=='define':
n = lex.get_token()
i = int(lex.get_token())
self.ids[n] = i
if i in self.names:
if not n.startswith("_APS_"):
print("Duplicate id",i,"for",n,"is", self.names[i])
else:
self.names[i] = n
if self.next_id<=i:
self.next_id = i+1
def parse(self):
deep = 0
if self.token == None:
more == None
elif "BEGIN" == self.token:
deep = 1
while deep!=0:
self.getToken()
if "BEGIN" == self.token:
deep += 1
elif "END" == self.token:
deep -= 1
elif "IDD_" == self.token[:4]:
possibleDlgName = self.token
self.getToken()
if "DIALOG" == self.token or "DIALOGEX" == self.token:
self.dialog(possibleDlgName)
elif "IDB_" == self.token[:4]:
possibleBitmap = self.token
self.getToken()
if "BITMAP" == self.token:
self.getToken()
if self.token=="MOVEABLE":
self.getToken() # PURE
self.getToken() # bmpname
bmf = self.token[1:-1] # quotes
self.bitmaps[possibleBitmap] = bmf
print("BITMAP", possibleBitmap, bmf)
def addId(self, id_name):
if id_name in self.ids:
id = self.ids[id_name]
else:
id = self.next_id
self.next_id += 1
self.ids[id_name] = id
self.names[id] = id_name
return id
def lang(self):
while self.token[0:4]=="LANG" or self.token[0:7]=="SUBLANG" or self.token==',':
self.getToken();
def dialog(self, name):
dlg = DialogDef(name,self.addId(name))
assert len(dlg.controls)==0
self._dialogs[name] = dlg
extras = []
self.getToken()
while not self.token.isdigit():
self.debug("extra", self.token)
extras.append(self.token)
self.getToken()
dlg.x = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.y = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.w = int(self.token)
self.getCommaToken()
self.getToken() # number
dlg.h = int(self.token)
self.getToken()
while not (self.token==None or self.token=="" or self.token=="END"):
if self.token=="STYLE":
self.dialogStyle(dlg)
elif self.token=="EXSTYLE":
self.dialogExStyle(dlg)
elif self.token=="CAPTION":
self.dialogCaption(dlg)
elif self.token=="FONT":
self.dialogFont(dlg)
elif self.token=="BEGIN":
self.controls(dlg)
else:
break
self.dialogs[name] = dlg.createDialogTemplate()
def dialogStyle(self, dlg):
dlg.style, dlg.styles = self.styles( [], win32con.WS_VISIBLE | win32con.DS_SETFONT)
def dialogExStyle(self, dlg):
self.getToken()
dlg.styleEx, dlg.stylesEx = self.styles( [], 0)
def styles(self, defaults, defaultStyle):
list = defaults
style = defaultStyle
if "STYLE"==self.token:
self.getToken()
i = 0
Not = False
while ((i%2==1 and ("|"==self.token or "NOT"==self.token)) or (i%2==0)) and not self.token==None:
Not = False;
if "NOT"==self.token:
Not = True
self.getToken()
i += 1
if self.token!="|":
if self.token in win32con.__dict__:
value = getattr(win32con,self.token)
else:
if self.token in commctrl.__dict__:
value = getattr(commctrl,self.token)
else:
value = 0
if Not:
list.append("NOT "+self.token)
self.debug("styles add Not",self.token, value)
style &= ~value
else:
list.append(self.token)
self.debug("styles add", self.token, value)
style |= value
self.getToken()
self.debug("style is ",style)
return style, list
def dialogCaption(self, dlg):
if "CAPTION"==self.token:
self.getToken()
self.token = self.token[1:-1]
self.debug("Caption is:",self.token)
if self.gettexted:
dlg.caption = gt_str(self.token)
else:
dlg.caption = self.token
self.getToken()
def dialogFont(self | idNum = 0
style = defaultControlStyle | random_line_split |
ann_interface.py | ]
if i < d_col: #data(speak)の可視化
# 音声Dataがrmsの場合
# set_data:範囲は 0-1
set_data = data[j][i] #self.speakDecibelNorm(data[j][i])
#ON/OFF むちゃくちゃすぎる
#set_data = 1 if set_data > 0.3 else 0
#self.edited_speaks[j][i] = set_data
#一時的なOffset
#set_data = data_proc2.speakNorm(set_data, upper=0.75, lower=0.25)
#self.edited_speaks[j][i] = set_data
#color_dataの範囲を0-255に変更
#color_data=int(set_data*255)
color_data = set_data
color_data = 1 if color_data > 0.5 else 0
color_data=int(color_data*255)
#print color_data
#print "at",color_data
color = [255-color_data]*3
elif i >= d_col and i < t_col-add_flag: # annotationの可視化
#print i
"""
set_data = anno[j][i-d_col] #anno(1000, 2)
if set_data == 0:
color = [255, 255, 255]
else:
color = [0, 0, 0]
"""
set_data = anno[j][i-d_col] #anno(1000, 2)
set_data = 0 if set_data < 0 else set_data
set_data = 1 if set_data > 1 else set_data
color_data=int(set_data*255)
color = [255-color_data]*3
else: #flag
set_data = self.edited_flags[j][0]
if set_data == 0:
color = [255, 255, 255]
else:
color = [0, 0, 0]
self.table.setItem(i, j, QtGui.QTableWidgetItem())
self.table.item(i, j).setBackground(QtGui.QColor(color[0],color[1],color[2]))
self.table.item(i, j).setToolTip(str(set_data))
hor = False
self.table.setVisible(False)
self.table.resizeRowsToContents()
self.table.resizeColumnsToContents()
self.table.setVisible(True)
# TableがClickされたとき
def clickUpdateTable(self, cItem):
self.tip = float(cItem.toolTip())
self.r = cItem.row()
self.c = cItem.column()
print "r:",self.r,", c:",self.c, ". tip:",self.tip
set_data = 0 if self.tip == 1 else 1
speak_dim = self.edited_speaks.shape[1]
anno_dim = self.edited_annos.shape[1]
if self.r < speak_dim:
self.edited_speaks[self.c][self.r] = set_data
elif self.r >= speak_dim and self.r < speak_dim+anno_dim:
self.edited_annos[self.c][self.r-speak_dim] = set_data
else:
self.edited_flags[self.c][0] = set_data
#indexes = self.table.selectedIndexes()
#print indexes
color = [[255, 255, 255], [0, 0, 0]]
self.table.setItem(self.r, self.c, QtGui.QTableWidgetItem())
self.table.item(self.r, self.c).setBackground(QtGui.QColor(color[set_data][0],color[set_data][1],color[set_data][2]))
self.table.item(self.r, self.c).setToolTip(str(set_data))
#jointsの可視化
# self.vizJoint(self.c)
def checkRangeData(self):
set_row = int(self.checkUser.text()) #0~4 User1=2, User2=3
start = int(self.checkSt.text())
end = int(self.checkEd.text())
color = [[255, 255, 255], [0, 0, 0]]
table_offset = self.edited_speaks.shape[1]
#変更するUserの指定
user = set_row - table_offset
#print user, table_offset
if user < 0:
print "Not Change!"
return
print "Change [User:", user, ", Start:",start,", end:",end,"]"
for i in range(start, end):
get_data = self.edited_annos[i][user]
set_data = 0 if get_data == 1 else 1
self.table.setItem(set_row, i, QtGui.QTableWidgetItem())
self.table.item(set_row, i).setBackground(QtGui.QColor(color[set_data][0],color[set_data][1],color[set_data][2]))
self.table.item(set_row, i).setToolTip(str(set_data))
self.edited_annos[i][user] = set_data
def sliderChange(self, timeline):
if len(self.input_joints)==0:
print "now no data:", timeline
return
#self.table.selectColum(timeline)
#self.table.verticalScrollBar().setValue(timeline)
self.table.setCurrentCell(self.r, timeline)
self.pubViz(timeline)
"""
def activatedUpdateTable(self, cItem):
row = cItem.row()
col = cItem.column()
print "row:", row,", col:", col#, ". tip:",self.tip
"""
# 生Dataの入力
def inputData(self):
filesize = int(self.frmSizeBox.text())
print "Input raw data:", filesize
self.fname = [str(self.txtSepFile.text())]
input_data = data_proc2.load_persons(self.fname, annobool=False, datalen=filesize)
#print input_data["times"][0]
# もし手をくわえるなら
#input_data[2] = data_proc.proc_anno(input_data[0], input_data[2], use_vote=True, use_speak=False)
self.loadInputData(input_data)
# 加工済のDataの入力
def inputProcedData(self):
filesize = int(self.frmSizeBox.text())
print "Input proced data", filesize
self.fname = [str(self.txtSepFile.text())]
input_data = data_proc2.load_proced_data_flag(self.fname, datalen=filesize)
#print input_data["times"]
self.loadInputData(input_data)
def loadInputData(self, input_data):
self.input_joints = input_data["joints"]
self.input_speaks = input_data["speaks"]
datalen=self.input_speaks.shape[0]
if input_data.has_key("annos"):
self.input_annos = input_data["annos"]
#とりあえずuser1だけ編集（0124_personsはまた別）
#self.input_annos[:,:1] = np.zeros((self.input_annos.shape[0],1))
"""
user_joint = self.input_joints[:,:36]
user_anno = self.input_annos[:,:1]
calc_user_anno = data_proc2.proc_anno(user_joint, user_anno, use_vote=True, use_anno=False, threshold=-0.2)
self.input_annos[:,:1] = calc_user_anno
print "now_persons mode"
user_joint = self.input_joints[:,36:]
user_anno = self.input_annos[:,1:]
calc_user_anno = data_proc2.proc_anno(user_joint, user_anno, use_vote=True, use_anno=False, threshold=-0.2)
self.input_annos[:,1:] = calc_user_anno
"""
#print "now model mode"
self.input_annos[:,:] = np.round(self.input_annos[:,:])
else:
self.input_annos = np.zeros((datalen, self.anno_dim))#(1000,2)
if input_data.has_key("flags"):
print "load flags"
self.input_flags = input_data["flags"]
else:
print "create flags"
self.input_flags = np.zeros((datalen, 1))
if input_data.has_key("times"):
print "load times"
self.input_times = input_data["times"]
else:
print "create times"
self.input_times = np.zeros((datalen, 1))
"""
diff_times = []
for t in range(len(self.input_times)):
if t == 0:
diff_times.append(0)
else:
diff_times.append(self.input_times[t]-self.input_times[t-1])
fps = np.round(1/float(np.mean(diff_times)))
plt.plot(self.input_annos[:,0], label="person", color="red")
plt.plot(self.input_annos[:,1], label="robot", color="green")
plt.xlabel("Frame (fps:" | +str(fps)+")")
plt.title("speaker/listener result")
plt.xl | conditional_block |
|
ann_interface.py | .txtSepFile.setText('')
# reset
def resetAnno(self):
print "reset Data before:",self.edited_joints.shape, self.edited_annos.shape
self.edited_joints = copy.deepcopy(self.input_joints)
self.edited_speaks = copy.deepcopy(self.input_speaks)
#datalen = self.edited_speaks.shape[1]
self.edited_annos = copy.deepcopy(self.input_annos) #np.zeros((datalen, self.anno_dim)) #(1000, 2)
self.edited_flags = copy.deepcopy(self.input_flags)
self.sld.setMaximum(self.edited_speaks.shape[0]-1) #
self.updateTable(self.edited_speaks, self.edited_annos, self.edited_times)
print "reset Data after:",self.edited_joints.shape, self.edited_speaks.shape, self.edited_annos.shape
def speakNorm(self, data, upper=300, lower=80):
# 上限
c_data=data if data <upper else upper
# 下限
c_data=c_data if c_data>lower else lower
# 最大値で割る
return (c_data-lower)/float(upper-lower)
def convDecibel(self, data):
return 20*math.log10(data)
#decibel
def speakDecibelNorm(self, data):
decibel = self.convDecibel(data)
return self.speakNorm(decibel, upper=70, lower=30)
def updateTable(self, data, anno, times):
#plt.plot(data)
#plt.show()
th = 0#float(self.ThesholdBox.text())
if(len(data)==0):
print "No Data! Push exec button..."
d_row, d_col = data.shape #(1000, 2)
add_ann = anno.shape[1] #annotationの個数
#print add_ann
add_flag = 1
#t_row:時間軸, t_col:次元数, add_ann:加えるAnnotation
t_col = d_col+add_ann+add_flag
t_row = d_row
#print "t, d, a",t_col,d_col,add_ann
self.table.clear()
font = QtGui.QFont()
font.setFamily(u"DejaVu Sans")
font.setPointSize(5)
self.table.horizontalHeader().setFont(font)
self.table.verticalHeader().setFont(font)
self.table.setColumnCount(t_row) # 次元数(tableはcolだけど値はrow!)+flag
self.table.setRowCount(t_col) # 時間軸(tableはrowだけど値はcol!)
# print "t:", t_row, t_col
#self.table.setRowCount(data.shape[0])
#self.table.setColumnCount(ann_num)
# 軸の値をSet
#for i in range(len(times)):
# jItem = QtGui.QTableWidgetItem(str(i))
# self.table.setHorizontalHeaderItem(i, jItem)
hor = True
for i in range(t_col):
iItem = QtGui.QTableWidgetItem(str(i))
self.table.setVerticalHeaderItem(i, iItem)
self.table.verticalHeaderItem(i).setToolTip(str(i))
#時間軸にデータを入れるなら↓
#self.table.verticalHeaderItem(i).setToolTip(str(times[i]))
for j in range(t_row):
if hor == True:
jItem = QtGui.QTableWidgetItem(str(j))
self.table.setHorizontalHeaderItem(j, jItem)
self.table.horizontalHeaderItem(j).setToolTip(str(times[j]))
#print "%.10f"%times[j]
if i < d_col: #data(speak)の可視化
# 音声Dataがrmsの場合
# set_data:範囲は 0-1
set_data = data[j][i] #self.speakDecibelNorm(data[j][i])
#ON/OFF むちゃくちゃすぎる
#set_data = 1 if set_data > 0.3 else 0
#self.edited_speaks[j][i] = set_data
#一時的なOffset
#set_data = data_proc2.speakNorm(set_data, upper=0.75, lower=0.25)
#self.edited_speaks[j][i] = set_data
#color_dataの範囲を0-255に変更
#color_data=int(set_data*255)
color_data = set_data
color_data = 1 if color_data > 0.5 else 0
color_data=int(color_data*255)
#print color_data
#print "at",color_data
color = [255-color_data]*3
elif i >= d_col and i < t_col-add_flag: # annotationの可視化
#print i
"""
set_data = anno[j][i-d_col] #anno(1000, 2)
if set_data == 0:
color = [255, 255, 255]
else:
color = [0, 0, 0]
"""
set_data = anno[j][i-d_col] #anno(1000, 2)
set_data = 0 if set_data < 0 else set_data
set_data = 1 if set_data > 1 else set_data
color_data=int(set_data*255)
color = [255-color_data]*3
else: #flag
set_data = self.edited_flags[j][0]
if set_data == 0:
color = [255, 255, 255]
else:
color = [0, 0, 0]
self.table.setItem(i, j, QtGui.QTableWidgetItem())
self.table.item(i, j).setBackground(QtGui.QColor(color[0],color[1],color[2]))
self.table.item(i, j).setToolTip(str(set_data))
hor = False
self.table.setVisible(False)
self.table.resizeRowsToContents()
self.table.resizeColumnsToContents()
self.table.setVisible(True)
# TableがClickされたとき
def clickUpdateTable(self, cItem):
self.tip = float(cItem.toolTip())
self.r = cItem.row()
self.c = cItem.column()
print "r:",self.r,", c:",self.c, ". tip:",self.tip
set_data = 0 if self.tip == 1 else 1
speak_dim = self.edited_speaks.shape[1]
anno_dim = self.edited_annos.shape[1]
if self.r < speak_dim:
self.edited_speaks[self.c][self.r] = set_data
elif self.r >= speak_dim and self.r < speak_dim+anno_dim:
self.edited_annos[self.c][self.r-speak_dim] = set_data
else:
self.edited_flags[self.c][0] = set_data
#indexes = self.table.selectedIndexes()
#print indexes
color = [[255, 255, 255], [0, 0, 0]]
self.table.setItem(self.r, self.c, QtGui.QTableWidgetItem())
self.table.item(self.r, self.c).setBackground(QtGui.QColor(color[set_data][0],color[set_data][1],color[set_data][2]))
self.table.item(self.r, self.c).setToolTip(str(set_data))
#jointsの可視化
# self.vizJoint(self.c)
def checkRangeData(self):
set_row = int(self.checkUser.text()) #0~4 User1=2, User2=3
start = int(self.checkSt.text())
end = int(self.checkEd.text())
color = [[255, 255, 255], [0, 0, 0]]
table_offset = self.edited_speaks.shape[1]
#変更するUserの指定
user = set_row - table_offset
#print user, table_offset
if user < 0:
print "Not Change!"
return
print "Change [User:", user, ", Start:",start,", end:",end,"]"
for i in range(start, end):
get_data = self.edited_annos[i][user]
set_data = 0 if get_data == 1 else 1
self.table.setItem(set_row, i, QtGui.QTableWidgetItem())
self.table.item(set_row, i).setBackground(QtGui.QColor(color[set_data][0],color[set_data][1],color[set_data][2]))
self.table.item(set_row, i).setToolTip(str(set_data))
self.edited_annos[i][user] = set_data
def sliderChange(self, timeline):
if len(self.input_joints)==0:
print "now no data:", timeline
return
#self.table.selectColum(timeline)
#self.table.verticalScrollBar().setValue(timeline)
self.table.setCurrentCell(self.r, timeline)
self.pubViz(timeline)
""" | random_line_split |
||
ann_interface.py | .2)
plt.legend()
plt.show()
"""
print "joints shape:", self.input_joints.shape
print "speaks shape:", self.input_speaks.shape
print "annos shape:", self.input_annos.shape
print "flags shape:", self.input_flags.shape
print "times shape:", self.input_times.shape
#for j in range(len(self.input_times)):
# print j,"%.10f"%self.input_times[j]
self.timediff(self.input_times)
self.edited_joints = copy.deepcopy(self.input_joints)#np.arrayでCopyされる
self.edited_speaks = copy.deepcopy(self.input_speaks)#speakは編集しない(今のところ)
self.edited_annos = copy.deepcopy(self.input_annos)
self.edited_flags = copy.deepcopy(self.input_flags)
self.edited_times = copy.deepcopy(self.input_times)
#self.updateTable(self.input_joints)
self.updateTable(self.edited_speaks, self.edited_annos, self.edited_times)
#Sliderの最大値をset
self.sld.setMaximum(datalen - 1)
print "end"
def outputData(self):
name_json = str(self.txtOutputFile.text())
keys = ["joints", "speaks", "annos", "flags", "times"]
data = [self.edited_joints, self.edited_speaks, self.edited_annos, self.edited_flags, self.edited_times]
"""
if len(keys) != len(data):
print "Save false! keys len:"
"""
data_proc2.save_data(name_json, keys, data)
def timediff(self, times):
fpss = []
for i in range(len(times)-1):
fps = 1/(times[i+1]-times[i])
fpss.append(fps)
#print i, fps
fpss = np.array(fpss)
#print "mean:",np.mean(fpss),",std:",np.std(fpss)
def cutRangeData(self):
start = int(self.cutStart.text())
end = int(self.cutEnd.text())
print "cut data:",start,"-",end
self.edited_joints = self.edited_joints[start:end]
self.edited_speaks = self.edited_speaks[start:end]
self.edited_annos = self.edited_annos[start:end]
self.edited_flags = self.edited_flags[start:end]
self.edited_times = self.edited_times[start:end]
print "joints shape:", self.edited_joints.shape
print "speaks shape:", self.edited_speaks.shape
print "annos shape:", self.edited_annos.shape
print "flags shape:", self.edited_flags.shape
print "times shape:", self.edited_times.shape
self.updateTable(self.edited_speaks, self.edited_annos, self.edited_times)
#Sliderの最大値をset
self.sld.setMaximum(self.edited_joints.shape[0]-1)
print "end"
def directJoints(self):
print "direct joints"
size, dim = self.edited_joints.shape
user1_nose_y_idx = 35+33+2
pair = 1
pair_stack = 0
offset_y = 0.03
for i in range(size):
anno = self.edited_annos[i]
if anno[1] == 0:#聞き手なら
if anno[0] == 1 and anno[2] == 0:
#print i,":user0",self.input_joints[i][user1_nose_y_idx]
self.edited_joints[i][user1_nose_y_idx] += offset_y
pair = 0
pair_stack = 0
#print self.input_joints[i][user1_nose_y_idx]
elif anno[0] == 0 and anno[2] == 1:
#print i,":user2",self.input_joints[i][user1_nose_y_idx]
self.edited_joints[i][user1_nose_y_idx] -= offset_y
pair = 2
pair_stack = 0
#print self.input_joints[i][user1_nose_y_idx]
else: #誰も話していないなら
pair_stack += 1
else:#話し手ならどこを向くか
if pair == 0:
self.edited_joints[i][user1_nose_y_idx] += offset_y
elif pair == 2:
self.edited_joints[i][user1_nose_y_idx] -= offset_y
# 引っ繰り返して追加
def reverseData(self):
#y方向だけ引っくり返す
def reverse_y(joints):
#(10000, 36)
rev = np.array([[1,-1,1]*12]*joints.shape[0])
return joints*rev
print "reverseData before:",self.edited_joints.shape, self.edited_annos.shape
datalen = self.edited_annos.shape[0]
if self.anno_dim == 2:
j_r = np.hstack((self.edited_joints[:,36:], self.edited_joints[:,:36]))
self.edited_joints = np.vstack((self.edited_joints, j_r))
s_r = np.hstack((self.edited_speaks[:,1].reshape(datalen,1), self.edited_speaks[:,0].reshape(datalen,1)))
self.edited_speaks = np.vstack((self.edited_speaks, s_r))
a_r = np.hstack((self.edited_annos[:,1].reshape(datalen,1), self.edited_annos[:,0].reshape(datalen,1)))
self.edited_annos = np.vstack((self.edited_annos, a_r))
self.edited_flags = np.vstack((self.edited_flags, self.edited_flags))
self.edited_times = np.append(self.edited_times, self.edited_times)
else:
print "bad shape"
#print self.edited_times.shape
self.updateTable(self.edited_speaks, self.edited_annos, self.edited_times)
#Sliderの最大値をset
self.sld.setMaximum(self.edited_joints.shape[0]-1)
print "reverseData after:",self.edited_joints.shape,self.edited_speaks.shape,self.edited_annos.shape
def rviz_obj(self, obj_id, obj_ns, obj_type, obj_size, obj_color=[0, 0, 0, 0], obj_life=0):
obj = Marker()
obj.header.frame_id, obj.header.stamp = "camera_link", rospy.Time.now()
obj.ns, obj.action, obj.type = str(obj_ns), 0, obj_type
obj.scale.x, obj.scale.y, obj.scale.z = obj_size[0], obj_size[1], obj_size[2]
obj.color = obj_color
obj.lifetime = rospy.Duration.from_sec(obj_life)
obj.pose.orientation.w = 1.0
return obj
def set_point(self, pos, addx=0, addy=0, addz=0, rotate=False):
pt = Point()
if rotate == True:
pt.x, pt.y, pt.z = -1*pos[0]+addx, -1*pos[1]+addy, pos[2]+addz
else:
pt.x, pt.y, pt.z = pos[0]+addx, pos[1]+addy, pos[2]+addz
return pt
def set_vizmsg_point(self, u, data, color, psize, ofs, addx=0, addy=0, rotate=False):
pmsg = self.rviz_obj(u, 'p'+str(u), 7, [psize, psize, psize], color, 0)
points = []
for p in range(data.shape[1]/ofs):
points.append(self.set_point([data[0, p*ofs],
data[0, p*ofs+1],
data[0, p*ofs+2]],
addx=addx, addy=addy, rotate=rotate))
pmsg.points = points
return pmsg
def set_vizmsg_line(self, u, data, color, lsize, llist, addx=0, addy=0, rotate=False):
lmsg = self.rviz_obj(u, 'l'+str(u), 5, [lsize, lsize, lsize], color, 0)
for ls in llist:
for l in range(len(ls)-1):
for add in r | ange(2):
#print person[0, ls[l+add]], ls[l+add], l, add
linepoint=self.set_point([data[0,ls[l+add]*3],
data[0,ls[l+add]*3+1],
data[0,ls[l+add]*3+2]],
addx=addx, addy=addy, rotate=rotate)
lmsg.points.append(linepoint)
return lmsg
| identifier_body |
|
ann_interface.py | else:
print "create flags"
self.input_flags = np.zeros((datalen, 1))
if input_data.has_key("times"):
print "load times"
self.input_times = input_data["times"]
else:
print "create times"
self.input_times = np.zeros((datalen, 1))
"""
diff_times = []
for t in range(len(self.input_times)):
if t == 0:
diff_times.append(0)
else:
diff_times.append(self.input_times[t]-self.input_times[t-1])
fps = np.round(1/float(np.mean(diff_times)))
plt.plot(self.input_annos[:,0], label="person", color="red")
plt.plot(self.input_annos[:,1], label="robot", color="green")
plt.xlabel("Frame (fps:"+str(fps)+")")
plt.title("speaker/listener result")
plt.xlim(0,len(self.input_annos))
plt.ylim(-0.2, 1.2)
plt.legend()
plt.show()
"""
print "joints shape:", self.input_joints.shape
print "speaks shape:", self.input_speaks.shape
print "annos shape:", self.input_annos.shape
print "flags shape:", self.input_flags.shape
print "times shape:", self.input_times.shape
#for j in range(len(self.input_times)):
# print j,"%.10f"%self.input_times[j]
self.timediff(self.input_times)
self.edited_joints = copy.deepcopy(self.input_joints)#np.arrayでCopyされる
self.edited_speaks = copy.deepcopy(self.input_speaks)#speakは編集しない(今のところ)
self.edited_annos = copy.deepcopy(self.input_annos)
self.edited_flags = copy.deepcopy(self.input_flags)
self.edited_times = copy.deepcopy(self.input_times)
#self.updateTable(self.input_joints)
self.updateTable(self.edited_speaks, self.edited_annos, self.edited_times)
#Sliderの最大値をset
self.sld.setMaximum(datalen - 1)
print "end"
def outputData(self):
name_json = str(self.txtOutputFile.text())
keys = ["joints", "speaks", "annos", "flags", "times"]
data = [self.edited_joints, self.edited_speaks, self.edited_annos, self.edited_flags, self.edited_times]
"""
if len(keys) != len(data):
print "Save false! keys len:"
"""
data_proc2.save_data(name_json, keys, data)
def timediff(self, times):
fpss = []
for i in range(len(times)-1):
fps = 1/(times[i+1]-times[i])
fpss.append(fps)
#print i, fps
fpss = np.array(fpss)
#print "mean:",np.mean(fpss),",std:",np.std(fpss)
def cutRangeData(self):
start = int(self.cutStart.text())
end = int(self.cutEnd.text())
print "cut data:",start,"-",end
self.edited_joints = self.edited_joints[start:end]
self.edited_speaks = self.edited_speaks[start:end]
self.edited_annos = self.edited_annos[start:end]
self.edited_flags = self.edited_flags[start:end]
self.edited_times = self.edited_times[start:end]
print "joints shape:", self.edited_joints.shape
print "speaks shape:", self.edited_speaks.shape
print "annos shape:", self.edited_annos.shape
print "flags shape:", self.edited_flags.shape
print "times shape:", self.edited_times.shape
self.updateTable(self.edited_speaks, self.edited_annos, self.edited_times)
#Sliderの最大値をset
self.sld.setMaximum(self.edited_joints.shape[0]-1)
print "end"
def directJoints(self):
print "direct joints"
size, dim = self.edited_joints.shape
user1_nose_y_idx = 35+33+2
pair = 1
pair_stack = 0
offset_y = 0.03
for i in range(size):
anno = self.edited_annos[i]
if anno[1] == 0:#聞き手なら
if anno[0] == 1 and anno[2] == 0:
#print i,":user0",self.input_joints[i][user1_nose_y_idx]
self.edited_joints[i][user1_nose_y_idx] += offset_y
pair = 0
pair_stack = 0
#print self.input_joints[i][user1_nose_y_idx]
elif anno[0] == 0 and anno[2] == 1:
#print i,":user2",self.input_joints[i][user1_nose_y_idx]
self.edited_joints[i][user1_nose_y_idx] -= offset_y
pair = 2
pair_stack = 0
#print self.input_joints[i][user1_nose_y_idx]
else: #誰も話していないなら
pair_stack += 1
else:#話し手ならどこを向くか
if pair == 0:
self.edited_joints[i][user1_nose_y_idx] += offset_y
elif pair == 2:
self.edited_joints[i][user1_nose_y_idx] -= offset_y
# 引っ繰り返して追加
def reverseData(self):
#y方向だけ引っくり返す
def reverse_y(joints):
#(10000, 36)
rev = np.array([[1,-1,1]*12]*joints.shape[0])
return joints*rev
print "reverseData before:",self.edited_joints.shape, self.edited_annos.shape
datalen = self.edited_annos.shape[0]
if self.anno_dim == 2:
j_r = np.hstack((self.edited_joints[:,36:], self.edited_joints[:,:36]))
self.edited_joints = np.vstack((self.edited_joints, j_r))
s_r = np.hstack((self.edited_speaks[:,1].reshape(datalen,1), self.edited_speaks[:,0].reshape(datalen,1)))
self.edited_speaks = np.vstack((self.edited_speaks, s_r))
a_r = np.hstack((self.edited_annos[:,1].reshape(datalen,1), self.edited_annos[:,0].reshape(datalen,1)))
self.edited_annos = np.vstack((self.edited_annos, a_r))
self.edited_flags = np.vstack((self.edited_flags, self.edited_flags))
self.edited_times = np.append(self.edited_times, self.edited_times)
else:
print "bad shape"
#print self.edited_times.shape
self.updateTable(self.edited_speaks, self.edited_annos, self.edited_times)
#Sliderの最大値をset
self.sld.setMaximum(self.edited_joints.shape[0]-1)
print "reverseData after:",self.edited_joints.shape,self.edited_speaks.shape,self.edited_annos.shape
def rviz_obj(self, obj_id, obj_ns, obj_type, obj_size, obj_color=[0, 0, 0, 0], obj_life=0):
obj = Marker()
obj.header.frame_id, obj.header.stamp = "camera_link", rospy.Time.now()
obj.ns, obj.action, obj.type = str(obj_ns), 0, obj_type
obj.scale.x, obj.scale.y, obj.scale.z = obj_size[0], obj_size[1], obj_size[2]
obj.color = obj_color
obj.lifetime = rospy.Duration.from_sec(obj_life)
obj.pose.orientation.w = 1.0
return obj
def set_point(self, pos, addx=0, addy=0, addz=0, rotate=False):
pt = Point()
if rotate == True:
pt.x, pt.y, pt.z = -1*pos[0]+addx, -1*pos[1]+addy, pos[2]+addz
else:
pt.x, pt.y, pt.z = pos[0]+addx, pos[1]+addy, pos[2]+addz
return pt
def set_vizmsg_point(self, u, data, color, psize, ofs, addx=0, addy=0, rotate=False):
pmsg = self.rviz_obj(u, 'p'+str(u), 7, [psize, psize, psize], color, 0)
points = []
for p in range(data.shape[1]/ofs):
points.append(self.set_point([data[0, p*ofs],
data[0, p*ofs+1],
data[0, p*ofs+2]], | identifier_name |
||
index.js | = [];
function next(index) {
if (index < array.length) | else {
resolve(results);
}
}
next(0);
});
}
function findPromise(array, callback, thisArg) {
return new Promise((resolve, reject) => {
function next(index) {
if (index < array.length) {
callback.call(thisArg, array[index], index, array).then(result => {
if (result) {
resolve(array[index]);
} else {
next(index + 1);
}
}).catch(error => {
reject(error);
});
} else {
resolve();
}
}
next(0);
});
}
async function readDirRecursively(dir, options) {
const rootDir = _.get(options, 'rootDir', dir);
const files = await fse.readdir(dir);
const result = await mapPromise(files, async (file) => {
const filePath = path.join(dir, file);
const relFilePath = path.relative(rootDir, filePath);
const stats = await fse.stat(filePath);
if (_.has(options, 'filter') && !options.filter(relFilePath, stats)) {
return Promise.resolve();
}
if (stats.isDirectory()) {
return readDirRecursively(filePath, {...options, rootDir});
} else if (stats.isFile()) {
return relFilePath;
} else {
return null;
}
});
return _.chain(result).compact().flatten().value();
}
/**
* Gets the value at the first path of object having non undefined value.
* If all paths resolve to undefined values, the defaultValue is returned.
*
* @param {Object} object The object to query.
* @param {Array<String | Array<String>>} paths The property paths to search for.
* @param {*} [defaultValue] The value returned if all paths resolve to undefined values
* @returns {*}
*/
function getFirst(object, paths, defaultValue) {
let result = _(object).at(paths).reject(_.isUndefined).first();
return _.isUndefined(result) ? defaultValue : result;
}
function append(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.get(object, path).push(value);
}
function concat(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.set(object, path, _.get(object, path).concat(value));
}
function copy(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (_.has(sourceObject, sourcePath)) {
let value = _.get(sourceObject, sourcePath);
if (transform) {
value = transform(value);
}
_.set(targetObject, targetPath, value);
}
}
function copyIfNotSet(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (!_.has(targetObject, targetPath)) {
copy(sourceObject, sourcePath, targetObject, targetPath, transform);
}
}
function rename(object, oldPath, newPath) {
if (_.has(object, oldPath)) {
_.set(object, newPath, _.get(object, oldPath));
oldPath = _.toPath(oldPath);
if (oldPath.length > 1) {
object = _.get(object, _.initial(oldPath));
}
delete object[_.last(oldPath)];
}
}
function failFunctionWithTag(tag) {
return function fail(message) {
throw new Error(`[${tag}] ${message}`);
};
}
function assertFunctionWithFail(fail) {
return function assert(value, message) {
if (!value) {
fail(message);
}
}
}
/**
* Deeply maps the passed `value` by recursively calling the `iteratee` on
* value's children. The value returned from the iteratee is used to map the
* children.
*
* The iteratee is invoked with three arguments - the `value` being iterated,
* the `fieldPath` of the current `value` relative to the original passed value,
* and the `stack` of ancestors of the current `value`.
*
* For the first time the `iterate` will be called with the original `value`
* and empty arrays for `fieldPath` and `stack`.
*
* In other words, any `value` passed to the iteratee (except the first call,
* and assuming the ancestors keys were not mapped)
* will be equal to: `_.get(originalValue, fieldPath)`
*
* The recursion is called in pre-order depth-first-search. Meaning, the
* iteratee is called first on parent nodes and then on its children. Therefore
* if iteratee maps/replaces the parent node, then the children of the replaced
* node will be traversed.
*
* @example
* mapDeep({ prop: 'foo', arr: [ 'bar' , 1, 2 ] }, (value) => {
* if (_.isString(value)) return '__' + value;
* if (_.isNumber(value)) return value * 10;
* return value;
* })
* => { prop: '__foo', arr: [ '__bar', 10, 20 ] }
*
* mapDeep({ prop: 'foo', arr: [ 'bar' ] }, (value, fieldPath) => {
* if ((_.isString(value)) return value + '__' + fieldPath.join('.');
* return value;
* })
* => { prop: 'foo__prop', arr: [ 'bar__arr.0' ] }
*
* @param {*} value A value to map
* @param {Function} iteratee Function (value: any, fieldPath: Array, stack: Array)
* @param {object} [options]
* @param {boolean} [options.iterateCollections] Default: true
* @param {boolean} [options.iterateScalars] Default: true
* @param {boolean} [options.postOrder] Change the invocation of iteratee to post-order depth-first-search. Default: false
* @param {Array} [_keyPath] For internal recursive use
* @param {Array} [_objectStack] For internal recursive use
* @returns {*}
*/
function mapDeep(value, iteratee, options = {}, _keyPath = [], _objectStack = []) {
const postOrder = _.get(options, 'postOrder', false);
let iterate;
if (_.isPlainObject(value) || _.isArray(value)) {
iterate = _.get(options, 'iterateCollections', true);
} else {
iterate = _.get(options, 'iterateScalars', true);
}
if (iterate && !postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
const childrenIterator = (val, key) => {
return mapDeep(val, iteratee, options, _.concat(_keyPath, key), _.concat(_objectStack, [value]));
};
if (_.isPlainObject(value)) {
value = _.mapValues(value, childrenIterator);
} else if (_.isArray(value)) {
value = _.map(value, childrenIterator);
}
if (iterate && postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
return value;
}
function fieldPathToString(fieldPath) {
return _.reduce(fieldPath, (accumulator, fieldName, index) => {
if (_.isString(fieldName) && /\W/.test(fieldName)) {
// field name is a string with non alphanumeric character
accumulator += `['${fieldName}']`;
} else if (_.isNumber(fieldName)) {
accumulator += `[${fieldName}]`;
} else {
if (index > 0) {
accumulator += '.';
}
accumulator += fieldName;
}
return accumulator;
}, '');
}
function getFirstExistingFile(fileNames, inputDir) {
const filePaths = _.map(fileNames, fileName => path.resolve(inputDir, fileName));
return findPromise(filePaths, (filePath) => fse.pathExists(filePath));
}
function parseFirstExistingFile(fileNames, inputDir) {
return getFirstExistingFile(fileNames, inputDir).then(filePath => {
if (filePath) {
return parseFile(filePath);
} else {
return null;
}
});
}
async function parseFile(filePath) {
const data = await fse.readFile(filePath, 'utf8');
return parseDataByFilePath(data, filePath);
}
function parseDataByFilePath(string, filePath) {
const extension = path.extname(filePath).substring(1);
let data;
switch (extension) {
case 'yml':
case 'yaml':
data = yaml.safeLoad(string, {schema: yaml.JSON_SCHEMA});
break;
case 'json':
data = JSON.parse(string);
break;
case 'toml':
data = toml.parse(string);
break;
case 'md':
data = parseMarkdownWithFrontMatter(string);
break;
default:
throw new Error(`parseDataByFilePath error, extension '${extension}' of file ${filePath} is not supported`);
}
return data;
}
function parseMarkdownWithFrontMatter(string) {
string = string.replace('\r\n', '\n');
let frontmatter = null;
let markdown = string;
let frontMatterTypes = [
{
type: 'yaml',
startDelimiter: '---\n | {
callback.call(thisArg, array[index], index, array).then(result => {
results[index] = result;
next(index + 1);
}).catch(error => {
reject(error);
});
} | conditional_block |
index.js | {Array<String | Array<String>>} paths The property paths to search for.
* @param {*} [defaultValue] The value returned if all paths resolve to undefined values
* @returns {*}
*/
function getFirst(object, paths, defaultValue) {
let result = _(object).at(paths).reject(_.isUndefined).first();
return _.isUndefined(result) ? defaultValue : result;
}
function append(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.get(object, path).push(value);
}
function concat(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.set(object, path, _.get(object, path).concat(value));
}
function copy(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (_.has(sourceObject, sourcePath)) {
let value = _.get(sourceObject, sourcePath);
if (transform) {
value = transform(value);
}
_.set(targetObject, targetPath, value);
}
}
function copyIfNotSet(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (!_.has(targetObject, targetPath)) {
copy(sourceObject, sourcePath, targetObject, targetPath, transform);
}
}
function rename(object, oldPath, newPath) {
if (_.has(object, oldPath)) {
_.set(object, newPath, _.get(object, oldPath));
oldPath = _.toPath(oldPath);
if (oldPath.length > 1) {
object = _.get(object, _.initial(oldPath));
}
delete object[_.last(oldPath)];
}
}
function failFunctionWithTag(tag) {
return function fail(message) {
throw new Error(`[${tag}] ${message}`);
};
}
function assertFunctionWithFail(fail) {
return function assert(value, message) {
if (!value) {
fail(message);
}
}
}
/**
* Deeply maps the passed `value` by recursively calling the `iteratee` on
* value's children. The value returned from the iteratee is used to map the
* children.
*
* The iteratee is invoked with three arguments - the `value` being iterated,
* the `fieldPath` of the current `value` relative to the original passed value,
* and the `stack` of ancestors of the current `value`.
*
* For the first time the `iterate` will be called with the original `value`
* and empty arrays for `fieldPath` and `stack`.
*
* In other words, any `value` passed to the iteratee (except the first call,
* and assuming the ancestors keys were not mapped)
* will be equal to: `_.get(originalValue, fieldPath)`
*
* The recursion is called in pre-order depth-first-search. Meaning, the
* iteratee is called first on parent nodes and then on its children. Therefore
* if iteratee maps/replaces the parent node, then the children of the replaced
* node will be traversed.
*
* @example
* mapDeep({ prop: 'foo', arr: [ 'bar' , 1, 2 ] }, (value) => {
* if (_.isString(value)) return '__' + value;
* if (_.isNumber(value)) return value * 10;
* return value;
* })
* => { prop: '__foo', arr: [ '__bar', 10, 20 ] }
*
* mapDeep({ prop: 'foo', arr: [ 'bar' ] }, (value, fieldPath) => {
* if ((_.isString(value)) return value + '__' + fieldPath.join('.');
* return value;
* })
* => { prop: 'foo__prop', arr: [ 'bar__arr.0' ] }
*
* @param {*} value A value to map
* @param {Function} iteratee Function (value: any, fieldPath: Array, stack: Array)
* @param {object} [options]
* @param {boolean} [options.iterateCollections] Default: true
* @param {boolean} [options.iterateScalars] Default: true
* @param {boolean} [options.postOrder] Change the invocation of iteratee to post-order depth-first-search. Default: false
* @param {Array} [_keyPath] For internal recursive use
* @param {Array} [_objectStack] For internal recursive use
* @returns {*}
*/
function mapDeep(value, iteratee, options = {}, _keyPath = [], _objectStack = []) {
const postOrder = _.get(options, 'postOrder', false);
let iterate;
if (_.isPlainObject(value) || _.isArray(value)) {
iterate = _.get(options, 'iterateCollections', true);
} else {
iterate = _.get(options, 'iterateScalars', true);
}
if (iterate && !postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
const childrenIterator = (val, key) => {
return mapDeep(val, iteratee, options, _.concat(_keyPath, key), _.concat(_objectStack, [value]));
};
if (_.isPlainObject(value)) {
value = _.mapValues(value, childrenIterator);
} else if (_.isArray(value)) {
value = _.map(value, childrenIterator);
}
if (iterate && postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
return value;
}
function fieldPathToString(fieldPath) {
return _.reduce(fieldPath, (accumulator, fieldName, index) => {
if (_.isString(fieldName) && /\W/.test(fieldName)) {
// field name is a string with non alphanumeric character
accumulator += `['${fieldName}']`;
} else if (_.isNumber(fieldName)) {
accumulator += `[${fieldName}]`;
} else {
if (index > 0) {
accumulator += '.';
}
accumulator += fieldName;
}
return accumulator;
}, '');
}
function getFirstExistingFile(fileNames, inputDir) {
const filePaths = _.map(fileNames, fileName => path.resolve(inputDir, fileName));
return findPromise(filePaths, (filePath) => fse.pathExists(filePath));
}
function parseFirstExistingFile(fileNames, inputDir) {
return getFirstExistingFile(fileNames, inputDir).then(filePath => {
if (filePath) {
return parseFile(filePath);
} else {
return null;
}
});
}
async function parseFile(filePath) {
const data = await fse.readFile(filePath, 'utf8');
return parseDataByFilePath(data, filePath);
}
function parseDataByFilePath(string, filePath) {
const extension = path.extname(filePath).substring(1);
let data;
switch (extension) {
case 'yml':
case 'yaml':
data = yaml.safeLoad(string, {schema: yaml.JSON_SCHEMA});
break;
case 'json':
data = JSON.parse(string);
break;
case 'toml':
data = toml.parse(string);
break;
case 'md':
data = parseMarkdownWithFrontMatter(string);
break;
default:
throw new Error(`parseDataByFilePath error, extension '${extension}' of file ${filePath} is not supported`);
}
return data;
}
function parseMarkdownWithFrontMatter(string) {
string = string.replace('\r\n', '\n');
let frontmatter = null;
let markdown = string;
let frontMatterTypes = [
{
type: 'yaml',
startDelimiter: '---\n',
endDelimiter: '\n---',
parse: (string) => yaml.safeLoad(string, {schema: yaml.JSON_SCHEMA})
},
{
type: 'toml',
startDelimiter: '+++\n',
endDelimiter: '\n+++',
parse: (string) => toml.parse(string)
},
{
type: 'json',
startDelimiter: '{\n',
endDelimiter: '\n}',
parse: (string) => JSON.parse(string)
}
];
_.forEach(frontMatterTypes, fmType => {
if (string.startsWith(fmType.startDelimiter)) {
let index = string.indexOf(fmType.endDelimiter);
if (index !== -1) {
// The end delimiter must be followed by EOF or by a new line (possibly preceded with spaces)
// For example ("." used for spaces):
// |---
// |title: Title
// |---...
// |
// |Markdown Content
// |
// "index" points to the beginning of the second "---"
// "endDelimEndIndex" points to the end of the second "---"
// "afterEndDelim" is everything after the second "---"
// "afterEndDelimMatch" is the matched "...\n" after the second "---"
// frontmatter will be: {title: "Title"}
// markdown will be "\nMarkdown Content\n" (the first \n after end delimiter is discarded)
const endDelimEndIndex = index + fmType.endDelimiter.length;
const afterEndDelim = string.substring(endDelimEndIndex);
const afterEndDelimMatch = afterEndDelim.match(/^\s*?(\n|$)/);
if (afterEndDelimMatch) {
const data = string.substring(fmType.startDelimiter.length, index);
frontmatter = fmType.parse(data); | random_line_split |
||
index.js | , thisArg) {
return new Promise((resolve, reject) => {
function next(index) {
if (index < array.length) {
callback.call(thisArg, array[index], index, array).then(result => {
if (result) {
resolve(array[index]);
} else {
next(index + 1);
}
}).catch(error => {
reject(error);
});
} else {
resolve();
}
}
next(0);
});
}
async function readDirRecursively(dir, options) {
const rootDir = _.get(options, 'rootDir', dir);
const files = await fse.readdir(dir);
const result = await mapPromise(files, async (file) => {
const filePath = path.join(dir, file);
const relFilePath = path.relative(rootDir, filePath);
const stats = await fse.stat(filePath);
if (_.has(options, 'filter') && !options.filter(relFilePath, stats)) {
return Promise.resolve();
}
if (stats.isDirectory()) {
return readDirRecursively(filePath, {...options, rootDir});
} else if (stats.isFile()) {
return relFilePath;
} else {
return null;
}
});
return _.chain(result).compact().flatten().value();
}
/**
* Gets the value at the first path of object having non undefined value.
* If all paths resolve to undefined values, the defaultValue is returned.
*
* @param {Object} object The object to query.
* @param {Array<String | Array<String>>} paths The property paths to search for.
* @param {*} [defaultValue] The value returned if all paths resolve to undefined values
* @returns {*}
*/
function getFirst(object, paths, defaultValue) {
let result = _(object).at(paths).reject(_.isUndefined).first();
return _.isUndefined(result) ? defaultValue : result;
}
function append(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.get(object, path).push(value);
}
function concat(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.set(object, path, _.get(object, path).concat(value));
}
function copy(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (_.has(sourceObject, sourcePath)) {
let value = _.get(sourceObject, sourcePath);
if (transform) {
value = transform(value);
}
_.set(targetObject, targetPath, value);
}
}
function copyIfNotSet(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (!_.has(targetObject, targetPath)) {
copy(sourceObject, sourcePath, targetObject, targetPath, transform);
}
}
function rename(object, oldPath, newPath) {
if (_.has(object, oldPath)) {
_.set(object, newPath, _.get(object, oldPath));
oldPath = _.toPath(oldPath);
if (oldPath.length > 1) {
object = _.get(object, _.initial(oldPath));
}
delete object[_.last(oldPath)];
}
}
function failFunctionWithTag(tag) {
return function fail(message) {
throw new Error(`[${tag}] ${message}`);
};
}
function assertFunctionWithFail(fail) {
return function assert(value, message) {
if (!value) {
fail(message);
}
}
}
/**
* Deeply maps the passed `value` by recursively calling the `iteratee` on
* value's children. The value returned from the iteratee is used to map the
* children.
*
* The iteratee is invoked with three arguments - the `value` being iterated,
* the `fieldPath` of the current `value` relative to the original passed value,
* and the `stack` of ancestors of the current `value`.
*
* For the first time the `iterate` will be called with the original `value`
* and empty arrays for `fieldPath` and `stack`.
*
* In other words, any `value` passed to the iteratee (except the first call,
* and assuming the ancestors keys were not mapped)
* will be equal to: `_.get(originalValue, fieldPath)`
*
* The recursion is called in pre-order depth-first-search. Meaning, the
* iteratee is called first on parent nodes and then on its children. Therefore
* if iteratee maps/replaces the parent node, then the children of the replaced
* node will be traversed.
*
* @example
* mapDeep({ prop: 'foo', arr: [ 'bar' , 1, 2 ] }, (value) => {
* if (_.isString(value)) return '__' + value;
* if (_.isNumber(value)) return value * 10;
* return value;
* })
* => { prop: '__foo', arr: [ '__bar', 10, 20 ] }
*
* mapDeep({ prop: 'foo', arr: [ 'bar' ] }, (value, fieldPath) => {
* if ((_.isString(value)) return value + '__' + fieldPath.join('.');
* return value;
* })
* => { prop: 'foo__prop', arr: [ 'bar__arr.0' ] }
*
* @param {*} value A value to map
* @param {Function} iteratee Function (value: any, fieldPath: Array, stack: Array)
* @param {object} [options]
* @param {boolean} [options.iterateCollections] Default: true
* @param {boolean} [options.iterateScalars] Default: true
* @param {boolean} [options.postOrder] Change the invocation of iteratee to post-order depth-first-search. Default: false
* @param {Array} [_keyPath] For internal recursive use
* @param {Array} [_objectStack] For internal recursive use
* @returns {*}
*/
function mapDeep(value, iteratee, options = {}, _keyPath = [], _objectStack = []) {
const postOrder = _.get(options, 'postOrder', false);
let iterate;
if (_.isPlainObject(value) || _.isArray(value)) {
iterate = _.get(options, 'iterateCollections', true);
} else {
iterate = _.get(options, 'iterateScalars', true);
}
if (iterate && !postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
const childrenIterator = (val, key) => {
return mapDeep(val, iteratee, options, _.concat(_keyPath, key), _.concat(_objectStack, [value]));
};
if (_.isPlainObject(value)) {
value = _.mapValues(value, childrenIterator);
} else if (_.isArray(value)) {
value = _.map(value, childrenIterator);
}
if (iterate && postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
return value;
}
function fieldPathToString(fieldPath) {
return _.reduce(fieldPath, (accumulator, fieldName, index) => {
if (_.isString(fieldName) && /\W/.test(fieldName)) {
// field name is a string with non alphanumeric character
accumulator += `['${fieldName}']`;
} else if (_.isNumber(fieldName)) {
accumulator += `[${fieldName}]`;
} else {
if (index > 0) {
accumulator += '.';
}
accumulator += fieldName;
}
return accumulator;
}, '');
}
function getFirstExistingFile(fileNames, inputDir) {
const filePaths = _.map(fileNames, fileName => path.resolve(inputDir, fileName));
return findPromise(filePaths, (filePath) => fse.pathExists(filePath));
}
function parseFirstExistingFile(fileNames, inputDir) {
return getFirstExistingFile(fileNames, inputDir).then(filePath => {
if (filePath) {
return parseFile(filePath);
} else {
return null;
}
});
}
async function parseFile(filePath) {
const data = await fse.readFile(filePath, 'utf8');
return parseDataByFilePath(data, filePath);
}
function parseDataByFilePath(string, filePath) {
const extension = path.extname(filePath).substring(1);
let data;
switch (extension) {
case 'yml':
case 'yaml':
data = yaml.safeLoad(string, {schema: yaml.JSON_SCHEMA});
break;
case 'json':
data = JSON.parse(string);
break;
case 'toml':
data = toml.parse(string);
break;
case 'md':
data = parseMarkdownWithFrontMatter(string);
break;
default:
throw new Error(`parseDataByFilePath error, extension '${extension}' of file ${filePath} is not supported`);
}
return data;
}
function parseMarkdownWithFrontMatter(string) | {
string = string.replace('\r\n', '\n');
let frontmatter = null;
let markdown = string;
let frontMatterTypes = [
{
type: 'yaml',
startDelimiter: '---\n',
endDelimiter: '\n---',
parse: (string) => yaml.safeLoad(string, {schema: yaml.JSON_SCHEMA})
},
{
type: 'toml',
startDelimiter: '+++\n',
endDelimiter: '\n+++',
parse: (string) => toml.parse(string)
},
{
type: 'json',
startDelimiter: '{\n', | identifier_body |
|
index.js | (array, callback, thisArg) {
return new Promise((resolve, reject) => {
function next(index) {
if (index < array.length) {
callback.call(thisArg, array[index], index, array).then(() => {
next(index + 1);
}).catch(error => {
reject(error);
});
} else {
resolve();
}
}
next(0);
});
}
function mapPromise(array, callback, thisArg) {
return new Promise((resolve, reject) => {
let results = [];
function next(index) {
if (index < array.length) {
callback.call(thisArg, array[index], index, array).then(result => {
results[index] = result;
next(index + 1);
}).catch(error => {
reject(error);
});
} else {
resolve(results);
}
}
next(0);
});
}
function findPromise(array, callback, thisArg) {
return new Promise((resolve, reject) => {
function next(index) {
if (index < array.length) {
callback.call(thisArg, array[index], index, array).then(result => {
if (result) {
resolve(array[index]);
} else {
next(index + 1);
}
}).catch(error => {
reject(error);
});
} else {
resolve();
}
}
next(0);
});
}
async function readDirRecursively(dir, options) {
const rootDir = _.get(options, 'rootDir', dir);
const files = await fse.readdir(dir);
const result = await mapPromise(files, async (file) => {
const filePath = path.join(dir, file);
const relFilePath = path.relative(rootDir, filePath);
const stats = await fse.stat(filePath);
if (_.has(options, 'filter') && !options.filter(relFilePath, stats)) {
return Promise.resolve();
}
if (stats.isDirectory()) {
return readDirRecursively(filePath, {...options, rootDir});
} else if (stats.isFile()) {
return relFilePath;
} else {
return null;
}
});
return _.chain(result).compact().flatten().value();
}
/**
* Gets the value at the first path of object having non undefined value.
* If all paths resolve to undefined values, the defaultValue is returned.
*
* @param {Object} object The object to query.
* @param {Array<String | Array<String>>} paths The property paths to search for.
* @param {*} [defaultValue] The value returned if all paths resolve to undefined values
* @returns {*}
*/
function getFirst(object, paths, defaultValue) {
let result = _(object).at(paths).reject(_.isUndefined).first();
return _.isUndefined(result) ? defaultValue : result;
}
function append(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.get(object, path).push(value);
}
function concat(object, path, value) {
if (!_.has(object, path)) {
_.set(object, path, []);
}
_.set(object, path, _.get(object, path).concat(value));
}
function copy(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (_.has(sourceObject, sourcePath)) {
let value = _.get(sourceObject, sourcePath);
if (transform) {
value = transform(value);
}
_.set(targetObject, targetPath, value);
}
}
function copyIfNotSet(sourceObject, sourcePath, targetObject, targetPath, transform) {
if (!_.has(targetObject, targetPath)) {
copy(sourceObject, sourcePath, targetObject, targetPath, transform);
}
}
function rename(object, oldPath, newPath) {
if (_.has(object, oldPath)) {
_.set(object, newPath, _.get(object, oldPath));
oldPath = _.toPath(oldPath);
if (oldPath.length > 1) {
object = _.get(object, _.initial(oldPath));
}
delete object[_.last(oldPath)];
}
}
function failFunctionWithTag(tag) {
return function fail(message) {
throw new Error(`[${tag}] ${message}`);
};
}
function assertFunctionWithFail(fail) {
return function assert(value, message) {
if (!value) {
fail(message);
}
}
}
/**
* Deeply maps the passed `value` by recursively calling the `iteratee` on
* value's children. The value returned from the iteratee is used to map the
* children.
*
* The iteratee is invoked with three arguments - the `value` being iterated,
* the `fieldPath` of the current `value` relative to the original passed value,
* and the `stack` of ancestors of the current `value`.
*
* For the first time the `iterate` will be called with the original `value`
* and empty arrays for `fieldPath` and `stack`.
*
* In other words, any `value` passed to the iteratee (except the first call,
* and assuming the ancestors keys were not mapped)
* will be equal to: `_.get(originalValue, fieldPath)`
*
* The recursion is called in pre-order depth-first-search. Meaning, the
* iteratee is called first on parent nodes and then on its children. Therefore
* if iteratee maps/replaces the parent node, then the children of the replaced
* node will be traversed.
*
* @example
* mapDeep({ prop: 'foo', arr: [ 'bar' , 1, 2 ] }, (value) => {
* if (_.isString(value)) return '__' + value;
* if (_.isNumber(value)) return value * 10;
* return value;
* })
* => { prop: '__foo', arr: [ '__bar', 10, 20 ] }
*
* mapDeep({ prop: 'foo', arr: [ 'bar' ] }, (value, fieldPath) => {
* if ((_.isString(value)) return value + '__' + fieldPath.join('.');
* return value;
* })
* => { prop: 'foo__prop', arr: [ 'bar__arr.0' ] }
*
* @param {*} value A value to map
* @param {Function} iteratee Function (value: any, fieldPath: Array, stack: Array)
* @param {object} [options]
* @param {boolean} [options.iterateCollections] Default: true
* @param {boolean} [options.iterateScalars] Default: true
* @param {boolean} [options.postOrder] Change the invocation of iteratee to post-order depth-first-search. Default: false
* @param {Array} [_keyPath] For internal recursive use
* @param {Array} [_objectStack] For internal recursive use
* @returns {*}
*/
function mapDeep(value, iteratee, options = {}, _keyPath = [], _objectStack = []) {
const postOrder = _.get(options, 'postOrder', false);
let iterate;
if (_.isPlainObject(value) || _.isArray(value)) {
iterate = _.get(options, 'iterateCollections', true);
} else {
iterate = _.get(options, 'iterateScalars', true);
}
if (iterate && !postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
const childrenIterator = (val, key) => {
return mapDeep(val, iteratee, options, _.concat(_keyPath, key), _.concat(_objectStack, [value]));
};
if (_.isPlainObject(value)) {
value = _.mapValues(value, childrenIterator);
} else if (_.isArray(value)) {
value = _.map(value, childrenIterator);
}
if (iterate && postOrder) {
value = iteratee(value, _keyPath, _objectStack);
}
return value;
}
function fieldPathToString(fieldPath) {
return _.reduce(fieldPath, (accumulator, fieldName, index) => {
if (_.isString(fieldName) && /\W/.test(fieldName)) {
// field name is a string with non alphanumeric character
accumulator += `['${fieldName}']`;
} else if (_.isNumber(fieldName)) {
accumulator += `[${fieldName}]`;
} else {
if (index > 0) {
accumulator += '.';
}
accumulator += fieldName;
}
return accumulator;
}, '');
}
function getFirstExistingFile(fileNames, inputDir) {
const filePaths = _.map(fileNames, fileName => path.resolve(inputDir, fileName));
return findPromise(filePaths, (filePath) => fse.pathExists(filePath));
}
function parseFirstExistingFile(fileNames, inputDir) {
return getFirstExistingFile(fileNames, inputDir).then(filePath => {
if (filePath) {
return parseFile(filePath);
} else {
return null;
}
});
}
async function parseFile(filePath) {
const data = await fse.readFile(filePath, 'utf8');
return parseDataByFilePath(data, filePath);
}
function parseDataByFilePath(string, filePath) {
const extension = path.extname(filePath).substring(1);
let data;
switch (extension) {
case 'yml':
case 'yaml':
data = yaml.safeLoad(string, {schema: yaml.JSON_SCHEMA});
break;
case 'json':
data = JSON.parse(string);
break;
case 'toml':
data = toml.parse(string);
| forEachPromise | identifier_name |
|
server.go | server.log[i] = NewConsensusState(len(server.BGsInfo), -1, server)
}
i1, err := strconv.Atoi(server.RPCPort)
common.AssertNil(err, "RPC port cannot be recognized.", logger)
tcpPort := common.CalcTCPPortFromRPCPort(i1)
server.tcpManager = NewTCPManager(strconv.Itoa(tcpPort))
server.tcpManager.SetServer(server)
logger.Infof("Server %s start ", server.Address+":"+server.RPCPort)
for _, s := range c["raft_peers"].([]interface{}) {
server.raftPeers = append(server.raftPeers, s.(string))
}
for _, s := range c["rpc_peers"].([]interface{}) {
server.rpcPeers = append(server.rpcPeers, s.(string))
}
server.resultReceiver = NewBftResultReceiver(server.SBFTReplicaAddressForBFTResult)
server.resultVerifier = NewBftResultVerifier(server.SBFTResultVerifierAddress)
server.disseminationLayer.SetServer(server)
server.config = configuration.NewConfiguration(server.ID, configHome)
server.addr = server.Address + ":" + server.RPCPort
// initialize byzantine groups (list of superleafs)
for _, bg := range c["byzantine_groups"].([]interface{}) {
bgInfo := byzantineGroup.NewByzantineGroup(bg)
server.BGsInfo = append(server.BGsInfo, bgInfo)
}
var succ bool
server.SuperLeafID, succ = server.BGsInfo[server.BGID].GetSuperLeafIdByServer(
server.Address + ":" + server.RPCPort)
common.AssertTrue(succ, "Cannot fetch SuperleafID", logger)
logger.Infof("Server %s SuperLeafId %d", server.Address+":"+server.RPCPort, server.SuperLeafID)
//create grpc server
sopts := []grpc.ServerOption{grpc.InitialWindowSize(2000000)}
sopts = append(sopts, grpc.InitialConnWindowSize(2000000))
server.grpcServer = grpc.NewServer(sopts...)
pb.RegisterPolarisAllServer(server.grpcServer, server)
reflection.Register(server.grpcServer)
logger.Info("GRPC server created")
return server
}
func (s *Server) Start() {
logger.Debugf("Server %v start...", s.ID)
// initialize Raft layer
proposeC := make(chan string)
defer close(proposeC)
confChangeC := make(chan raftpb.ConfChange)
defer close(confChangeC)
var raft *Raft
getSnapshot := func() ([]byte, error) { return raft.GetSnapshot() }
commitC, errorC, snapshotterReady, getLeaderID, raftNode, leaderC := raftnode.NewRaftNode(
s.RaftID, s.RaftPort, s.raftPeers, s.join, getSnapshot, proposeC, confChangeC, RaftOutputChannelSize)
s.getLeaderID = getLeaderID
s.raftNode = raftNode
s.raftLayer = NewRaft(s, <-snapshotterReady, proposeC, commitC, errorC)
s.requestManager = NewRequestManager(s,
int(s.config.GetClientRequestCycleTimeout()),
s.config.GetMaxBatchSize(),
s.raftLayer.slRequestChan,
s.raftLayer.txnBodyChan)
// wait for raft leader election
<-leaderC
go s.requestManager.Start()
go s.raftLayer.Start()
go s.disseminationLayer.Start()
if s.IsLeader() {
// create a thread receiving the result from SBFT replica
go s.resultReceiver.Start()
logger.Debugf("leader %v start process sbft result thread", s.ID)
// create a thread handling the result from SBFT replica
go s.processSBFTResult()
}
s.saveLeaderAddress()
s.tcpManager.Start()
tcpAddrList := make([]string, 0)
for _, bg := range s.BGsInfo {
for _, sAddr := range bg.GetServerList() {
items := strings.Split(sAddr, ":")
portNum, _ := strconv.Atoi(items[1])
tPort := common.CalcTCPPortFromRPCPort(portNum)
tAddr := items[0] + ":" + strconv.Itoa(tPort)
s.serverTCPAddrMap[sAddr] = tAddr
tcpAddrList = append(tcpAddrList, tAddr)
}
}
logger.Debugf("tpc server addrs %v", tcpAddrList)
s.tcpManager.DialAll(tcpAddrList)
// Start a RPC Listener
RPCListener, err := net.Listen("tcp", ":"+s.RPCPort)
if err != nil {
logger.Errorf("Failed to listen port %s, %v", s.RPCPort, err)
}
err = s.grpcServer.Serve(RPCListener)
if err != nil {
logger.Errorf("Cannot start to serve RPC calls %v", err)
}
}
// get monitor id (the leader of superleaf(Raft group))
func (s *Server) GetLeader() string {
id := s.getLeaderID()
if id == 0 {
return ""
}
leader := s.rpcPeers[id-1]
go s.BGsInfo[s.BGID].UpdateLeader(leader)
logger.Debugf("server %v get leader %v, raft id %v", s.addr, leader, id)
return leader
}
func (s *Server) IsLeader() bool {
// when the raft leader call getLeaderID, it will return 0
// it only shows in the first time
return int(s.getLeaderID()) == s.RaftID || int(s.getLeaderID()) == 0
}
func (s *Server) IsBGLeader() bool {
if s.currentBGLeaderSuperLeadId != s.SuperLeafID {
return false
}
return s.IsLeader()
}
func (s *Server) saveLeaderAddress() {
fName := fmt.Sprintf("./leader_%v.log", s.ID)
f, err := os.Create(fName)
if err != nil {
logger.Fatalf("create leader log file error %v", err)
}
defer f.Close()
leader := s.GetLeader()
if leader == "" {
leader = s.addr
}
logger.Debugf("save leader id %v", leader)
f.WriteString(leader)
f.Sync()
}
func (s *Server) GetRaftTerm() uint64 {
if s.raftNode == nil {
logger.Error("Raft Node is nil!")
return raft.InvalidRaftTerm
}
return s.raftNode.GetRaftTerm()
}
func (s *Server) GetSBFTClientConnection() *byzantineGroup.Connection {
if s.SBFTClientConnection == nil {
s.SBFTClientConnection = byzantineGroup.NewConnection(s.SBFTClientAddressForBFTLayer, queueLen, 1)
}
return s.SBFTClientConnection
}
func (s *Server) handleRPCError(err error) (*grpcpool.Pool, bool) {
errCode := grpc.Code(err)
if errCode == common.NotLeaderErrorCode {
leaderId := grpc.ErrorDesc(err)
s.BGsInfo[s.BGID].UpdateLeader(leaderId)
conn := s.BGsInfo[s.BGID].GetConnection(leaderId).GetConnectionPool()
return conn, true
}
logger.Warningf("Unhandled ERROR: %v", err)
return nil, false
}
// list of monitors (leaders of superleafs)
func (s *Server) GetBGMembers() []string {
leaders := make([]string, 0)
for i := 0; i < s.BGsInfo[s.BGID].GetSuperLeafNum(); i++ {
l := s.BGsInfo[s.BGID].GetLeader(i)
if l == s.GetServerAddr() {
continue
}
leaders = append(leaders, l)
}
return leaders
}
func (s *Server) GetServerAddr() string {
return s.addr
}
// return consensusState for cycleId
func (s *Server) GetConsensusStateByCycleId(cycleId int) *ConsensusState {
s.logLock.Lock()
defer s.logLock.Unlock()
common.AssertTrue(cycleId >= 0, "cycleID cannot be negative!", logger)
common.AssertTrue(cycleId > s.round2LastFinishedCycle-common.MaxCycleNumberInStorage, "Cannot access stale cycles!", logger)
// cycle may not complete in order
index := cycleId % common.MaxCycleNumberInStorage
if s.log[index].cycleId != cycleId {
// name-removed: Here we overwrite stale records
s.log[index] = NewConsensusState(len(s.BGsInfo), cycleId, s)
}
return s.log[index]
}
// check if the server recieves the state response of bgId for cycleId
// return true: already received
// false: not received
func (s *Server) CheckBGState(cycleId int, bgId int) bool {
logger.Debugf("check bg state response for cycle %v bgId %v", cycleId, bgId)
cs := s.GetConsensusStateByCycleId(cycleId)
op := NewCheckBGStateOp(bgId, cs)
if !cs.AddOPandWait(op) {
logger.Fatal("Error: should return true")
}
logger.Debugf("state response for cycle %v bgId %v is %v",
cycleId, | }
for i := 0; i < common.MaxCycleNumberInStorage; i++ {
// Fill it with -1 | random_line_split |
|
server.go | raft_peers"].([]interface{}) {
server.raftPeers = append(server.raftPeers, s.(string))
}
for _, s := range c["rpc_peers"].([]interface{}) {
server.rpcPeers = append(server.rpcPeers, s.(string))
}
server.resultReceiver = NewBftResultReceiver(server.SBFTReplicaAddressForBFTResult)
server.resultVerifier = NewBftResultVerifier(server.SBFTResultVerifierAddress)
server.disseminationLayer.SetServer(server)
server.config = configuration.NewConfiguration(server.ID, configHome)
server.addr = server.Address + ":" + server.RPCPort
// initialize byzantine groups (list of superleafs)
for _, bg := range c["byzantine_groups"].([]interface{}) {
bgInfo := byzantineGroup.NewByzantineGroup(bg)
server.BGsInfo = append(server.BGsInfo, bgInfo)
}
var succ bool
server.SuperLeafID, succ = server.BGsInfo[server.BGID].GetSuperLeafIdByServer(
server.Address + ":" + server.RPCPort)
common.AssertTrue(succ, "Cannot fetch SuperleafID", logger)
logger.Infof("Server %s SuperLeafId %d", server.Address+":"+server.RPCPort, server.SuperLeafID)
//create grpc server
sopts := []grpc.ServerOption{grpc.InitialWindowSize(2000000)}
sopts = append(sopts, grpc.InitialConnWindowSize(2000000))
server.grpcServer = grpc.NewServer(sopts...)
pb.RegisterPolarisAllServer(server.grpcServer, server)
reflection.Register(server.grpcServer)
logger.Info("GRPC server created")
return server
}
func (s *Server) Start() {
logger.Debugf("Server %v start...", s.ID)
// initialize Raft layer
proposeC := make(chan string)
defer close(proposeC)
confChangeC := make(chan raftpb.ConfChange)
defer close(confChangeC)
var raft *Raft
getSnapshot := func() ([]byte, error) { return raft.GetSnapshot() }
commitC, errorC, snapshotterReady, getLeaderID, raftNode, leaderC := raftnode.NewRaftNode(
s.RaftID, s.RaftPort, s.raftPeers, s.join, getSnapshot, proposeC, confChangeC, RaftOutputChannelSize)
s.getLeaderID = getLeaderID
s.raftNode = raftNode
s.raftLayer = NewRaft(s, <-snapshotterReady, proposeC, commitC, errorC)
s.requestManager = NewRequestManager(s,
int(s.config.GetClientRequestCycleTimeout()),
s.config.GetMaxBatchSize(),
s.raftLayer.slRequestChan,
s.raftLayer.txnBodyChan)
// wait for raft leader election
<-leaderC
go s.requestManager.Start()
go s.raftLayer.Start()
go s.disseminationLayer.Start()
if s.IsLeader() {
// create a thread receiving the result from SBFT replica
go s.resultReceiver.Start()
logger.Debugf("leader %v start process sbft result thread", s.ID)
// create a thread handling the result from SBFT replica
go s.processSBFTResult()
}
s.saveLeaderAddress()
s.tcpManager.Start()
tcpAddrList := make([]string, 0)
for _, bg := range s.BGsInfo {
for _, sAddr := range bg.GetServerList() {
items := strings.Split(sAddr, ":")
portNum, _ := strconv.Atoi(items[1])
tPort := common.CalcTCPPortFromRPCPort(portNum)
tAddr := items[0] + ":" + strconv.Itoa(tPort)
s.serverTCPAddrMap[sAddr] = tAddr
tcpAddrList = append(tcpAddrList, tAddr)
}
}
logger.Debugf("tpc server addrs %v", tcpAddrList)
s.tcpManager.DialAll(tcpAddrList)
// Start a RPC Listener
RPCListener, err := net.Listen("tcp", ":"+s.RPCPort)
if err != nil {
logger.Errorf("Failed to listen port %s, %v", s.RPCPort, err)
}
err = s.grpcServer.Serve(RPCListener)
if err != nil {
logger.Errorf("Cannot start to serve RPC calls %v", err)
}
}
// get monitor id (the leader of superleaf(Raft group))
func (s *Server) GetLeader() string {
id := s.getLeaderID()
if id == 0 {
return ""
}
leader := s.rpcPeers[id-1]
go s.BGsInfo[s.BGID].UpdateLeader(leader)
logger.Debugf("server %v get leader %v, raft id %v", s.addr, leader, id)
return leader
}
func (s *Server) IsLeader() bool {
// when the raft leader call getLeaderID, it will return 0
// it only shows in the first time
return int(s.getLeaderID()) == s.RaftID || int(s.getLeaderID()) == 0
}
func (s *Server) IsBGLeader() bool {
if s.currentBGLeaderSuperLeadId != s.SuperLeafID {
return false
}
return s.IsLeader()
}
func (s *Server) saveLeaderAddress() {
fName := fmt.Sprintf("./leader_%v.log", s.ID)
f, err := os.Create(fName)
if err != nil {
logger.Fatalf("create leader log file error %v", err)
}
defer f.Close()
leader := s.GetLeader()
if leader == "" {
leader = s.addr
}
logger.Debugf("save leader id %v", leader)
f.WriteString(leader)
f.Sync()
}
func (s *Server) GetRaftTerm() uint64 {
if s.raftNode == nil {
logger.Error("Raft Node is nil!")
return raft.InvalidRaftTerm
}
return s.raftNode.GetRaftTerm()
}
func (s *Server) GetSBFTClientConnection() *byzantineGroup.Connection {
if s.SBFTClientConnection == nil {
s.SBFTClientConnection = byzantineGroup.NewConnection(s.SBFTClientAddressForBFTLayer, queueLen, 1)
}
return s.SBFTClientConnection
}
func (s *Server) | (err error) (*grpcpool.Pool, bool) {
errCode := grpc.Code(err)
if errCode == common.NotLeaderErrorCode {
leaderId := grpc.ErrorDesc(err)
s.BGsInfo[s.BGID].UpdateLeader(leaderId)
conn := s.BGsInfo[s.BGID].GetConnection(leaderId).GetConnectionPool()
return conn, true
}
logger.Warningf("Unhandled ERROR: %v", err)
return nil, false
}
// list of monitors (leaders of superleafs)
func (s *Server) GetBGMembers() []string {
leaders := make([]string, 0)
for i := 0; i < s.BGsInfo[s.BGID].GetSuperLeafNum(); i++ {
l := s.BGsInfo[s.BGID].GetLeader(i)
if l == s.GetServerAddr() {
continue
}
leaders = append(leaders, l)
}
return leaders
}
func (s *Server) GetServerAddr() string {
return s.addr
}
// return consensusState for cycleId
func (s *Server) GetConsensusStateByCycleId(cycleId int) *ConsensusState {
s.logLock.Lock()
defer s.logLock.Unlock()
common.AssertTrue(cycleId >= 0, "cycleID cannot be negative!", logger)
common.AssertTrue(cycleId > s.round2LastFinishedCycle-common.MaxCycleNumberInStorage, "Cannot access stale cycles!", logger)
// cycle may not complete in order
index := cycleId % common.MaxCycleNumberInStorage
if s.log[index].cycleId != cycleId {
// name-removed: Here we overwrite stale records
s.log[index] = NewConsensusState(len(s.BGsInfo), cycleId, s)
}
return s.log[index]
}
// check if the server recieves the state response of bgId for cycleId
// return true: already received
// false: not received
func (s *Server) CheckBGState(cycleId int, bgId int) bool {
logger.Debugf("check bg state response for cycle %v bgId %v", cycleId, bgId)
cs := s.GetConsensusStateByCycleId(cycleId)
op := NewCheckBGStateOp(bgId, cs)
if !cs.AddOPandWait(op) {
logger.Fatal("Error: should return true")
}
logger.Debugf("state response for cycle %v bgId %v is %v",
cycleId, bgId, op.GetResult())
return op.GetResult()
}
func (s *Server) CheckStateRequest(sp *pb.StateRequestMessage) bool {
return s.checkRequestQC(sp)
}
func (s *Server) CheckStateResponse(sp *pb.StateResponseMessage) bool {
r := s.checkQC(sp)
if r {
// if QC check ok, then replicate to the Raft group
s.disseminationLayer.AddStateResponse(sp)
}
return r
}
// if the state response is ready, then get the state response
// otherwise return nil and put request to pending list
func (s *Server) GetOrWaitBGState | handleRPCError | identifier_name |
server.go | raft_peers"].([]interface{}) {
server.raftPeers = append(server.raftPeers, s.(string))
}
for _, s := range c["rpc_peers"].([]interface{}) {
server.rpcPeers = append(server.rpcPeers, s.(string))
}
server.resultReceiver = NewBftResultReceiver(server.SBFTReplicaAddressForBFTResult)
server.resultVerifier = NewBftResultVerifier(server.SBFTResultVerifierAddress)
server.disseminationLayer.SetServer(server)
server.config = configuration.NewConfiguration(server.ID, configHome)
server.addr = server.Address + ":" + server.RPCPort
// initialize byzantine groups (list of superleafs)
for _, bg := range c["byzantine_groups"].([]interface{}) {
bgInfo := byzantineGroup.NewByzantineGroup(bg)
server.BGsInfo = append(server.BGsInfo, bgInfo)
}
var succ bool
server.SuperLeafID, succ = server.BGsInfo[server.BGID].GetSuperLeafIdByServer(
server.Address + ":" + server.RPCPort)
common.AssertTrue(succ, "Cannot fetch SuperleafID", logger)
logger.Infof("Server %s SuperLeafId %d", server.Address+":"+server.RPCPort, server.SuperLeafID)
//create grpc server
sopts := []grpc.ServerOption{grpc.InitialWindowSize(2000000)}
sopts = append(sopts, grpc.InitialConnWindowSize(2000000))
server.grpcServer = grpc.NewServer(sopts...)
pb.RegisterPolarisAllServer(server.grpcServer, server)
reflection.Register(server.grpcServer)
logger.Info("GRPC server created")
return server
}
func (s *Server) Start() {
logger.Debugf("Server %v start...", s.ID)
// initialize Raft layer
proposeC := make(chan string)
defer close(proposeC)
confChangeC := make(chan raftpb.ConfChange)
defer close(confChangeC)
var raft *Raft
getSnapshot := func() ([]byte, error) { return raft.GetSnapshot() }
commitC, errorC, snapshotterReady, getLeaderID, raftNode, leaderC := raftnode.NewRaftNode(
s.RaftID, s.RaftPort, s.raftPeers, s.join, getSnapshot, proposeC, confChangeC, RaftOutputChannelSize)
s.getLeaderID = getLeaderID
s.raftNode = raftNode
s.raftLayer = NewRaft(s, <-snapshotterReady, proposeC, commitC, errorC)
s.requestManager = NewRequestManager(s,
int(s.config.GetClientRequestCycleTimeout()),
s.config.GetMaxBatchSize(),
s.raftLayer.slRequestChan,
s.raftLayer.txnBodyChan)
// wait for raft leader election
<-leaderC
go s.requestManager.Start()
go s.raftLayer.Start()
go s.disseminationLayer.Start()
if s.IsLeader() {
// create a thread receiving the result from SBFT replica
go s.resultReceiver.Start()
logger.Debugf("leader %v start process sbft result thread", s.ID)
// create a thread handling the result from SBFT replica
go s.processSBFTResult()
}
s.saveLeaderAddress()
s.tcpManager.Start()
tcpAddrList := make([]string, 0)
for _, bg := range s.BGsInfo {
for _, sAddr := range bg.GetServerList() {
items := strings.Split(sAddr, ":")
portNum, _ := strconv.Atoi(items[1])
tPort := common.CalcTCPPortFromRPCPort(portNum)
tAddr := items[0] + ":" + strconv.Itoa(tPort)
s.serverTCPAddrMap[sAddr] = tAddr
tcpAddrList = append(tcpAddrList, tAddr)
}
}
logger.Debugf("tpc server addrs %v", tcpAddrList)
s.tcpManager.DialAll(tcpAddrList)
// Start a RPC Listener
RPCListener, err := net.Listen("tcp", ":"+s.RPCPort)
if err != nil {
logger.Errorf("Failed to listen port %s, %v", s.RPCPort, err)
}
err = s.grpcServer.Serve(RPCListener)
if err != nil {
logger.Errorf("Cannot start to serve RPC calls %v", err)
}
}
// get monitor id (the leader of superleaf(Raft group))
func (s *Server) GetLeader() string {
id := s.getLeaderID()
if id == 0 {
return ""
}
leader := s.rpcPeers[id-1]
go s.BGsInfo[s.BGID].UpdateLeader(leader)
logger.Debugf("server %v get leader %v, raft id %v", s.addr, leader, id)
return leader
}
func (s *Server) IsLeader() bool |
func (s *Server) IsBGLeader() bool {
if s.currentBGLeaderSuperLeadId != s.SuperLeafID {
return false
}
return s.IsLeader()
}
func (s *Server) saveLeaderAddress() {
fName := fmt.Sprintf("./leader_%v.log", s.ID)
f, err := os.Create(fName)
if err != nil {
logger.Fatalf("create leader log file error %v", err)
}
defer f.Close()
leader := s.GetLeader()
if leader == "" {
leader = s.addr
}
logger.Debugf("save leader id %v", leader)
f.WriteString(leader)
f.Sync()
}
func (s *Server) GetRaftTerm() uint64 {
if s.raftNode == nil {
logger.Error("Raft Node is nil!")
return raft.InvalidRaftTerm
}
return s.raftNode.GetRaftTerm()
}
func (s *Server) GetSBFTClientConnection() *byzantineGroup.Connection {
if s.SBFTClientConnection == nil {
s.SBFTClientConnection = byzantineGroup.NewConnection(s.SBFTClientAddressForBFTLayer, queueLen, 1)
}
return s.SBFTClientConnection
}
func (s *Server) handleRPCError(err error) (*grpcpool.Pool, bool) {
errCode := grpc.Code(err)
if errCode == common.NotLeaderErrorCode {
leaderId := grpc.ErrorDesc(err)
s.BGsInfo[s.BGID].UpdateLeader(leaderId)
conn := s.BGsInfo[s.BGID].GetConnection(leaderId).GetConnectionPool()
return conn, true
}
logger.Warningf("Unhandled ERROR: %v", err)
return nil, false
}
// list of monitors (leaders of superleafs)
func (s *Server) GetBGMembers() []string {
leaders := make([]string, 0)
for i := 0; i < s.BGsInfo[s.BGID].GetSuperLeafNum(); i++ {
l := s.BGsInfo[s.BGID].GetLeader(i)
if l == s.GetServerAddr() {
continue
}
leaders = append(leaders, l)
}
return leaders
}
func (s *Server) GetServerAddr() string {
return s.addr
}
// return consensusState for cycleId
func (s *Server) GetConsensusStateByCycleId(cycleId int) *ConsensusState {
s.logLock.Lock()
defer s.logLock.Unlock()
common.AssertTrue(cycleId >= 0, "cycleID cannot be negative!", logger)
common.AssertTrue(cycleId > s.round2LastFinishedCycle-common.MaxCycleNumberInStorage, "Cannot access stale cycles!", logger)
// cycle may not complete in order
index := cycleId % common.MaxCycleNumberInStorage
if s.log[index].cycleId != cycleId {
// name-removed: Here we overwrite stale records
s.log[index] = NewConsensusState(len(s.BGsInfo), cycleId, s)
}
return s.log[index]
}
// check if the server recieves the state response of bgId for cycleId
// return true: already received
// false: not received
func (s *Server) CheckBGState(cycleId int, bgId int) bool {
logger.Debugf("check bg state response for cycle %v bgId %v", cycleId, bgId)
cs := s.GetConsensusStateByCycleId(cycleId)
op := NewCheckBGStateOp(bgId, cs)
if !cs.AddOPandWait(op) {
logger.Fatal("Error: should return true")
}
logger.Debugf("state response for cycle %v bgId %v is %v",
cycleId, bgId, op.GetResult())
return op.GetResult()
}
func (s *Server) CheckStateRequest(sp *pb.StateRequestMessage) bool {
return s.checkRequestQC(sp)
}
func (s *Server) CheckStateResponse(sp *pb.StateResponseMessage) bool {
r := s.checkQC(sp)
if r {
// if QC check ok, then replicate to the Raft group
s.disseminationLayer.AddStateResponse(sp)
}
return r
}
// if the state response is ready, then get the state response
// otherwise return nil and put request to pending list
func (s *Server) GetOrWaitBG | {
// when the raft leader call getLeaderID, it will return 0
// it only shows in the first time
return int(s.getLeaderID()) == s.RaftID || int(s.getLeaderID()) == 0
} | identifier_body |
server.go | raft_peers"].([]interface{}) {
server.raftPeers = append(server.raftPeers, s.(string))
}
for _, s := range c["rpc_peers"].([]interface{}) {
server.rpcPeers = append(server.rpcPeers, s.(string))
}
server.resultReceiver = NewBftResultReceiver(server.SBFTReplicaAddressForBFTResult)
server.resultVerifier = NewBftResultVerifier(server.SBFTResultVerifierAddress)
server.disseminationLayer.SetServer(server)
server.config = configuration.NewConfiguration(server.ID, configHome)
server.addr = server.Address + ":" + server.RPCPort
// initialize byzantine groups (list of superleafs)
for _, bg := range c["byzantine_groups"].([]interface{}) {
bgInfo := byzantineGroup.NewByzantineGroup(bg)
server.BGsInfo = append(server.BGsInfo, bgInfo)
}
var succ bool
server.SuperLeafID, succ = server.BGsInfo[server.BGID].GetSuperLeafIdByServer(
server.Address + ":" + server.RPCPort)
common.AssertTrue(succ, "Cannot fetch SuperleafID", logger)
logger.Infof("Server %s SuperLeafId %d", server.Address+":"+server.RPCPort, server.SuperLeafID)
//create grpc server
sopts := []grpc.ServerOption{grpc.InitialWindowSize(2000000)}
sopts = append(sopts, grpc.InitialConnWindowSize(2000000))
server.grpcServer = grpc.NewServer(sopts...)
pb.RegisterPolarisAllServer(server.grpcServer, server)
reflection.Register(server.grpcServer)
logger.Info("GRPC server created")
return server
}
func (s *Server) Start() {
logger.Debugf("Server %v start...", s.ID)
// initialize Raft layer
proposeC := make(chan string)
defer close(proposeC)
confChangeC := make(chan raftpb.ConfChange)
defer close(confChangeC)
var raft *Raft
getSnapshot := func() ([]byte, error) { return raft.GetSnapshot() }
commitC, errorC, snapshotterReady, getLeaderID, raftNode, leaderC := raftnode.NewRaftNode(
s.RaftID, s.RaftPort, s.raftPeers, s.join, getSnapshot, proposeC, confChangeC, RaftOutputChannelSize)
s.getLeaderID = getLeaderID
s.raftNode = raftNode
s.raftLayer = NewRaft(s, <-snapshotterReady, proposeC, commitC, errorC)
s.requestManager = NewRequestManager(s,
int(s.config.GetClientRequestCycleTimeout()),
s.config.GetMaxBatchSize(),
s.raftLayer.slRequestChan,
s.raftLayer.txnBodyChan)
// wait for raft leader election
<-leaderC
go s.requestManager.Start()
go s.raftLayer.Start()
go s.disseminationLayer.Start()
if s.IsLeader() {
// create a thread receiving the result from SBFT replica
go s.resultReceiver.Start()
logger.Debugf("leader %v start process sbft result thread", s.ID)
// create a thread handling the result from SBFT replica
go s.processSBFTResult()
}
s.saveLeaderAddress()
s.tcpManager.Start()
tcpAddrList := make([]string, 0)
for _, bg := range s.BGsInfo {
for _, sAddr := range bg.GetServerList() {
items := strings.Split(sAddr, ":")
portNum, _ := strconv.Atoi(items[1])
tPort := common.CalcTCPPortFromRPCPort(portNum)
tAddr := items[0] + ":" + strconv.Itoa(tPort)
s.serverTCPAddrMap[sAddr] = tAddr
tcpAddrList = append(tcpAddrList, tAddr)
}
}
logger.Debugf("tpc server addrs %v", tcpAddrList)
s.tcpManager.DialAll(tcpAddrList)
// Start a RPC Listener
RPCListener, err := net.Listen("tcp", ":"+s.RPCPort)
if err != nil {
logger.Errorf("Failed to listen port %s, %v", s.RPCPort, err)
}
err = s.grpcServer.Serve(RPCListener)
if err != nil {
logger.Errorf("Cannot start to serve RPC calls %v", err)
}
}
// get monitor id (the leader of superleaf(Raft group))
func (s *Server) GetLeader() string {
id := s.getLeaderID()
if id == 0 |
leader := s.rpcPeers[id-1]
go s.BGsInfo[s.BGID].UpdateLeader(leader)
logger.Debugf("server %v get leader %v, raft id %v", s.addr, leader, id)
return leader
}
func (s *Server) IsLeader() bool {
// when the raft leader call getLeaderID, it will return 0
// it only shows in the first time
return int(s.getLeaderID()) == s.RaftID || int(s.getLeaderID()) == 0
}
func (s *Server) IsBGLeader() bool {
if s.currentBGLeaderSuperLeadId != s.SuperLeafID {
return false
}
return s.IsLeader()
}
func (s *Server) saveLeaderAddress() {
fName := fmt.Sprintf("./leader_%v.log", s.ID)
f, err := os.Create(fName)
if err != nil {
logger.Fatalf("create leader log file error %v", err)
}
defer f.Close()
leader := s.GetLeader()
if leader == "" {
leader = s.addr
}
logger.Debugf("save leader id %v", leader)
f.WriteString(leader)
f.Sync()
}
func (s *Server) GetRaftTerm() uint64 {
if s.raftNode == nil {
logger.Error("Raft Node is nil!")
return raft.InvalidRaftTerm
}
return s.raftNode.GetRaftTerm()
}
func (s *Server) GetSBFTClientConnection() *byzantineGroup.Connection {
if s.SBFTClientConnection == nil {
s.SBFTClientConnection = byzantineGroup.NewConnection(s.SBFTClientAddressForBFTLayer, queueLen, 1)
}
return s.SBFTClientConnection
}
func (s *Server) handleRPCError(err error) (*grpcpool.Pool, bool) {
errCode := grpc.Code(err)
if errCode == common.NotLeaderErrorCode {
leaderId := grpc.ErrorDesc(err)
s.BGsInfo[s.BGID].UpdateLeader(leaderId)
conn := s.BGsInfo[s.BGID].GetConnection(leaderId).GetConnectionPool()
return conn, true
}
logger.Warningf("Unhandled ERROR: %v", err)
return nil, false
}
// list of monitors (leaders of superleafs)
func (s *Server) GetBGMembers() []string {
leaders := make([]string, 0)
for i := 0; i < s.BGsInfo[s.BGID].GetSuperLeafNum(); i++ {
l := s.BGsInfo[s.BGID].GetLeader(i)
if l == s.GetServerAddr() {
continue
}
leaders = append(leaders, l)
}
return leaders
}
func (s *Server) GetServerAddr() string {
return s.addr
}
// return consensusState for cycleId
func (s *Server) GetConsensusStateByCycleId(cycleId int) *ConsensusState {
s.logLock.Lock()
defer s.logLock.Unlock()
common.AssertTrue(cycleId >= 0, "cycleID cannot be negative!", logger)
common.AssertTrue(cycleId > s.round2LastFinishedCycle-common.MaxCycleNumberInStorage, "Cannot access stale cycles!", logger)
// cycle may not complete in order
index := cycleId % common.MaxCycleNumberInStorage
if s.log[index].cycleId != cycleId {
// name-removed: Here we overwrite stale records
s.log[index] = NewConsensusState(len(s.BGsInfo), cycleId, s)
}
return s.log[index]
}
// check if the server recieves the state response of bgId for cycleId
// return true: already received
// false: not received
func (s *Server) CheckBGState(cycleId int, bgId int) bool {
logger.Debugf("check bg state response for cycle %v bgId %v", cycleId, bgId)
cs := s.GetConsensusStateByCycleId(cycleId)
op := NewCheckBGStateOp(bgId, cs)
if !cs.AddOPandWait(op) {
logger.Fatal("Error: should return true")
}
logger.Debugf("state response for cycle %v bgId %v is %v",
cycleId, bgId, op.GetResult())
return op.GetResult()
}
func (s *Server) CheckStateRequest(sp *pb.StateRequestMessage) bool {
return s.checkRequestQC(sp)
}
func (s *Server) CheckStateResponse(sp *pb.StateResponseMessage) bool {
r := s.checkQC(sp)
if r {
// if QC check ok, then replicate to the Raft group
s.disseminationLayer.AddStateResponse(sp)
}
return r
}
// if the state response is ready, then get the state response
// otherwise return nil and put request to pending list
func (s *Server) GetOrWaitBG | {
return ""
} | conditional_block |
doom.py | 00
max_steps = 100
batch_size = 64
explore_start = 1.0
explore_stop = .01
decay_rate = 0.0001
gamma = 0.95
pretrain_length = batch_size
memory_size = 1000000
render = True
DQNetwork = None
stack_size = 4
saver = tf.train.Saver()
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--model", required=False, type=bool, default=False,
help="Use the latest saved model")
args = vars(ap.parse_args())
def train(memory):
global stacked_frames
global saver
sess = tf.Session()
sess.run(tf.global_variables_initializer())
decay_step = 0
game.init()
for episode in range(total_episodes):
print("Training on episode: {}".format(episode))
step = 0
episode_rewards = []
game.new_episode()
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
while step < max_steps:
step += 1
decay_step += 1
action, explore_probability = predict_action(decay_step, possible_actions, state, sess)
reward = game.make_action(action)
done = game.is_episode_finished()
episode_rewards.append(reward)
if done:
# the episode ends so no next state
next_state = np.zeros((84, 84), dtype=np.int)
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Set step = max_steps to end the episode
step = max_steps
# Get the total reward of the episode
total_reward = np.sum(episode_rewards)
print('Episode: {}'.format(episode),
'Total reward: {}'.format(total_reward),
'Training loss: {:.4f}'.format(loss),
'Explore P: {:.4f}'.format(explore_probability))
memory.add((state, action, reward, next_state, done))
else:
# Get the next state
next_state = game.get_state().screen_buffer
# Stack the frame of the next_state
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Add experience to memory
memory.add((state, action, reward, next_state, done))
# st+1 is now our current state
state = next_state
### LEARNING PART
# Obtain random mini-batch from memory
batch = memory.sample(batch_size)
states_mb = np.array([each[0] for each in batch])
actions_mb = np.array([each[1] for each in batch])
rewards_mb = np.array([each[2] for each in batch])
next_states_mb = np.array([each[3] for each in batch])
dones_mb = np.array([each[4] for each in batch])
target_Qs_batch = []
# Get Q values for next_state
Qs_next_state = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: next_states_mb})
# Set Q_target = r if the episode ends at s+1, otherwise set Q_target = r + gamma*maxQ(s', a')
for i in range(0, len(batch)):
terminal = dones_mb[i]
# If we are in a terminal state, only equals reward
if terminal:
target_Qs_batch.append(rewards_mb[i])
else:
target = rewards_mb[i] + gamma * np.max(Qs_next_state[i])
target_Qs_batch.append(target)
targets_mb = np.array([each for each in target_Qs_batch])
loss, _ = sess.run([DQNetwork.loss, DQNetwork.optimizer],
feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
# Write TF Summaries
summary = sess.run(write_op, feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
writer.add_summary(summary, episode)
writer.flush()
# Save model every 5 episodes
if episode % 5 == 0:
save_path = saver.save(sess, "./models/model.ckpt")
print("Model Saved")
def infer():
global env
global saver
sess = tf.Session()
total_test_rewards = []
game, possible_actions = create_environment()
totalScore = 0
saver.restore(sess, "./models/model.ckpt")
game.init()
for episode in range(1):
total_rewards = 0
state = env.reset()
state, stacked_frames = stack_frames(stacked_frames, state, True)
print("**************************************")
print("EPISODSE ", episode)
while True:
# reshape the state
state = state.reshape((1, *state_size))
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state})
# Take the biggest Q value
choice = np.argmax(Qs)
action = possible_actions[choice]
next_state, reward, done, _ = env.step(action)
env.render()
total_rewards += reward
if done:
print("Score", total_rewards)
total_test_rewards.append(total_rewards)
break
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
state = next_state
env.close()
def predict_action(decay_step, possible_actions, state, sess):
global explore_start
global explore_stop
global decay_rate
exp_exp_tradeoff = np.random.rand()
explore_probability = explore_stop + (explore_start - explore_stop) * np.exp(-decay_rate * decay_step)
if explore_probability > exp_exp_tradeoff:
action = random.choice(possible_actions)
else:
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state.reshape((1, *state.shape))})
choice = np.argmax(Qs)
action = possible_actions[int(choice)]
return action, explore_probability
def createnetwork():
global DQNetwork
global state_size
global action_size
global learning_rate
tf.reset_default_graph()
DQNetwork = dqn2.DQNetwork(state_size, action_size, learning_rate)
def preprocess_frame(frame):
cropped_frame = frame[30:-10, 30: -30]
normalized_frame = cropped_frame/255.0
preprocessed_frame = transform.resize(normalized_frame, [84, 84])
return preprocessed_frame
def stack_frames(frames2stack, state, is_new_episode):
frame = preprocess_frame(state)
if is_new_episode:
# Clear the stacked frames
frames2stack = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
# this is new episode so copy the first and only frame 4 times
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
# stack the frames
stacked_state = np.stack(frames2stack, axis=2)
else:
# Append frame to deque
frames2stack.append(frame)
stacked_state = np.stack(frames2stack, axis=2)
return stacked_state, frames2stack
def create_environment():
global game
global state_size
global action_size
game = DoomGame()
game.load_config("basic.cfg")
game.set_doom_scenario_path("basic.wad")
game.init()
state_size = [84, 84, 4] # 4 Frames at 84x84 resolution
# Possible actions
left = [1, 0, 0]
right = [0, 1, 0]
shoot = [0, 0, 1]
possible_actions = [left, right, shoot]
action_size = 3
return game, possible_actions
def test_environment():
|
if not args['model']:
stacked_frames = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
game, possible_actions = create_environment()
print("Game Environment created")
createnetwork()
print("network created")
memory = mem.Memory(max_size=memory_size)
game.new_episode()
for i in range(pretrain_length):
if i is 0:
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
# Take a random action
action = random.choice(possible_actions)
# rewards
reward = game.make_action(action)
done = | global game
episodes = 10
for i in range(episodes):
game.new_episode()
while not game.is_episode_finished():
state = game.get_state()
img = state.screen_buffer
misc = state.game_variables
action = random.choice(possible_actions)
print("Taking action: {}".format(action))
reward = game.make_action(action)
print("Reward for above action: {}".format(reward))
time.sleep(.2)
print("Episode final reward score: {}".format(game.get_total_reward()))
time.sleep(2)
game.close() | identifier_body |
doom.py | 500
max_steps = 100
batch_size = 64
explore_start = 1.0
explore_stop = .01
decay_rate = 0.0001
gamma = 0.95
pretrain_length = batch_size
memory_size = 1000000
render = True
DQNetwork = None
stack_size = 4
saver = tf.train.Saver()
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--model", required=False, type=bool, default=False,
help="Use the latest saved model")
args = vars(ap.parse_args())
def train(memory):
global stacked_frames
global saver
sess = tf.Session()
sess.run(tf.global_variables_initializer())
decay_step = 0
game.init()
for episode in range(total_episodes):
print("Training on episode: {}".format(episode))
step = 0
episode_rewards = []
game.new_episode()
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
while step < max_steps:
step += 1
decay_step += 1
action, explore_probability = predict_action(decay_step, possible_actions, state, sess)
reward = game.make_action(action)
done = game.is_episode_finished()
episode_rewards.append(reward)
if done:
# the episode ends so no next state
next_state = np.zeros((84, 84), dtype=np.int)
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Set step = max_steps to end the episode
step = max_steps
# Get the total reward of the episode
total_reward = np.sum(episode_rewards)
print('Episode: {}'.format(episode),
'Total reward: {}'.format(total_reward),
'Training loss: {:.4f}'.format(loss),
'Explore P: {:.4f}'.format(explore_probability))
memory.add((state, action, reward, next_state, done))
else:
# Get the next state
next_state = game.get_state().screen_buffer
# Stack the frame of the next_state
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Add experience to memory
memory.add((state, action, reward, next_state, done))
# st+1 is now our current state
state = next_state
### LEARNING PART
# Obtain random mini-batch from memory
batch = memory.sample(batch_size)
states_mb = np.array([each[0] for each in batch])
actions_mb = np.array([each[1] for each in batch])
rewards_mb = np.array([each[2] for each in batch])
next_states_mb = np.array([each[3] for each in batch])
dones_mb = np.array([each[4] for each in batch])
target_Qs_batch = []
# Get Q values for next_state
Qs_next_state = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: next_states_mb})
# Set Q_target = r if the episode ends at s+1, otherwise set Q_target = r + gamma*maxQ(s', a')
for i in range(0, len(batch)):
terminal = dones_mb[i]
# If we are in a terminal state, only equals reward
if terminal:
target_Qs_batch.append(rewards_mb[i])
else:
target = rewards_mb[i] + gamma * np.max(Qs_next_state[i])
target_Qs_batch.append(target)
targets_mb = np.array([each for each in target_Qs_batch])
loss, _ = sess.run([DQNetwork.loss, DQNetwork.optimizer],
feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
# Write TF Summaries
summary = sess.run(write_op, feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
writer.add_summary(summary, episode)
writer.flush()
# Save model every 5 episodes
if episode % 5 == 0:
save_path = saver.save(sess, "./models/model.ckpt")
print("Model Saved")
def infer():
global env
global saver
sess = tf.Session()
total_test_rewards = []
game, possible_actions = create_environment()
totalScore = 0
saver.restore(sess, "./models/model.ckpt")
game.init()
for episode in range(1):
total_rewards = 0
state = env.reset()
state, stacked_frames = stack_frames(stacked_frames, state, True)
print("**************************************")
print("EPISODSE ", episode)
while True:
# reshape the state
state = state.reshape((1, *state_size))
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state})
# Take the biggest Q value
choice = np.argmax(Qs)
action = possible_actions[choice]
next_state, reward, done, _ = env.step(action)
env.render()
total_rewards += reward
if done:
|
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
state = next_state
env.close()
def predict_action(decay_step, possible_actions, state, sess):
global explore_start
global explore_stop
global decay_rate
exp_exp_tradeoff = np.random.rand()
explore_probability = explore_stop + (explore_start - explore_stop) * np.exp(-decay_rate * decay_step)
if explore_probability > exp_exp_tradeoff:
action = random.choice(possible_actions)
else:
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state.reshape((1, *state.shape))})
choice = np.argmax(Qs)
action = possible_actions[int(choice)]
return action, explore_probability
def createnetwork():
global DQNetwork
global state_size
global action_size
global learning_rate
tf.reset_default_graph()
DQNetwork = dqn2.DQNetwork(state_size, action_size, learning_rate)
def preprocess_frame(frame):
cropped_frame = frame[30:-10, 30: -30]
normalized_frame = cropped_frame/255.0
preprocessed_frame = transform.resize(normalized_frame, [84, 84])
return preprocessed_frame
def stack_frames(frames2stack, state, is_new_episode):
frame = preprocess_frame(state)
if is_new_episode:
# Clear the stacked frames
frames2stack = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
# this is new episode so copy the first and only frame 4 times
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
# stack the frames
stacked_state = np.stack(frames2stack, axis=2)
else:
# Append frame to deque
frames2stack.append(frame)
stacked_state = np.stack(frames2stack, axis=2)
return stacked_state, frames2stack
def create_environment():
global game
global state_size
global action_size
game = DoomGame()
game.load_config("basic.cfg")
game.set_doom_scenario_path("basic.wad")
game.init()
state_size = [84, 84, 4] # 4 Frames at 84x84 resolution
# Possible actions
left = [1, 0, 0]
right = [0, 1, 0]
shoot = [0, 0, 1]
possible_actions = [left, right, shoot]
action_size = 3
return game, possible_actions
def test_environment():
global game
episodes = 10
for i in range(episodes):
game.new_episode()
while not game.is_episode_finished():
state = game.get_state()
img = state.screen_buffer
misc = state.game_variables
action = random.choice(possible_actions)
print("Taking action: {}".format(action))
reward = game.make_action(action)
print("Reward for above action: {}".format(reward))
time.sleep(.2)
print("Episode final reward score: {}".format(game.get_total_reward()))
time.sleep(2)
game.close()
if not args['model']:
stacked_frames = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
game, possible_actions = create_environment()
print("Game Environment created")
createnetwork()
print("network created")
memory = mem.Memory(max_size=memory_size)
game.new_episode()
for i in range(pretrain_length):
if i is 0:
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
# Take a random action
action = random.choice(possible_actions)
# rewards
reward = game.make_action(action)
done = | print("Score", total_rewards)
total_test_rewards.append(total_rewards)
break | conditional_block |
doom.py | 00
max_steps = 100
batch_size = 64
explore_start = 1.0
explore_stop = .01
decay_rate = 0.0001
gamma = 0.95
pretrain_length = batch_size
memory_size = 1000000
render = True
DQNetwork = None
stack_size = 4
saver = tf.train.Saver()
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--model", required=False, type=bool, default=False,
help="Use the latest saved model")
args = vars(ap.parse_args())
def | (memory):
global stacked_frames
global saver
sess = tf.Session()
sess.run(tf.global_variables_initializer())
decay_step = 0
game.init()
for episode in range(total_episodes):
print("Training on episode: {}".format(episode))
step = 0
episode_rewards = []
game.new_episode()
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
while step < max_steps:
step += 1
decay_step += 1
action, explore_probability = predict_action(decay_step, possible_actions, state, sess)
reward = game.make_action(action)
done = game.is_episode_finished()
episode_rewards.append(reward)
if done:
# the episode ends so no next state
next_state = np.zeros((84, 84), dtype=np.int)
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Set step = max_steps to end the episode
step = max_steps
# Get the total reward of the episode
total_reward = np.sum(episode_rewards)
print('Episode: {}'.format(episode),
'Total reward: {}'.format(total_reward),
'Training loss: {:.4f}'.format(loss),
'Explore P: {:.4f}'.format(explore_probability))
memory.add((state, action, reward, next_state, done))
else:
# Get the next state
next_state = game.get_state().screen_buffer
# Stack the frame of the next_state
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Add experience to memory
memory.add((state, action, reward, next_state, done))
# st+1 is now our current state
state = next_state
### LEARNING PART
# Obtain random mini-batch from memory
batch = memory.sample(batch_size)
states_mb = np.array([each[0] for each in batch])
actions_mb = np.array([each[1] for each in batch])
rewards_mb = np.array([each[2] for each in batch])
next_states_mb = np.array([each[3] for each in batch])
dones_mb = np.array([each[4] for each in batch])
target_Qs_batch = []
# Get Q values for next_state
Qs_next_state = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: next_states_mb})
# Set Q_target = r if the episode ends at s+1, otherwise set Q_target = r + gamma*maxQ(s', a')
for i in range(0, len(batch)):
terminal = dones_mb[i]
# If we are in a terminal state, only equals reward
if terminal:
target_Qs_batch.append(rewards_mb[i])
else:
target = rewards_mb[i] + gamma * np.max(Qs_next_state[i])
target_Qs_batch.append(target)
targets_mb = np.array([each for each in target_Qs_batch])
loss, _ = sess.run([DQNetwork.loss, DQNetwork.optimizer],
feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
# Write TF Summaries
summary = sess.run(write_op, feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
writer.add_summary(summary, episode)
writer.flush()
# Save model every 5 episodes
if episode % 5 == 0:
save_path = saver.save(sess, "./models/model.ckpt")
print("Model Saved")
def infer():
global env
global saver
sess = tf.Session()
total_test_rewards = []
game, possible_actions = create_environment()
totalScore = 0
saver.restore(sess, "./models/model.ckpt")
game.init()
for episode in range(1):
total_rewards = 0
state = env.reset()
state, stacked_frames = stack_frames(stacked_frames, state, True)
print("**************************************")
print("EPISODSE ", episode)
while True:
# reshape the state
state = state.reshape((1, *state_size))
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state})
# Take the biggest Q value
choice = np.argmax(Qs)
action = possible_actions[choice]
next_state, reward, done, _ = env.step(action)
env.render()
total_rewards += reward
if done:
print("Score", total_rewards)
total_test_rewards.append(total_rewards)
break
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
state = next_state
env.close()
def predict_action(decay_step, possible_actions, state, sess):
global explore_start
global explore_stop
global decay_rate
exp_exp_tradeoff = np.random.rand()
explore_probability = explore_stop + (explore_start - explore_stop) * np.exp(-decay_rate * decay_step)
if explore_probability > exp_exp_tradeoff:
action = random.choice(possible_actions)
else:
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state.reshape((1, *state.shape))})
choice = np.argmax(Qs)
action = possible_actions[int(choice)]
return action, explore_probability
def createnetwork():
global DQNetwork
global state_size
global action_size
global learning_rate
tf.reset_default_graph()
DQNetwork = dqn2.DQNetwork(state_size, action_size, learning_rate)
def preprocess_frame(frame):
cropped_frame = frame[30:-10, 30: -30]
normalized_frame = cropped_frame/255.0
preprocessed_frame = transform.resize(normalized_frame, [84, 84])
return preprocessed_frame
def stack_frames(frames2stack, state, is_new_episode):
frame = preprocess_frame(state)
if is_new_episode:
# Clear the stacked frames
frames2stack = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
# this is new episode so copy the first and only frame 4 times
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
# stack the frames
stacked_state = np.stack(frames2stack, axis=2)
else:
# Append frame to deque
frames2stack.append(frame)
stacked_state = np.stack(frames2stack, axis=2)
return stacked_state, frames2stack
def create_environment():
global game
global state_size
global action_size
game = DoomGame()
game.load_config("basic.cfg")
game.set_doom_scenario_path("basic.wad")
game.init()
state_size = [84, 84, 4] # 4 Frames at 84x84 resolution
# Possible actions
left = [1, 0, 0]
right = [0, 1, 0]
shoot = [0, 0, 1]
possible_actions = [left, right, shoot]
action_size = 3
return game, possible_actions
def test_environment():
global game
episodes = 10
for i in range(episodes):
game.new_episode()
while not game.is_episode_finished():
state = game.get_state()
img = state.screen_buffer
misc = state.game_variables
action = random.choice(possible_actions)
print("Taking action: {}".format(action))
reward = game.make_action(action)
print("Reward for above action: {}".format(reward))
time.sleep(.2)
print("Episode final reward score: {}".format(game.get_total_reward()))
time.sleep(2)
game.close()
if not args['model']:
stacked_frames = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
game, possible_actions = create_environment()
print("Game Environment created")
createnetwork()
print("network created")
memory = mem.Memory(max_size=memory_size)
game.new_episode()
for i in range(pretrain_length):
if i is 0:
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
# Take a random action
action = random.choice(possible_actions)
# rewards
reward = game.make_action(action)
done = | train | identifier_name |
doom.py | 500
max_steps = 100
batch_size = 64
explore_start = 1.0
explore_stop = .01
decay_rate = 0.0001
gamma = 0.95
pretrain_length = batch_size
memory_size = 1000000
render = True
DQNetwork = None
stack_size = 4
saver = tf.train.Saver()
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--model", required=False, type=bool, default=False,
help="Use the latest saved model")
args = vars(ap.parse_args())
def train(memory):
global stacked_frames
global saver
sess = tf.Session()
sess.run(tf.global_variables_initializer())
decay_step = 0
game.init()
for episode in range(total_episodes):
print("Training on episode: {}".format(episode))
step = 0
episode_rewards = []
game.new_episode()
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
while step < max_steps:
step += 1
decay_step += 1
action, explore_probability = predict_action(decay_step, possible_actions, state, sess)
reward = game.make_action(action)
done = game.is_episode_finished()
episode_rewards.append(reward)
if done:
# the episode ends so no next state
next_state = np.zeros((84, 84), dtype=np.int)
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Set step = max_steps to end the episode
step = max_steps
# Get the total reward of the episode
total_reward = np.sum(episode_rewards)
print('Episode: {}'.format(episode),
'Total reward: {}'.format(total_reward),
'Training loss: {:.4f}'.format(loss),
'Explore P: {:.4f}'.format(explore_probability))
memory.add((state, action, reward, next_state, done))
else:
# Get the next state
next_state = game.get_state().screen_buffer
# Stack the frame of the next_state
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
# Add experience to memory
memory.add((state, action, reward, next_state, done))
# st+1 is now our current state
state = next_state
### LEARNING PART
# Obtain random mini-batch from memory
batch = memory.sample(batch_size)
states_mb = np.array([each[0] for each in batch])
actions_mb = np.array([each[1] for each in batch])
rewards_mb = np.array([each[2] for each in batch])
next_states_mb = np.array([each[3] for each in batch])
dones_mb = np.array([each[4] for each in batch])
target_Qs_batch = []
# Get Q values for next_state
Qs_next_state = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: next_states_mb})
# Set Q_target = r if the episode ends at s+1, otherwise set Q_target = r + gamma*maxQ(s', a')
for i in range(0, len(batch)):
terminal = dones_mb[i]
# If we are in a terminal state, only equals reward
if terminal:
target_Qs_batch.append(rewards_mb[i])
else:
target = rewards_mb[i] + gamma * np.max(Qs_next_state[i])
target_Qs_batch.append(target)
targets_mb = np.array([each for each in target_Qs_batch]) | loss, _ = sess.run([DQNetwork.loss, DQNetwork.optimizer],
feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
# Write TF Summaries
summary = sess.run(write_op, feed_dict={DQNetwork.inputs_: states_mb,
DQNetwork.target_Q: targets_mb,
DQNetwork.actions_: actions_mb})
writer.add_summary(summary, episode)
writer.flush()
# Save model every 5 episodes
if episode % 5 == 0:
save_path = saver.save(sess, "./models/model.ckpt")
print("Model Saved")
def infer():
global env
global saver
sess = tf.Session()
total_test_rewards = []
game, possible_actions = create_environment()
totalScore = 0
saver.restore(sess, "./models/model.ckpt")
game.init()
for episode in range(1):
total_rewards = 0
state = env.reset()
state, stacked_frames = stack_frames(stacked_frames, state, True)
print("**************************************")
print("EPISODSE ", episode)
while True:
# reshape the state
state = state.reshape((1, *state_size))
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state})
# Take the biggest Q value
choice = np.argmax(Qs)
action = possible_actions[choice]
next_state, reward, done, _ = env.step(action)
env.render()
total_rewards += reward
if done:
print("Score", total_rewards)
total_test_rewards.append(total_rewards)
break
next_state, stacked_frames = stack_frames(stacked_frames, next_state, False)
state = next_state
env.close()
def predict_action(decay_step, possible_actions, state, sess):
global explore_start
global explore_stop
global decay_rate
exp_exp_tradeoff = np.random.rand()
explore_probability = explore_stop + (explore_start - explore_stop) * np.exp(-decay_rate * decay_step)
if explore_probability > exp_exp_tradeoff:
action = random.choice(possible_actions)
else:
Qs = sess.run(DQNetwork.output, feed_dict={DQNetwork.inputs_: state.reshape((1, *state.shape))})
choice = np.argmax(Qs)
action = possible_actions[int(choice)]
return action, explore_probability
def createnetwork():
global DQNetwork
global state_size
global action_size
global learning_rate
tf.reset_default_graph()
DQNetwork = dqn2.DQNetwork(state_size, action_size, learning_rate)
def preprocess_frame(frame):
cropped_frame = frame[30:-10, 30: -30]
normalized_frame = cropped_frame/255.0
preprocessed_frame = transform.resize(normalized_frame, [84, 84])
return preprocessed_frame
def stack_frames(frames2stack, state, is_new_episode):
frame = preprocess_frame(state)
if is_new_episode:
# Clear the stacked frames
frames2stack = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
# this is new episode so copy the first and only frame 4 times
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
frames2stack.append(frame)
# stack the frames
stacked_state = np.stack(frames2stack, axis=2)
else:
# Append frame to deque
frames2stack.append(frame)
stacked_state = np.stack(frames2stack, axis=2)
return stacked_state, frames2stack
def create_environment():
global game
global state_size
global action_size
game = DoomGame()
game.load_config("basic.cfg")
game.set_doom_scenario_path("basic.wad")
game.init()
state_size = [84, 84, 4] # 4 Frames at 84x84 resolution
# Possible actions
left = [1, 0, 0]
right = [0, 1, 0]
shoot = [0, 0, 1]
possible_actions = [left, right, shoot]
action_size = 3
return game, possible_actions
def test_environment():
global game
episodes = 10
for i in range(episodes):
game.new_episode()
while not game.is_episode_finished():
state = game.get_state()
img = state.screen_buffer
misc = state.game_variables
action = random.choice(possible_actions)
print("Taking action: {}".format(action))
reward = game.make_action(action)
print("Reward for above action: {}".format(reward))
time.sleep(.2)
print("Episode final reward score: {}".format(game.get_total_reward()))
time.sleep(2)
game.close()
if not args['model']:
stacked_frames = deque([np.zeros((84, 84), dtype=np.int) for i in range(stack_size)], maxlen=4)
game, possible_actions = create_environment()
print("Game Environment created")
createnetwork()
print("network created")
memory = mem.Memory(max_size=memory_size)
game.new_episode()
for i in range(pretrain_length):
if i is 0:
state = game.get_state().screen_buffer
state, stacked_frames = stack_frames(stacked_frames, state, True)
# Take a random action
action = random.choice(possible_actions)
# rewards
reward = game.make_action(action)
done = | random_line_split |
|
dataset3.js | 418531', y: '3.17806176', label: 'C1' },
{ x: '4.28296762', y: '9.39110461', label: 'C2' },
{ x: '0.54567095', y: '1.74704601', label: 'C2' },
{ x: '6.47297586', y: '80.0737218', label: 'C2' },
{ x: '3.56196783', y: '3.46501229', label: 'C1' },
{ x: '4.92110965', y: '3.21782503', label: 'C1' },
{ x: '7.08960234', y: '3.31001019', label: 'C1' },
{ x: '6.6400647', y: '11.4021873', label: 'C2' },
{ x: '3.04376354', y: '3.11156957', label: 'C1' },
{ x: '3.29279458', y: '3.20280598', label: 'C1' },
{ x: '11.1281167', y: '3.35227009', label: 'C1' },
{ x: '0.62532426', y: '2.6768092', label: 'C1' },
{ x: '14.1219825', y: '3.47557778', label: 'C1' },
{ x: '5.97399823', y: '7.92169457', label: 'C2' },
{ x: '11.4297922', y: '21.5417738', label: 'C2' },
{ x: '14.5248268', y: '27.7087372', label: 'C2' },
{ x: '3.09732353', y: '3.26640523', label: 'C1' },
{ x: '9.90401929', y: '62.2373692', label: 'C2' },
{ x: '8.49818415', y: '69.0314842', label: 'C2' },
{ x: '4.60844752', y: '3.15543562', label: 'C1' },
{ x: '14.7514267', y: '3.45141488', label: 'C1' },
{ x: '10.5700858', y: '3.42392187', label: 'C1' },
{ x: '11.8527787', y: '3.38192599', label: 'C1' }, | { x: '4.06277657', y: '3.30054593', label: 'C1' },
{ x: '10.1004059', y: '73.8328052', label: 'C2' },
{ x: '11.9150365', y: '3.37543243', label: 'C1' },
{ x: '2.67113254', y: '5.12725717', label: 'C2' },
{ x: '9.21185949', y: '14.5993617', label: 'C2' },
{ x: '2.59559923', y: '5.1530681', label: 'C2' },
{ x: '11.2512589', y: '34.1527354', label: 'C2' },
{ x: '3.46217231', y: '4.64449256', label: 'C2' },
{ x: '10.1713614', y: '287.740405', label: 'C2' },
{ x: '12.7060762', y: '18.9983532', label: 'C2' },
{ x: '0.24033326', y: '2.65936106', label: 'C1' },
{ x: '7.21594897', y: '3.2822869', label: 'C1' },
{ x: '11.1487167', y: '16.5251589', label: 'C2' },
{ x: '11.31077', y: '36.740755', label: 'C2' },
{ x: '8.7980285', y: '150.739092', label: 'C2' },
{ x: '12.3128452', y: '3.46424609', label: 'C1' },
{ x: '14.3563646', y: '27.2356295', label: 'C2' },
{ x: '7.55607776', y: '3.27713683', label: 'C1' },
{ x: '1.16779077', y: '2.59038073', label: 'C1' },
{ x: '1.15726188', y: '2.18638168', label: 'C2' },
{ x: '4.74303415', y: '3.28008028', label: 'C1' },
{ x: '6.85750908', y: '11.8555794', label: 'C2' },
{ x: '4.57319864', y: '3.14574577', label: 'C1' },
{ x: '10.458388', y: '3.45509926', label: 'C1' },
{ x: '7.18939787', y: '3.35470766', label: 'C1' },
{ x: '7.59407331', y: '14.5317836', label: 'C2' },
{ x: '1.32847072', y: '2.86762537', label: 'C2' },
{ x: '4.82451857', y: '3.23219081', label: 'C1' },
{ x: '11.2828455', y: '58.5434514', label: ' | { x: '0.51454207', y: '2.55030179', label: 'C1' },
{ x: '0.1780755', y: '1.52949356', label: 'C2' },
{ x: '0.76631977', y: '2.5589982', label: 'C1' },
{ x: '14.2249825', y: '19.6862421', label: 'C2' }, | random_line_split |
covid19co_pipe.py | -Social/Casos-positivos-de-COVID-19-en-Colombia/gt2j-8ykr)
#
# The number of new cases are increasing day by day around the world.
# This dataset has information about reported cases from 32 Colombia departments.
#
# Also you can get the dataset Google COVID-19 Community Mobility Reports - Colombia.
#
# You can view and collaborate to the analysis here:
# [colombia_covid_19_analysis](https://www.kaggle.com/sebaxtian/colombia-covid-19-analysis) Kaggle Notebook Kernel.
# %% [markdown]
# ---
# %% [markdown]
# ## Data Sources
# %%
# Input data files are available in the "../input/" directory.
INPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
INPUT_DIR = '../input'
# Output data files are available in the "../output/" directory.
OUTPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
OUTPUT_DIR = '../output'
# Official Daily Report Until Now
URL_OFFICIAL_DATASET = 'https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv?accessType=DOWNLOAD'
# Official Daily Samples Processed
URL_SAMPLES_PROCESSED = 'https://www.datos.gov.co/api/views/8835-5baf/rows.csv?accessType=DOWNLOAD'
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Daily Report
# %%
# Official Daily Report Until Now
with requests.get(URL_OFFICIAL_DATASET) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Daily Report
covid19co = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_official.csv'))
# Total Daily Report
covid19co.shape
# %%
# Show dataframe
covid19co.tail()
# %%
# Show attributes
list(covid19co.columns.values)
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co.columns = [unidecode.unidecode(value).upper() for value in covid19co.columns]
# Show dataframe
covid19co.head()
| covid19co[attr] = covid19co[attr].transform(lambda value: str(value).title())
# Show dataframe
covid19co.head()
# %%
# Fill NaN Values
if covid19co.isna().sum().sum() > 0:
covid19co.fillna(value='-', inplace=True)
# Show dataframe
covid19co.head()
# %%
# Setup Date Format
def setup_date(value):
try:
value = value.split('T')[0].split('-')
if len(value) == 3:
value = value[2] + '/' + value[1] + '/' + value[0]
else:
value = '-'
except IndexError:
value = '-'
if len(value) != 10 and len(value) != 1:
value = '-'
return value
# Date Columns
date_columns = list(filter(lambda value: value.find('FECHA') != -1 or value.find('FIS') != -1, covid19co.columns))
# For each date column
for date_column in date_columns:
covid19co[date_column] = covid19co[date_column].transform(lambda value: setup_date(value))
# Show dataframe
covid19co.head()
# %%
# Add Day, Month, Year, Month Name and Day Name for each Date
# Spanish
nombre_mes = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']
nombre_dia = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
# Get day
def get_day(value):
if value not in '-':
return value.split('/')[0]
return value
# Get month
def get_month(value):
if value not in '-':
return value.split('/')[1]
return value
# Get year
def get_year(value):
if value not in '-':
return value.split('/')[2]
return value
# Get month name
def get_month_name(value):
if value not in '-':
return nombre_mes[int(value.split('/')[1]) - 1]
return value
# Get weekday
def get_weekday(value):
if value not in '-':
return nombre_dia[datetime.date(int(value.split('/')[2]), int(value.split('/')[1]), int(value.split('/')[0])).weekday()]
return value
# For each date column
for date_column in date_columns:
covid19co[date_column + ' DIA'] = covid19co[date_column].transform(lambda value: get_day(value))
covid19co[date_column + ' MES'] = covid19co[date_column].transform(lambda value: get_month(value))
covid19co[date_column + ' ANIO'] = covid19co[date_column].transform(lambda value: get_year(value))
covid19co[date_column + ' NOMBRE MES'] = covid19co[date_column].transform(lambda value: get_month_name(value))
covid19co[date_column + ' DIA SEMANA'] = covid19co[date_column].transform(lambda value: get_weekday(value))
# Show dataframe
covid19co.head()
# %% [markdown]
# ## Covid19 Colombia Dataset
# > ***Output file***: covid19co.csv
# %%
# Save dataframe
covid19co.to_csv(os.path.join(OUTPUT_DIR, 'covid19co.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Samples Processed
# %%
# Official Samples Processed Until Now
with requests.get(URL_SAMPLES_PROCESSED) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Samples Processed
covid19co_samples_processed = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'))
# Total Daily Report
covid19co_samples_processed.shape
# %%
# Show dataframe
covid19co_samples_processed.head()
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co_samples_processed.columns = [unidecode.unidecode(value).upper() for value in covid19co_samples_processed.columns]
# Show dataframe
covid19co_samples_processed.head()
# %%
# Setup Date Format
covid19co_samples_processed['FECHA'] = covid19co_samples_processed['FECHA'].transform(lambda value: setup_date(value))
# Show dataframe
covid19co_samples_processed.head()
# %%
# Select Columns
covid19co_samples_processed = covid19co_samples_processed[['FECHA', 'ACUMULADAS']]
# Show dataframe
covid19co_samples_processed.tail()
# %% [markdown]
# ## Covid19 Colombia Samples Processed Dataset
# > ***Output file***: covid19co_samples_processed.csv
# %%
# Save dataframe
covid19co_samples_processed.to_csv(os.path.join(OUTPUT_DIR, 'covid19co_samples_processed.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Google Community Mobility Reports - Colombia
# %%
# Open Official Google Community Mobility - Colombia
google_community_mobility_reports = pd.read_csv(os.path.join(OUTPUT_DIR, 'google_community_mobility_reports.csv'))
# Total Google Community Mobility - Colombia
google_community_mobility_reports.shape
# %%
# Show dataframe
google_community_mobility_reports.tail()
# %%
# Update Google Community Mobility Reports - Colombia
date_last_report = google_community_mobility_reports['date'].values[-1]
#print(date_last_report)
# 13/05/2020
date_last_report = date_last_report.split('/')
date_last_report = date_last_report[2] + '-' + date_last_report[1] + '-' + date_last_report[0]
#print(date_last_report)
# 2020-05-13
new_reports = pd.DataFrame(columns=['date', 'country', 'file', 'url'])
new_reports['date'] = [dti.strftime('%Y-%m-%d') for dti in pd.date_range(start=date_last_report, end=datetime.date.today().isoformat(), freq='D')]
new_reports['country'] = 'Colombia'
new_reports['file'] = [date + '_CO_Mobility_Report_en.pdf' for date in new_reports['date'].values]
# Get URL report
def get_report_url(file):
with requests.get('https://www.gstatic.com/covid19/mobility/' + file) as community_mobility_report:
if community_mobility_report.status_code == 200:
return community_mobility_report.url
else:
return np.nan
# Get URL |
# %%
# Update texto to title text format
for attr in covid19co.columns:
if covid19co[attr].dtypes == 'object': | random_line_split |
covid19co_pipe.py | and collaborate to the analysis here:
# [colombia_covid_19_analysis](https://www.kaggle.com/sebaxtian/colombia-covid-19-analysis) Kaggle Notebook Kernel.
# %% [markdown]
# ---
# %% [markdown]
# ## Data Sources
# %%
# Input data files are available in the "../input/" directory.
INPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
INPUT_DIR = '../input'
# Output data files are available in the "../output/" directory.
OUTPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
OUTPUT_DIR = '../output'
# Official Daily Report Until Now
URL_OFFICIAL_DATASET = 'https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv?accessType=DOWNLOAD'
# Official Daily Samples Processed
URL_SAMPLES_PROCESSED = 'https://www.datos.gov.co/api/views/8835-5baf/rows.csv?accessType=DOWNLOAD'
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Daily Report
# %%
# Official Daily Report Until Now
with requests.get(URL_OFFICIAL_DATASET) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Daily Report
covid19co = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_official.csv'))
# Total Daily Report
covid19co.shape
# %%
# Show dataframe
covid19co.tail()
# %%
# Show attributes
list(covid19co.columns.values)
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co.columns = [unidecode.unidecode(value).upper() for value in covid19co.columns]
# Show dataframe
covid19co.head()
# %%
# Update texto to title text format
for attr in covid19co.columns:
if covid19co[attr].dtypes == 'object':
covid19co[attr] = covid19co[attr].transform(lambda value: str(value).title())
# Show dataframe
covid19co.head()
# %%
# Fill NaN Values
if covid19co.isna().sum().sum() > 0:
covid19co.fillna(value='-', inplace=True)
# Show dataframe
covid19co.head()
# %%
# Setup Date Format
def setup_date(value):
try:
value = value.split('T')[0].split('-')
if len(value) == 3:
value = value[2] + '/' + value[1] + '/' + value[0]
else:
value = '-'
except IndexError:
value = '-'
if len(value) != 10 and len(value) != 1:
value = '-'
return value
# Date Columns
date_columns = list(filter(lambda value: value.find('FECHA') != -1 or value.find('FIS') != -1, covid19co.columns))
# For each date column
for date_column in date_columns:
covid19co[date_column] = covid19co[date_column].transform(lambda value: setup_date(value))
# Show dataframe
covid19co.head()
# %%
# Add Day, Month, Year, Month Name and Day Name for each Date
# Spanish
nombre_mes = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']
nombre_dia = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
# Get day
def get_day(value):
if value not in '-':
return value.split('/')[0]
return value
# Get month
def get_month(value):
if value not in '-':
return value.split('/')[1]
return value
# Get year
def get_year(value):
if value not in '-':
return value.split('/')[2]
return value
# Get month name
def get_month_name(value):
if value not in '-':
return nombre_mes[int(value.split('/')[1]) - 1]
return value
# Get weekday
def get_weekday(value):
if value not in '-':
return nombre_dia[datetime.date(int(value.split('/')[2]), int(value.split('/')[1]), int(value.split('/')[0])).weekday()]
return value
# For each date column
for date_column in date_columns:
covid19co[date_column + ' DIA'] = covid19co[date_column].transform(lambda value: get_day(value))
covid19co[date_column + ' MES'] = covid19co[date_column].transform(lambda value: get_month(value))
covid19co[date_column + ' ANIO'] = covid19co[date_column].transform(lambda value: get_year(value))
covid19co[date_column + ' NOMBRE MES'] = covid19co[date_column].transform(lambda value: get_month_name(value))
covid19co[date_column + ' DIA SEMANA'] = covid19co[date_column].transform(lambda value: get_weekday(value))
# Show dataframe
covid19co.head()
# %% [markdown]
# ## Covid19 Colombia Dataset
# > ***Output file***: covid19co.csv
# %%
# Save dataframe
covid19co.to_csv(os.path.join(OUTPUT_DIR, 'covid19co.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Samples Processed
# %%
# Official Samples Processed Until Now
with requests.get(URL_SAMPLES_PROCESSED) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Samples Processed
covid19co_samples_processed = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'))
# Total Daily Report
covid19co_samples_processed.shape
# %%
# Show dataframe
covid19co_samples_processed.head()
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co_samples_processed.columns = [unidecode.unidecode(value).upper() for value in covid19co_samples_processed.columns]
# Show dataframe
covid19co_samples_processed.head()
# %%
# Setup Date Format
covid19co_samples_processed['FECHA'] = covid19co_samples_processed['FECHA'].transform(lambda value: setup_date(value))
# Show dataframe
covid19co_samples_processed.head()
# %%
# Select Columns
covid19co_samples_processed = covid19co_samples_processed[['FECHA', 'ACUMULADAS']]
# Show dataframe
covid19co_samples_processed.tail()
# %% [markdown]
# ## Covid19 Colombia Samples Processed Dataset
# > ***Output file***: covid19co_samples_processed.csv
# %%
# Save dataframe
covid19co_samples_processed.to_csv(os.path.join(OUTPUT_DIR, 'covid19co_samples_processed.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Google Community Mobility Reports - Colombia
# %%
# Open Official Google Community Mobility - Colombia
google_community_mobility_reports = pd.read_csv(os.path.join(OUTPUT_DIR, 'google_community_mobility_reports.csv'))
# Total Google Community Mobility - Colombia
google_community_mobility_reports.shape
# %%
# Show dataframe
google_community_mobility_reports.tail()
# %%
# Update Google Community Mobility Reports - Colombia
date_last_report = google_community_mobility_reports['date'].values[-1]
#print(date_last_report)
# 13/05/2020
date_last_report = date_last_report.split('/')
date_last_report = date_last_report[2] + '-' + date_last_report[1] + '-' + date_last_report[0]
#print(date_last_report)
# 2020-05-13
new_reports = pd.DataFrame(columns=['date', 'country', 'file', 'url'])
new_reports['date'] = [dti.strftime('%Y-%m-%d') for dti in pd.date_range(start=date_last_report, end=datetime.date.today().isoformat(), freq='D')]
new_reports['country'] = 'Colombia'
new_reports['file'] = [date + '_CO_Mobility_Report_en.pdf' for date in new_reports['date'].values]
# Get URL report
def get_report_url(file):
with requests.get('https://www.gstatic.com/covid19/mobility/' + file) as community_mobility_report:
if community_mobility_report.status_code == 200:
return community_mobility_report.url
else:
return np.nan
# Get URL report
new_reports['url'] = new_reports['file'].transform(lambda value: get_report_url(value))
# Drop any report without URL
new_reports.dropna(inplace=True)
# Reset index
new_reports.reset_index(inplace=True, drop=True)
# Only new reports
new_reports = new_reports.iloc[1:]
# Show dataframe
new_reports.head()
# %%
# Get/Add Mobility Changes
def ge | t_mobility_changes(U | identifier_name |
|
covid19co_pipe.py | ocial/Casos-positivos-de-COVID-19-en-Colombia/gt2j-8ykr)
#
# The number of new cases are increasing day by day around the world.
# This dataset has information about reported cases from 32 Colombia departments.
#
# Also you can get the dataset Google COVID-19 Community Mobility Reports - Colombia.
#
# You can view and collaborate to the analysis here:
# [colombia_covid_19_analysis](https://www.kaggle.com/sebaxtian/colombia-covid-19-analysis) Kaggle Notebook Kernel.
# %% [markdown]
# ---
# %% [markdown]
# ## Data Sources
# %%
# Input data files are available in the "../input/" directory.
INPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
INPUT_DIR = '../input'
# Output data files are available in the "../output/" directory.
OUTPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
OUTPUT_DIR = '../output'
# Official Daily Report Until Now
URL_OFFICIAL_DATASET = 'https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv?accessType=DOWNLOAD'
# Official Daily Samples Processed
URL_SAMPLES_PROCESSED = 'https://www.datos.gov.co/api/views/8835-5baf/rows.csv?accessType=DOWNLOAD'
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Daily Report
# %%
# Official Daily Report Until Now
with requests.get(URL_OFFICIAL_DATASET) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Daily Report
covid19co = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_official.csv'))
# Total Daily Report
covid19co.shape
# %%
# Show dataframe
covid19co.tail()
# %%
# Show attributes
list(covid19co.columns.values)
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co.columns = [unidecode.unidecode(value).upper() for value in covid19co.columns]
# Show dataframe
covid19co.head()
# %%
# Update texto to title text format
for attr in covid19co.columns:
if covid19co[attr].dtypes == 'object':
covid19co[attr] = covid19co[attr].transform(lambda value: str(value).title())
# Show dataframe
covid19co.head()
# %%
# Fill NaN Values
if covid19co.isna().sum().sum() > 0:
covid19co.fillna(value='-', inplace=True)
# Show dataframe
covid19co.head()
# %%
# Setup Date Format
def setup_date(value):
try:
value = value.split('T')[0].split('-')
if len(value) == 3:
value = value[2] + '/' + value[1] + '/' + value[0]
else:
value = '-'
except IndexError:
value = '-'
if len(value) != 10 and len(value) != 1:
value = '-'
return value
# Date Columns
date_columns = list(filter(lambda value: value.find('FECHA') != -1 or value.find('FIS') != -1, covid19co.columns))
# For each date column
for date_column in date_columns:
covid19co[date_column] = covid19co[date_column].transform(lambda value: setup_date(value))
# Show dataframe
covid19co.head()
# %%
# Add Day, Month, Year, Month Name and Day Name for each Date
# Spanish
nombre_mes = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']
nombre_dia = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
# Get day
def get_day(value):
if value not in '-':
return value.split('/')[0]
return value
# Get month
def get_month(value):
if value not in '-':
return value.split('/')[1]
return value
# Get year
def get_year(value):
if value not in '-':
return value.split('/')[2]
return value
# Get month name
def get_month_name(value):
if value not in '-':
return nombre_mes[int(value.split('/')[1]) - 1]
return value
# Get weekday
def get_weekday(value):
if value not in '-':
return nombre_dia[datetime.date(int(value.split('/')[2]), int(value.split('/')[1]), int(value.split('/')[0])).weekday()]
return value
# For each date column
for date_column in date_columns:
covid19co[date_column + ' DIA'] = covid19co[date_column].transform(lambda value: get_day(value))
covid19co[date_column + ' MES'] = covid19co[date_column].transform(lambda value: get_month(value))
covid19co[date_column + ' ANIO'] = covid19co[date_column].transform(lambda value: get_year(value))
covid19co[date_column + ' NOMBRE MES'] = covid19co[date_column].transform(lambda value: get_month_name(value))
covid19co[date_column + ' DIA SEMANA'] = covid19co[date_column].transform(lambda value: get_weekday(value))
# Show dataframe
covid19co.head()
# %% [markdown]
# ## Covid19 Colombia Dataset
# > ***Output file***: covid19co.csv
# %%
# Save dataframe
covid19co.to_csv(os.path.join(OUTPUT_DIR, 'covid19co.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Samples Processed
# %%
# Official Samples Processed Until Now
with requests.get(URL_SAMPLES_PROCESSED) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Samples Processed
covid19co_samples_processed = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'))
# Total Daily Report
covid19co_samples_processed.shape
# %%
# Show dataframe
covid19co_samples_processed.head()
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co_samples_processed.columns = [unidecode.unidecode(value).upper() for value in covid19co_samples_processed.columns]
# Show dataframe
covid19co_samples_processed.head()
# %%
# Setup Date Format
covid19co_samples_processed['FECHA'] = covid19co_samples_processed['FECHA'].transform(lambda value: setup_date(value))
# Show dataframe
covid19co_samples_processed.head()
# %%
# Select Columns
covid19co_samples_processed = covid19co_samples_processed[['FECHA', 'ACUMULADAS']]
# Show dataframe
covid19co_samples_processed.tail()
# %% [markdown]
# ## Covid19 Colombia Samples Processed Dataset
# > ***Output file***: covid19co_samples_processed.csv
# %%
# Save dataframe
covid19co_samples_processed.to_csv(os.path.join(OUTPUT_DIR, 'covid19co_samples_processed.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Google Community Mobility Reports - Colombia
# %%
# Open Official Google Community Mobility - Colombia
google_community_mobility_reports = pd.read_csv(os.path.join(OUTPUT_DIR, 'google_community_mobility_reports.csv'))
# Total Google Community Mobility - Colombia
google_community_mobility_reports.shape
# %%
# Show dataframe
google_community_mobility_reports.tail()
# %%
# Update Google Community Mobility Reports - Colombia
date_last_report = google_community_mobility_reports['date'].values[-1]
#print(date_last_report)
# 13/05/2020
date_last_report = date_last_report.split('/')
date_last_report = date_last_report[2] + '-' + date_last_report[1] + '-' + date_last_report[0]
#print(date_last_report)
# 2020-05-13
new_reports = pd.DataFrame(columns=['date', 'country', 'file', 'url'])
new_reports['date'] = [dti.strftime('%Y-%m-%d') for dti in pd.date_range(start=date_last_report, end=datetime.date.today().isoformat(), freq='D')]
new_reports['country'] = 'Colombia'
new_reports['file'] = [date + '_CO_Mobility_Report_en.pdf' for date in new_reports['date'].values]
# Get URL report
def get_report_url(file):
wi | Get URL report | th requests.get('https://www.gstatic.com/covid19/mobility/' + file) as community_mobility_report:
if community_mobility_report.status_code == 200:
return community_mobility_report.url
else:
return np.nan
# | identifier_body |
covid19co_pipe.py | ocial/Casos-positivos-de-COVID-19-en-Colombia/gt2j-8ykr)
#
# The number of new cases are increasing day by day around the world.
# This dataset has information about reported cases from 32 Colombia departments.
#
# Also you can get the dataset Google COVID-19 Community Mobility Reports - Colombia.
#
# You can view and collaborate to the analysis here:
# [colombia_covid_19_analysis](https://www.kaggle.com/sebaxtian/colombia-covid-19-analysis) Kaggle Notebook Kernel.
# %% [markdown]
# ---
# %% [markdown]
# ## Data Sources
# %%
# Input data files are available in the "../input/" directory.
INPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
INPUT_DIR = '../input'
# Output data files are available in the "../output/" directory.
OUTPUT_DIR = './'
if os.path.split(os.path.abspath('.'))[-1] == 'src':
OUTPUT_DIR = '../output'
# Official Daily Report Until Now
URL_OFFICIAL_DATASET = 'https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv?accessType=DOWNLOAD'
# Official Daily Samples Processed
URL_SAMPLES_PROCESSED = 'https://www.datos.gov.co/api/views/8835-5baf/rows.csv?accessType=DOWNLOAD'
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Daily Report
# %%
# Official Daily Report Until Now
with requests.get(URL_OFFICIAL_DATASET) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Daily Report
covid19co = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_official.csv'))
# Total Daily Report
covid19co.shape
# %%
# Show dataframe
covid19co.tail()
# %%
# Show attributes
list(covid19co.columns.values)
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co.columns = [unidecode.unidecode(value).upper() for value in covid19co.columns]
# Show dataframe
covid19co.head()
# %%
# Update texto to title text format
for attr in covid19co.columns:
if covid19co[attr].dtypes == 'object':
covid19co[attr] = covid19co[attr].transform(lambda value: str(value).title())
# Show dataframe
covid19co.head()
# %%
# Fill NaN Values
if covid19co.isna().sum().sum() > 0:
covid19co.fillna(value='-', inplace=True)
# Show dataframe
covid19co.head()
# %%
# Setup Date Format
def setup_date(value):
try:
value = value.split('T')[0].split('-')
if len(value) == 3:
|
else:
value = '-'
except IndexError:
value = '-'
if len(value) != 10 and len(value) != 1:
value = '-'
return value
# Date Columns
date_columns = list(filter(lambda value: value.find('FECHA') != -1 or value.find('FIS') != -1, covid19co.columns))
# For each date column
for date_column in date_columns:
covid19co[date_column] = covid19co[date_column].transform(lambda value: setup_date(value))
# Show dataframe
covid19co.head()
# %%
# Add Day, Month, Year, Month Name and Day Name for each Date
# Spanish
nombre_mes = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']
nombre_dia = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo']
# Get day
def get_day(value):
if value not in '-':
return value.split('/')[0]
return value
# Get month
def get_month(value):
if value not in '-':
return value.split('/')[1]
return value
# Get year
def get_year(value):
if value not in '-':
return value.split('/')[2]
return value
# Get month name
def get_month_name(value):
if value not in '-':
return nombre_mes[int(value.split('/')[1]) - 1]
return value
# Get weekday
def get_weekday(value):
if value not in '-':
return nombre_dia[datetime.date(int(value.split('/')[2]), int(value.split('/')[1]), int(value.split('/')[0])).weekday()]
return value
# For each date column
for date_column in date_columns:
covid19co[date_column + ' DIA'] = covid19co[date_column].transform(lambda value: get_day(value))
covid19co[date_column + ' MES'] = covid19co[date_column].transform(lambda value: get_month(value))
covid19co[date_column + ' ANIO'] = covid19co[date_column].transform(lambda value: get_year(value))
covid19co[date_column + ' NOMBRE MES'] = covid19co[date_column].transform(lambda value: get_month_name(value))
covid19co[date_column + ' DIA SEMANA'] = covid19co[date_column].transform(lambda value: get_weekday(value))
# Show dataframe
covid19co.head()
# %% [markdown]
# ## Covid19 Colombia Dataset
# > ***Output file***: covid19co.csv
# %%
# Save dataframe
covid19co.to_csv(os.path.join(OUTPUT_DIR, 'covid19co.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Official Covid19 Colombia Samples Processed
# %%
# Official Samples Processed Until Now
with requests.get(URL_SAMPLES_PROCESSED) as official_dataset:
with open(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'), 'wb') as dataset_file:
dataset_file.write(official_dataset.content)
# %%
# Open Official Samples Processed
covid19co_samples_processed = pd.read_csv(os.path.join(INPUT_DIR, 'covid19co_samples_processed_official.csv'))
# Total Daily Report
covid19co_samples_processed.shape
# %%
# Show dataframe
covid19co_samples_processed.head()
# %%
# Update Name Columns
# Remove Accents and Uppercase
covid19co_samples_processed.columns = [unidecode.unidecode(value).upper() for value in covid19co_samples_processed.columns]
# Show dataframe
covid19co_samples_processed.head()
# %%
# Setup Date Format
covid19co_samples_processed['FECHA'] = covid19co_samples_processed['FECHA'].transform(lambda value: setup_date(value))
# Show dataframe
covid19co_samples_processed.head()
# %%
# Select Columns
covid19co_samples_processed = covid19co_samples_processed[['FECHA', 'ACUMULADAS']]
# Show dataframe
covid19co_samples_processed.tail()
# %% [markdown]
# ## Covid19 Colombia Samples Processed Dataset
# > ***Output file***: covid19co_samples_processed.csv
# %%
# Save dataframe
covid19co_samples_processed.to_csv(os.path.join(OUTPUT_DIR, 'covid19co_samples_processed.csv'), index=False)
# %% [markdown]
# ---
# %% [markdown]
# ## Google Community Mobility Reports - Colombia
# %%
# Open Official Google Community Mobility - Colombia
google_community_mobility_reports = pd.read_csv(os.path.join(OUTPUT_DIR, 'google_community_mobility_reports.csv'))
# Total Google Community Mobility - Colombia
google_community_mobility_reports.shape
# %%
# Show dataframe
google_community_mobility_reports.tail()
# %%
# Update Google Community Mobility Reports - Colombia
date_last_report = google_community_mobility_reports['date'].values[-1]
#print(date_last_report)
# 13/05/2020
date_last_report = date_last_report.split('/')
date_last_report = date_last_report[2] + '-' + date_last_report[1] + '-' + date_last_report[0]
#print(date_last_report)
# 2020-05-13
new_reports = pd.DataFrame(columns=['date', 'country', 'file', 'url'])
new_reports['date'] = [dti.strftime('%Y-%m-%d') for dti in pd.date_range(start=date_last_report, end=datetime.date.today().isoformat(), freq='D')]
new_reports['country'] = 'Colombia'
new_reports['file'] = [date + '_CO_Mobility_Report_en.pdf' for date in new_reports['date'].values]
# Get URL report
def get_report_url(file):
with requests.get('https://www.gstatic.com/covid19/mobility/' + file) as community_mobility_report:
if community_mobility_report.status_code == 200:
return community_mobility_report.url
else:
return np.nan
# Get URL report | value = value[2] + '/' + value[1] + '/' + value[0] | conditional_block |
peermanager.go | .conf.NPAddPeers {
// go-multiaddr implementation does not support recent p2p protocol yet, but deprecated name ipfs.
// This adhoc will be removed when go-multiaddr is patched.
target = strings.Replace(target, "/p2p/", "/ipfs/", 1)
targetAddr, err := ma.NewMultiaddr(target)
if err != nil {
pm.logger.Warn().Err(err).Str("target", target).Msg("invalid NPAddPeer address")
continue
}
splitted := strings.Split(targetAddr.String(), "/")
if len(splitted) != 7 {
pm.logger.Warn().Str("target", target).Msg("invalid NPAddPeer address")
continue
}
peerAddrString := splitted[2]
peerPortString := splitted[4]
peerPort, err := strconv.Atoi(peerPortString)
if err != nil {
pm.logger.Warn().Str("port", peerPortString).Msg("invalid Peer port")
continue
}
peerIDString := splitted[6]
peerID, err := peer.IDB58Decode(peerIDString)
if err != nil {
pm.logger.Warn().Str(LogPeerID, peerIDString).Msg("invalid PeerID")
continue
}
peerMeta := PeerMeta{
ID: peerID,
Port: uint32(peerPort),
IPAddress: peerAddrString,
Designated: true,
Outbound: true,
}
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Str("addr", peerAddrString).Int("port", peerPort).Msg("Adding Designated peer")
pm.designatedPeers[peerID] = peerMeta
}
}
func (pm *peerManager) runManagePeers() {
addrDuration := time.Minute * 3
addrTicker := time.NewTicker(addrDuration)
// reconnectRunners := make(map[peer.ID]*reconnectRunner)
MANLOOP:
for {
select {
case meta := <-pm.addPeerChannel:
if pm.addOutboundPeer(meta) {
if _, found := pm.designatedPeers[meta.ID]; found {
pm.rm.CancelJob(meta.ID)
}
}
case id := <-pm.removePeerChannel:
if pm.removePeer(id) {
if meta, found := pm.designatedPeers[id]; found {
pm.rm.AddJob(meta)
}
}
case <-addrTicker.C:
pm.checkAndCollectPeerListFromAll()
pm.logPeerMetrics()
case peerMetas := <-pm.fillPoolChannel:
pm.tryFillPool(&peerMetas)
case <-pm.finishChannel:
addrTicker.Stop()
pm.rm.Stop()
// TODO need to keep loop till all remote peer objects are removed, otherwise panic or channel deadlock can come.
break MANLOOP
}
}
// cleanup peers
for peerID := range pm.remotePeers {
pm.removePeer(peerID)
}
}
func (pm *peerManager) logPeerMetrics() {
if pm.logger.IsDebugEnabled() {
pm.logger.Debug().Msg(pm.mm.Summary())
}
}
// addOutboundPeer try to connect and handshake to remote peer. it can be called after peermanager is inited.
// It return true if peer is added or already exist, or return false if failed to add peer.
func (pm *peerManager) addOutboundPeer(meta PeerMeta) bool {
addrString := fmt.Sprintf("/ip4/%s/tcp/%d", meta.IPAddress, meta.Port)
var peerAddr, err = ma.NewMultiaddr(addrString)
if err != nil {
pm.logger.Warn().Err(err).Str("addr", addrString).Msg("invalid NPAddPeer address")
return false
}
var peerID = meta.ID
pm.mutex.Lock()
inboundPeer, ok := pm.remotePeers[peerID]
if ok {
// peer is already exist (and maybe inbound peer)
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Peer is already managed by peermanager")
if meta.Designated {
// If remote peer was connected first. designated flag is not set yet.
inboundPeer.meta.Designated = true
}
pm.mutex.Unlock()
return true
}
pm.mutex.Unlock()
pm.Peerstore().AddAddr(peerID, peerAddr, meta.TTL())
ctx := context.Background()
s, err := pm.NewStream(ctx, meta.ID, aergoP2PSub)
if err != nil {
pm.logger.Info().Err(err).Str("addr", addrString).Str(LogPeerID, meta.ID.Pretty()).Str(LogProtoID, string(aergoP2PSub)).Msg("Error while get stream")
return false
}
rd := metric.NewReader(s)
wt := metric.NewWriter(s)
h := newHandshaker(pm, pm.actorServ, pm.logger, peerID)
rw, remoteStatus, err := h.handshakeOutboundPeerTimeout(rd, wt, defaultHandshakeTTL)
if err != nil {
pm.logger.Debug().Err(err).Str(LogPeerID, meta.ID.Pretty()).Msg("Failed to handshake")
//pm.sendGoAway(rw, "Failed to handshake")
s.Close()
return false
}
pm.mutex.Lock()
inboundPeer, ok = pm.remotePeers[peerID]
if ok {
if ComparePeerID(pm.selfMeta.ID, meta.ID) <= 0 {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, and remote peer is higher priority so closing this outbound connection.")
pm.mutex.Unlock()
pm.sendGoAway(rw, "Already handshaked")
s.Close()
return true
} else {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, but local peer is higher priority so closing that inbound connection")
// disconnect lower valued connection
pm.deletePeer(meta.ID)
inboundPeer.stop()
}
}
// update peer info to remote sent infor
meta = FromPeerAddress(remoteStatus.Sender)
outboundPeer := newRemotePeer(meta, pm, pm.actorServ, pm.logger, pm.mf, pm.signer, rw)
// insert Handlers
pm.handlerFactory.insertHandlers(outboundPeer)
go outboundPeer.runPeer()
pm.insertPeer(peerID, outboundPeer)
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Str("addr", net.ParseIP(meta.IPAddress).String()+":"+strconv.Itoa(int(meta.Port))).Msg("Outbound peer is added to peerService")
outboundPeer.metric = pm.mm.Add(peerID, rd, wt)
pm.mutex.Unlock()
addrs := pm.Peerstore().Addrs(peerID)
addrStrs := make([]string, len(addrs))
for i, addr := range addrs {
addrStrs[i] = addr.String()
}
pm.logger.Debug().Strs("addrs", addrStrs).Str(LogPeerID, outboundPeer.meta.ID.Pretty()).Msg("addresses of peer")
// peer is ready
h.doInitialSync()
// notice to p2pmanager that handshaking is finished
pm.NotifyPeerHandshake(peerID)
return true
}
func (pm *peerManager) sendGoAway(rw MsgReadWriter, msg string) {
goMsg := &types.GoAwayNotice{Message: msg}
// TODO code smell. non safe casting.
mo := pm.mf.newMsgRequestOrder(false, GoAway, goMsg).(*pbRequestOrder)
container := mo.message
rw.WriteMsg(container)
}
func (pm *peerManager) checkInPeerstore(peerID peer.ID) bool {
found := false
for _, existingPeerID := range pm.Peerstore().Peers() {
if existingPeerID == peerID {
found = true
break
}
}
return found
}
func (pm *peerManager) AddNewPeer(peer PeerMeta) {
pm.addPeerChannel <- peer
}
func (pm *peerManager) RemovePeer(peerID peer.ID) {
pm.removePeerChannel <- peerID
}
func (pm *peerManager) NotifyPeerHandshake(peerID peer.ID) {
pm.checkAndCollectPeerList(peerID)
}
func (pm *peerManager) NotifyPeerAddressReceived(metas []PeerMeta) {
pm.fillPoolChannel <- metas
}
// removePeer remove and disconnect managed remote peer connection
// It return true if peer is exist and managed by peermanager
func (pm *peerManager) removePeer(peerID peer.ID) bool {
pm.mutex.Lock()
target, ok := pm.remotePeers[peerID]
if !ok {
pm.mutex.Unlock()
return false
}
pm.deletePeer(peerID)
// No internal module access this peer anymore, but remote message can be received.
target.stop()
pm.mutex.Unlock()
// also disconnect connection
for _, existingPeerID := range pm.Peerstore().Peers() {
if existingPeerID == peerID {
for _, listener := range pm.eventListeners {
listener.OnRemovePeer(peerID)
}
pm.Network().ClosePeer(peerID)
return true
}
}
return true
}
func (pm *peerManager) Peerstore() pstore.Peerstore | {
return pm.Host.Peerstore()
} | identifier_body |
|
peermanager.go | }
func (pm *peerManager) SelfMeta() PeerMeta {
return pm.selfMeta
}
func (pm *peerManager) SelfNodeID() peer.ID {
return pm.selfMeta.ID
}
func (pm *peerManager) RegisterEventListener(listener PeerEventListener) {
pm.mutex.Lock()
defer pm.mutex.Unlock()
pm.eventListeners = append(pm.eventListeners, listener)
}
func (pm *peerManager) init() {
// check Key and address
priv := NodePrivKey()
pub := NodePubKey()
pid := NodeID()
pm.privateKey = priv
pm.publicKey = pub
// init address and port
// if not set, it look up ip addresses of machine and choose suitable one (but not so smart) and default port 7845
peerAddr, peerPort := pm.getProtocolAddrs()
pm.selfMeta.IPAddress = peerAddr.String()
pm.selfMeta.Port = uint32(peerPort)
pm.selfMeta.ID = pid
// if bindAddress or bindPort is not set, it will be same as NetProtocolAddr or NetProtocolPort
if len(pm.conf.NPBindAddr) > 0 {
bindAddr := net.ParseIP(pm.conf.NPBindAddr)
if bindAddr == nil {
panic("invalid NPBindAddr " + pm.conf.NPBindAddr)
}
pm.bindAddress = bindAddr
} else {
pm.bindAddress = peerAddr
}
if pm.conf.NPBindPort > 0 {
pm.bindPort = pm.conf.NPBindPort
} else {
pm.bindPort = peerPort
}
// set meta info
// TODO more survey libp2p NAT configuration
// set designated peers
pm.addDesignatedPeers()
}
func (pm *peerManager) getProtocolAddrs() (protocolAddr net.IP, protocolPort int) {
if len(pm.conf.NetProtocolAddr) != 0 {
protocolAddr = net.ParseIP(pm.conf.NetProtocolAddr)
if protocolAddr == nil {
panic("invalid NetProtocolAddr " + pm.conf.NetProtocolAddr)
}
if protocolAddr.IsUnspecified() {
panic("NetProtocolAddr should be a specified IP address, not 0.0.0.0")
}
} else {
extIP, err := externalIP()
if err != nil {
panic("error while finding IP address: " + err.Error())
}
protocolAddr = extIP
}
protocolPort = pm.conf.NetProtocolPort
if protocolPort <= 0 {
panic("invalid NetProtocolPort " + strconv.Itoa(pm.conf.NetProtocolPort))
}
return
}
func (pm *peerManager) run() {
go pm.runManagePeers()
// need to start listen after chainservice is read to init
// FIXME: adhoc code
go func() {
time.Sleep(time.Second * 3)
pm.startListener()
// addition should start after all modules are started
go func() {
time.Sleep(time.Second * 2)
for _, meta := range pm.designatedPeers {
pm.addPeerChannel <- meta
}
}()
}()
}
func (pm *peerManager) addDesignatedPeers() {
// add remote node from config
for _, target := range pm.conf.NPAddPeers {
// go-multiaddr implementation does not support recent p2p protocol yet, but deprecated name ipfs.
// This adhoc will be removed when go-multiaddr is patched.
target = strings.Replace(target, "/p2p/", "/ipfs/", 1)
targetAddr, err := ma.NewMultiaddr(target)
if err != nil {
pm.logger.Warn().Err(err).Str("target", target).Msg("invalid NPAddPeer address")
continue
}
splitted := strings.Split(targetAddr.String(), "/")
if len(splitted) != 7 {
pm.logger.Warn().Str("target", target).Msg("invalid NPAddPeer address")
continue
}
peerAddrString := splitted[2]
peerPortString := splitted[4]
peerPort, err := strconv.Atoi(peerPortString)
if err != nil {
pm.logger.Warn().Str("port", peerPortString).Msg("invalid Peer port")
continue
}
peerIDString := splitted[6]
peerID, err := peer.IDB58Decode(peerIDString)
if err != nil {
pm.logger.Warn().Str(LogPeerID, peerIDString).Msg("invalid PeerID")
continue
}
peerMeta := PeerMeta{
ID: peerID,
Port: uint32(peerPort),
IPAddress: peerAddrString,
Designated: true,
Outbound: true,
}
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Str("addr", peerAddrString).Int("port", peerPort).Msg("Adding Designated peer")
pm.designatedPeers[peerID] = peerMeta
}
}
func (pm *peerManager) runManagePeers() {
addrDuration := time.Minute * 3
addrTicker := time.NewTicker(addrDuration)
// reconnectRunners := make(map[peer.ID]*reconnectRunner)
MANLOOP:
for {
select {
case meta := <-pm.addPeerChannel:
if pm.addOutboundPeer(meta) |
case id := <-pm.removePeerChannel:
if pm.removePeer(id) {
if meta, found := pm.designatedPeers[id]; found {
pm.rm.AddJob(meta)
}
}
case <-addrTicker.C:
pm.checkAndCollectPeerListFromAll()
pm.logPeerMetrics()
case peerMetas := <-pm.fillPoolChannel:
pm.tryFillPool(&peerMetas)
case <-pm.finishChannel:
addrTicker.Stop()
pm.rm.Stop()
// TODO need to keep loop till all remote peer objects are removed, otherwise panic or channel deadlock can come.
break MANLOOP
}
}
// cleanup peers
for peerID := range pm.remotePeers {
pm.removePeer(peerID)
}
}
func (pm *peerManager) logPeerMetrics() {
if pm.logger.IsDebugEnabled() {
pm.logger.Debug().Msg(pm.mm.Summary())
}
}
// addOutboundPeer try to connect and handshake to remote peer. it can be called after peermanager is inited.
// It return true if peer is added or already exist, or return false if failed to add peer.
func (pm *peerManager) addOutboundPeer(meta PeerMeta) bool {
addrString := fmt.Sprintf("/ip4/%s/tcp/%d", meta.IPAddress, meta.Port)
var peerAddr, err = ma.NewMultiaddr(addrString)
if err != nil {
pm.logger.Warn().Err(err).Str("addr", addrString).Msg("invalid NPAddPeer address")
return false
}
var peerID = meta.ID
pm.mutex.Lock()
inboundPeer, ok := pm.remotePeers[peerID]
if ok {
// peer is already exist (and maybe inbound peer)
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Peer is already managed by peermanager")
if meta.Designated {
// If remote peer was connected first. designated flag is not set yet.
inboundPeer.meta.Designated = true
}
pm.mutex.Unlock()
return true
}
pm.mutex.Unlock()
pm.Peerstore().AddAddr(peerID, peerAddr, meta.TTL())
ctx := context.Background()
s, err := pm.NewStream(ctx, meta.ID, aergoP2PSub)
if err != nil {
pm.logger.Info().Err(err).Str("addr", addrString).Str(LogPeerID, meta.ID.Pretty()).Str(LogProtoID, string(aergoP2PSub)).Msg("Error while get stream")
return false
}
rd := metric.NewReader(s)
wt := metric.NewWriter(s)
h := newHandshaker(pm, pm.actorServ, pm.logger, peerID)
rw, remoteStatus, err := h.handshakeOutboundPeerTimeout(rd, wt, defaultHandshakeTTL)
if err != nil {
pm.logger.Debug().Err(err).Str(LogPeerID, meta.ID.Pretty()).Msg("Failed to handshake")
//pm.sendGoAway(rw, "Failed to handshake")
s.Close()
return false
}
pm.mutex.Lock()
inboundPeer, ok = pm.remotePeers[peerID]
if ok {
if ComparePeerID(pm.selfMeta.ID, meta.ID) <= 0 {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, and remote peer is higher priority so closing this outbound connection.")
pm.mutex.Unlock()
pm.sendGoAway(rw, "Already handshaked")
s.Close()
return true
} else {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, but local peer is higher priority so closing that inbound connection")
// disconnect lower valued connection
pm.deletePeer(meta.ID)
inboundPeer.stop()
| {
if _, found := pm.designatedPeers[meta.ID]; found {
pm.rm.CancelJob(meta.ID)
}
} | conditional_block |
peermanager.go | {
// add remote node from config
for _, target := range pm.conf.NPAddPeers {
// go-multiaddr implementation does not support recent p2p protocol yet, but deprecated name ipfs.
// This adhoc will be removed when go-multiaddr is patched.
target = strings.Replace(target, "/p2p/", "/ipfs/", 1)
targetAddr, err := ma.NewMultiaddr(target)
if err != nil {
pm.logger.Warn().Err(err).Str("target", target).Msg("invalid NPAddPeer address")
continue
}
splitted := strings.Split(targetAddr.String(), "/")
if len(splitted) != 7 {
pm.logger.Warn().Str("target", target).Msg("invalid NPAddPeer address")
continue
}
peerAddrString := splitted[2]
peerPortString := splitted[4]
peerPort, err := strconv.Atoi(peerPortString)
if err != nil {
pm.logger.Warn().Str("port", peerPortString).Msg("invalid Peer port")
continue
}
peerIDString := splitted[6]
peerID, err := peer.IDB58Decode(peerIDString)
if err != nil {
pm.logger.Warn().Str(LogPeerID, peerIDString).Msg("invalid PeerID")
continue
}
peerMeta := PeerMeta{
ID: peerID,
Port: uint32(peerPort),
IPAddress: peerAddrString,
Designated: true,
Outbound: true,
}
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Str("addr", peerAddrString).Int("port", peerPort).Msg("Adding Designated peer")
pm.designatedPeers[peerID] = peerMeta
}
}
func (pm *peerManager) runManagePeers() {
addrDuration := time.Minute * 3
addrTicker := time.NewTicker(addrDuration)
// reconnectRunners := make(map[peer.ID]*reconnectRunner)
MANLOOP:
for {
select {
case meta := <-pm.addPeerChannel:
if pm.addOutboundPeer(meta) {
if _, found := pm.designatedPeers[meta.ID]; found {
pm.rm.CancelJob(meta.ID)
}
}
case id := <-pm.removePeerChannel:
if pm.removePeer(id) {
if meta, found := pm.designatedPeers[id]; found {
pm.rm.AddJob(meta)
}
}
case <-addrTicker.C:
pm.checkAndCollectPeerListFromAll()
pm.logPeerMetrics()
case peerMetas := <-pm.fillPoolChannel:
pm.tryFillPool(&peerMetas)
case <-pm.finishChannel:
addrTicker.Stop()
pm.rm.Stop()
// TODO need to keep loop till all remote peer objects are removed, otherwise panic or channel deadlock can come.
break MANLOOP
}
}
// cleanup peers
for peerID := range pm.remotePeers {
pm.removePeer(peerID)
}
}
func (pm *peerManager) logPeerMetrics() {
if pm.logger.IsDebugEnabled() {
pm.logger.Debug().Msg(pm.mm.Summary())
}
}
// addOutboundPeer try to connect and handshake to remote peer. it can be called after peermanager is inited.
// It return true if peer is added or already exist, or return false if failed to add peer.
func (pm *peerManager) addOutboundPeer(meta PeerMeta) bool {
addrString := fmt.Sprintf("/ip4/%s/tcp/%d", meta.IPAddress, meta.Port)
var peerAddr, err = ma.NewMultiaddr(addrString)
if err != nil {
pm.logger.Warn().Err(err).Str("addr", addrString).Msg("invalid NPAddPeer address")
return false
}
var peerID = meta.ID
pm.mutex.Lock()
inboundPeer, ok := pm.remotePeers[peerID]
if ok {
// peer is already exist (and maybe inbound peer)
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Peer is already managed by peermanager")
if meta.Designated {
// If remote peer was connected first. designated flag is not set yet.
inboundPeer.meta.Designated = true
}
pm.mutex.Unlock()
return true
}
pm.mutex.Unlock()
pm.Peerstore().AddAddr(peerID, peerAddr, meta.TTL())
ctx := context.Background()
s, err := pm.NewStream(ctx, meta.ID, aergoP2PSub)
if err != nil {
pm.logger.Info().Err(err).Str("addr", addrString).Str(LogPeerID, meta.ID.Pretty()).Str(LogProtoID, string(aergoP2PSub)).Msg("Error while get stream")
return false
}
rd := metric.NewReader(s)
wt := metric.NewWriter(s)
h := newHandshaker(pm, pm.actorServ, pm.logger, peerID)
rw, remoteStatus, err := h.handshakeOutboundPeerTimeout(rd, wt, defaultHandshakeTTL)
if err != nil {
pm.logger.Debug().Err(err).Str(LogPeerID, meta.ID.Pretty()).Msg("Failed to handshake")
//pm.sendGoAway(rw, "Failed to handshake")
s.Close()
return false
}
pm.mutex.Lock()
inboundPeer, ok = pm.remotePeers[peerID]
if ok {
if ComparePeerID(pm.selfMeta.ID, meta.ID) <= 0 {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, and remote peer is higher priority so closing this outbound connection.")
pm.mutex.Unlock()
pm.sendGoAway(rw, "Already handshaked")
s.Close()
return true
} else {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, but local peer is higher priority so closing that inbound connection")
// disconnect lower valued connection
pm.deletePeer(meta.ID)
inboundPeer.stop()
}
}
// update peer info to remote sent infor
meta = FromPeerAddress(remoteStatus.Sender)
outboundPeer := newRemotePeer(meta, pm, pm.actorServ, pm.logger, pm.mf, pm.signer, rw)
// insert Handlers
pm.handlerFactory.insertHandlers(outboundPeer)
go outboundPeer.runPeer()
pm.insertPeer(peerID, outboundPeer)
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Str("addr", net.ParseIP(meta.IPAddress).String()+":"+strconv.Itoa(int(meta.Port))).Msg("Outbound peer is added to peerService")
outboundPeer.metric = pm.mm.Add(peerID, rd, wt)
pm.mutex.Unlock()
addrs := pm.Peerstore().Addrs(peerID)
addrStrs := make([]string, len(addrs))
for i, addr := range addrs {
addrStrs[i] = addr.String()
}
pm.logger.Debug().Strs("addrs", addrStrs).Str(LogPeerID, outboundPeer.meta.ID.Pretty()).Msg("addresses of peer")
// peer is ready
h.doInitialSync()
// notice to p2pmanager that handshaking is finished
pm.NotifyPeerHandshake(peerID)
return true
}
func (pm *peerManager) sendGoAway(rw MsgReadWriter, msg string) {
goMsg := &types.GoAwayNotice{Message: msg}
// TODO code smell. non safe casting.
mo := pm.mf.newMsgRequestOrder(false, GoAway, goMsg).(*pbRequestOrder)
container := mo.message
rw.WriteMsg(container)
}
func (pm *peerManager) checkInPeerstore(peerID peer.ID) bool {
found := false
for _, existingPeerID := range pm.Peerstore().Peers() {
if existingPeerID == peerID {
found = true
break
}
}
return found
}
func (pm *peerManager) AddNewPeer(peer PeerMeta) {
pm.addPeerChannel <- peer
}
func (pm *peerManager) RemovePeer(peerID peer.ID) {
pm.removePeerChannel <- peerID
}
func (pm *peerManager) NotifyPeerHandshake(peerID peer.ID) {
pm.checkAndCollectPeerList(peerID)
}
func (pm *peerManager) NotifyPeerAddressReceived(metas []PeerMeta) {
pm.fillPoolChannel <- metas
}
// removePeer remove and disconnect managed remote peer connection
// It return true if peer is exist and managed by peermanager
func (pm *peerManager) removePeer(peerID peer.ID) bool {
pm.mutex.Lock()
target, ok := pm.remotePeers[peerID]
if !ok {
pm.mutex.Unlock()
return false
}
pm.deletePeer(peerID)
// No internal module access this peer anymore, but remote message can be received.
target.stop()
pm.mutex.Unlock()
// also disconnect connection
for _, existingPeerID := range pm.Peerstore().Peers() {
if existingPeerID == peerID {
for _, listener := range pm.eventListeners {
listener.OnRemovePeer(peerID)
}
pm.Network().ClosePeer(peerID)
return true
}
}
return true
}
func (pm *peerManager) | Peerstore | identifier_name |
|
peermanager.go | , meta.ID.Pretty()).Msg("Failed to handshake")
//pm.sendGoAway(rw, "Failed to handshake")
s.Close()
return false
}
pm.mutex.Lock()
inboundPeer, ok = pm.remotePeers[peerID]
if ok {
if ComparePeerID(pm.selfMeta.ID, meta.ID) <= 0 {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, and remote peer is higher priority so closing this outbound connection.")
pm.mutex.Unlock()
pm.sendGoAway(rw, "Already handshaked")
s.Close()
return true
} else {
pm.logger.Info().Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("Inbound connection was already handshaked while handshaking outbound connection, but local peer is higher priority so closing that inbound connection")
// disconnect lower valued connection
pm.deletePeer(meta.ID)
inboundPeer.stop()
}
}
// update peer info to remote sent infor
meta = FromPeerAddress(remoteStatus.Sender)
outboundPeer := newRemotePeer(meta, pm, pm.actorServ, pm.logger, pm.mf, pm.signer, rw)
// insert Handlers
pm.handlerFactory.insertHandlers(outboundPeer)
go outboundPeer.runPeer()
pm.insertPeer(peerID, outboundPeer)
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Str("addr", net.ParseIP(meta.IPAddress).String()+":"+strconv.Itoa(int(meta.Port))).Msg("Outbound peer is added to peerService")
outboundPeer.metric = pm.mm.Add(peerID, rd, wt)
pm.mutex.Unlock()
addrs := pm.Peerstore().Addrs(peerID)
addrStrs := make([]string, len(addrs))
for i, addr := range addrs {
addrStrs[i] = addr.String()
}
pm.logger.Debug().Strs("addrs", addrStrs).Str(LogPeerID, outboundPeer.meta.ID.Pretty()).Msg("addresses of peer")
// peer is ready
h.doInitialSync()
// notice to p2pmanager that handshaking is finished
pm.NotifyPeerHandshake(peerID)
return true
}
func (pm *peerManager) sendGoAway(rw MsgReadWriter, msg string) {
goMsg := &types.GoAwayNotice{Message: msg}
// TODO code smell. non safe casting.
mo := pm.mf.newMsgRequestOrder(false, GoAway, goMsg).(*pbRequestOrder)
container := mo.message
rw.WriteMsg(container)
}
func (pm *peerManager) checkInPeerstore(peerID peer.ID) bool {
found := false
for _, existingPeerID := range pm.Peerstore().Peers() {
if existingPeerID == peerID {
found = true
break
}
}
return found
}
func (pm *peerManager) AddNewPeer(peer PeerMeta) {
pm.addPeerChannel <- peer
}
func (pm *peerManager) RemovePeer(peerID peer.ID) {
pm.removePeerChannel <- peerID
}
func (pm *peerManager) NotifyPeerHandshake(peerID peer.ID) {
pm.checkAndCollectPeerList(peerID)
}
func (pm *peerManager) NotifyPeerAddressReceived(metas []PeerMeta) {
pm.fillPoolChannel <- metas
}
// removePeer remove and disconnect managed remote peer connection
// It return true if peer is exist and managed by peermanager
func (pm *peerManager) removePeer(peerID peer.ID) bool {
pm.mutex.Lock()
target, ok := pm.remotePeers[peerID]
if !ok {
pm.mutex.Unlock()
return false
}
pm.deletePeer(peerID)
// No internal module access this peer anymore, but remote message can be received.
target.stop()
pm.mutex.Unlock()
// also disconnect connection
for _, existingPeerID := range pm.Peerstore().Peers() {
if existingPeerID == peerID {
for _, listener := range pm.eventListeners {
listener.OnRemovePeer(peerID)
}
pm.Network().ClosePeer(peerID)
return true
}
}
return true
}
func (pm *peerManager) Peerstore() pstore.Peerstore {
return pm.Host.Peerstore()
}
func (pm *peerManager) startListener() {
var err error
listens := make([]ma.Multiaddr, 0, 2)
// FIXME: should also support ip6 later
listen, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", pm.bindAddress, pm.bindPort))
if err != nil {
panic("Can't estabilish listening address: " + err.Error())
}
listens = append(listens, listen)
peerStore := pstore.NewPeerstore(pstoremem.NewKeyBook(), pstoremem.NewAddrBook(), pstoremem.NewPeerMetadata())
newHost, err := libp2p.New(context.Background(), libp2p.Identity(pm.privateKey), libp2p.Peerstore(peerStore), libp2p.ListenAddrs(listens...))
if err != nil {
pm.logger.Fatal().Err(err).Str("addr", listen.String()).Msg("Couldn't listen from")
panic(err.Error())
}
pm.logger.Info().Str("pid", pm.SelfNodeID().Pretty()).Str("addr[0]", listens[0].String()).
Msg("Set self node's pid, and listening for connections")
pm.Host = newHost
pm.SetStreamHandler(aergoP2PSub, pm.onHandshake)
}
func (pm *peerManager) onHandshake(s inet.Stream) {
peerID := s.Conn().RemotePeer()
h := newHandshaker(pm, pm.actorServ, pm.logger, peerID)
rd := metric.NewReader(s)
wt := metric.NewWriter(s)
rw, statusMsg, err := h.handshakeInboundPeer(rd, wt)
if err != nil {
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Err(err).Msg("fail to handshake")
s.Close()
return
}
// TODO: check status
meta := FromPeerAddress(statusMsg.Sender)
// try Add peer
if inboundPeer, success := pm.tryAddInboundPeer(meta, rw); !success {
// failed to add
pm.sendGoAway(rw, "Concurrent handshake")
s.Close()
return
} else {
inboundPeer.metric = pm.mm.Add(peerID, rd, wt)
}
h.doInitialSync()
// notice to p2pmanager that handshaking is finished
pm.NotifyPeerHandshake(peerID)
}
func (pm *peerManager) tryAddInboundPeer(meta PeerMeta, rw MsgReadWriter) (*remotePeerImpl, bool) {
pm.mutex.Lock()
defer pm.mutex.Unlock()
peerID := meta.ID
outboundPeer, found := pm.remotePeers[peerID]
if found {
if ComparePeerID(pm.selfMeta.ID, meta.ID) <= 0 {
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Msg("Outbound connection was already handshaked while handshaking inbound connection, and remote peer is higher priority so closing that outbound connection.")
pm.sendGoAway(rw, "Already handshaked")
pm.deletePeer(meta.ID)
outboundPeer.stop()
} else {
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Msg("Outbound connection was already handshaked while handshaking inbound connection, but local peer is higher priority and closing this inbound connection.")
// disconnect lower valued connection
return nil, false
}
}
inboundPeer := newRemotePeer(meta, pm, pm.actorServ, pm.logger, pm.mf, pm.signer, rw)
pm.handlerFactory.insertHandlers(inboundPeer)
go inboundPeer.runPeer()
pm.insertPeer(peerID, inboundPeer)
peerAddr := meta.ToPeerAddress()
addrs := pm.Peerstore().Addrs(peerID)
addrStrs := make([]string, len(addrs))
for i, addr := range addrs {
addrStrs[i] = addr.String()
}
pm.logger.Debug().Strs("addrs", addrStrs).Str(LogPeerID, inboundPeer.meta.ID.Pretty()).Msg("addresses of peer")
pm.logger.Info().Str(LogPeerID, peerID.Pretty()).Str("addr", getIP(&peerAddr).String()+":"+strconv.Itoa(int(peerAddr.Port))).Msg("Inbound peer is added to peerService")
return inboundPeer, true
}
func (pm *peerManager) Start() error {
pm.run()
//pm.conf.NPAddPeers
return nil
}
func (pm *peerManager) Stop() error {
// TODO stop service
// close(pm.addPeerChannel)
// close(pm.removePeerChannel)
pm.finishChannel <- struct{}{}
return nil
}
func (pm *peerManager) GetName() string {
return "p2p service"
}
func (pm *peerManager) checkAndCollectPeerListFromAll() {
if pm.hasEnoughPeers() {
return
}
for _, remotePeer := range pm.remotePeers {
pm.actorServ.SendRequest(message.P2PSvc, &message.GetAddressesMsg{ToWhom: remotePeer.meta.ID, Size: 20, Offset: 0})
}
}
func (pm *peerManager) checkAndCollectPeerList(ID peer.ID) { | if pm.hasEnoughPeers() {
return | random_line_split |
|
Config.ts | I don't know his lives . // I don't know where he~his lives .
He get to cleaned his son . // He got his~his son~son to:O clean:O the~ room~ .
We wrote down the number . // We wrote the number down~down .
`
.trim()
.split(/\n\n+/gm)
.map(line => ex.apply({}, line.split('//').map(side => side.trim()) as [string, string]))
const order_changing_labels: Record<string, true> = {
'S-adv': true,
'S-finV': true,
'S-WO': true,
WO: true,
INV: true,
OINV: true,
}
export const label_args: Record<string, number> = {
/*age_string: 1,*/
}
export type TaxonomyGroup = {
group: string
entries: {
label: string
desc: string
}[]
}
export type Taxonomy = TaxonomyGroup[]
const extra = 'gen def pl foreign'.split(' ')
const temporary = 'OBS! Cit-FL Com!'.split(' ')
const digits = /^\d+$/
/** An ordered set of label categories. */
export enum LabelOrder {
BASE,
NUM,
EXTRA,
TEMP,
}
/** Maps a label to a category in LabelOrder. */
export function label_order(label: string): LabelOrder {
if (temporary.includes(label)) {
return LabelOrder.TEMP
} else if (extra.includes(label)) {
return LabelOrder.EXTRA
} else if (digits.test(label)) {
return LabelOrder.NUM
} else {
return LabelOrder.BASE
}
}
/** Sorting function for labels. */
// Sort first by taxonomy, then label type, and finally alphabetically.
export const label_sort: Comparator<string> = chain_cmps(
mkcmp(label_taxonomy),
mkcmp(label_order),
cmp_order
)
const anonymization: Taxonomy = [
{
group: 'Morphology',
entries: [
{label: 'gen', desc: 'genitive'},
{label: 'def', desc: 'definite'},
{label: 'pl', desc: 'plural'},
],
},
{
group: 'Names',
entries: [
{label: 'firstname_male', desc: ''},
{label: 'firstname_female', desc: ''},
{label: 'firstname_unknown', desc: ''},
{label: 'initials', desc: ''},
{label: 'middlename', desc: ''},
{label: 'surname', desc: ''},
],
},
{
group: 'Geographic data',
entries: [
{label: 'foreign', desc: ''},
{label: 'area', desc: ''},
{label: 'city', desc: 'city including villages'},
{label: 'country', desc: 'except Sweden'},
{label: 'geo', desc: 'forest, lake, mountain, etc'},
{label: 'place', desc: ''},
{label: 'region', desc: ''},
{label: 'street_nr', desc: 'street number'},
{label: 'zip_code', desc: ''},
],
},
{
group: 'Institutions',
entries: [
{label: 'school', desc: ''},
{label: 'work', desc: ''},
{label: 'other_institution', desc: ''},
],
},
{
group: 'Transportation',
entries: [
{label: 'transport_name', desc: 'bus, metro, tram, train, express'},
{label: 'transport_nr', desc: 'number, color'},
],
},
{
group: 'Age',
entries: [{label: 'age_digits', desc: ''}, {label: 'age_string', desc: ''}],
},
{
group: 'Dates',
entries: [
{label: 'date_digits', desc: 'numerical date represenation, delimiters are retained'},
{label: 'day', desc: ''},
{label: 'month_digit', desc: ''},
{label: 'month_word', desc: ''},
{label: 'year', desc: ''},
],
},
{
group: 'Misc',
entries: [
{label: 'account_nr', desc: ''},
{label: 'email', desc: ''},
{label: 'extra', desc: ''},
{label: 'license_nr', desc: ''},
{label: 'other_nr_seq', desc: 'a sequence of numbers'},
{label: 'phone_nr', desc: ''},
{label: 'personid_nr', desc: ''},
{label: 'url', desc: ''},
],
},
{
group: 'Mark',
entries: [
{label: 'edu', desc: 'education, courses'},
{label: 'fam', desc: 'family members'},
{label: 'prof', desc: 'profession'},
{label: 'sensitive', desc: ''},
],
},
{
group: 'Other',
entries: [
{label: 'Cit-FL', desc: 'Citation for a language'},
{label: 'Com!', desc: 'Comment'},
{label: 'OBS!', desc: 'Attention'},
],
},
]
export const normalization: Taxonomy = [
{
group: 'Other',
entries: [
{
label: 'Cit-FL',
desc: 'Citation for a language'
},
{
label: 'Com!',
desc: 'Comment'
},
{
label: 'OBS!',
desc: 'Attention'
},
{
label: 'X',
desc: 'Impossible to interpret the writer’s intention',
},
],
},
]
// Julia's updated taxonomy 19 April 2018
export const correctannot: Taxonomy = [
{
group: 'Orthographic',
entries: [
{
label: 'O',
desc: 'Spelling',
},
{
label: 'O-Cap',
desc: 'Upper/lower case',
},
{
label: 'O-Comp',
desc: 'Spaces and hyphens between words',
},
],
},
{
group: 'Lexical',
entries: [
{
label: 'L-Der',
desc: 'Word formation (derivation and compounding)',
},
{
label: 'L-FL',
desc: 'Non-Swedish word corrected to Swedish word',
},
{
label: 'L-Ref',
desc: 'Choice of anaphoric expression',
},
{
label: 'L-W',
desc:
'Wrong word or phrase, other',
},
],
},
{
group: 'Morphological',
entries: [
{
label: 'M-Adj/adv',
desc: 'Adjective form of word corrected to adverb form',
},
{
label: 'M-Case',
desc: 'Nominative vs genitive/accusative',
},
{label: 'M-Def', desc: 'Definiteness: articles; forms of nouns and adjectives'},
{label: 'M-F', desc: 'Grammatical category kept, form changed'},
{label: 'M-Gend', desc: 'Gender'},
{label: 'M-Num', desc: 'Number'},
{
label: 'M-Other',
desc:
'Other morphological corrections, including change between different comparational forms of adjectives',
},
{label: 'M-Verb', desc: 'Verb forms; use of ha, komma and skola auxiliaries'},
],
},
{
group: 'Punctuation',
entries: [
{
label: 'P-M',
desc: 'Punctuation missing (added)',
},
{
label: 'P-R',
desc: 'Punctuation redundant (removed)',
},
{
label: 'P-Sent',
desc: 'Sentence segmentation',
},
{
label: 'P-W',
desc: 'Wrong punctuation',
},
],
},
{
group: 'Syntactical',
entries: [
{
label: 'S-Adv',
desc: 'Adverbial placement',
},
{
label: 'S-Comp',
desc: 'Compound vs multi-word expression, and other restructuring of the same lexical morphemes within a phrase',
},
{
label: 'S-Clause',
desc: 'Change of basic clause structure: syntactic function of components, hierarchical clause structure',
},
{
label: 'S-Ext',
desc: 'Extensive and complex correction',
},
{
label: 'S-FinV',
desc: 'Finite verb placement',
},
{
label: 'S-M',
desc:
'Word missing (added)',
},
{
label: 'S-Msubj',
desc: 'Subject missing (added)',
},
{
label: 'S-Other',
desc:
'Other syntactical correction',
},
{
label: 'S-R',
desc: 'Word redundant (removed)',
},
{
label: 'S-Type',
desc: 'Change of phrase |
Their was a problem yesteray . // There was a problem yesterday .
| random_line_split |
|
Config.ts | , mountain, etc'},
{label: 'place', desc: ''},
{label: 'region', desc: ''},
{label: 'street_nr', desc: 'street number'},
{label: 'zip_code', desc: ''},
],
},
{
group: 'Institutions',
entries: [
{label: 'school', desc: ''},
{label: 'work', desc: ''},
{label: 'other_institution', desc: ''},
],
},
{
group: 'Transportation',
entries: [
{label: 'transport_name', desc: 'bus, metro, tram, train, express'},
{label: 'transport_nr', desc: 'number, color'},
],
},
{
group: 'Age',
entries: [{label: 'age_digits', desc: ''}, {label: 'age_string', desc: ''}],
},
{
group: 'Dates',
entries: [
{label: 'date_digits', desc: 'numerical date represenation, delimiters are retained'},
{label: 'day', desc: ''},
{label: 'month_digit', desc: ''},
{label: 'month_word', desc: ''},
{label: 'year', desc: ''},
],
},
{
group: 'Misc',
entries: [
{label: 'account_nr', desc: ''},
{label: 'email', desc: ''},
{label: 'extra', desc: ''},
{label: 'license_nr', desc: ''},
{label: 'other_nr_seq', desc: 'a sequence of numbers'},
{label: 'phone_nr', desc: ''},
{label: 'personid_nr', desc: ''},
{label: 'url', desc: ''},
],
},
{
group: 'Mark',
entries: [
{label: 'edu', desc: 'education, courses'},
{label: 'fam', desc: 'family members'},
{label: 'prof', desc: 'profession'},
{label: 'sensitive', desc: ''},
],
},
{
group: 'Other',
entries: [
{label: 'Cit-FL', desc: 'Citation for a language'},
{label: 'Com!', desc: 'Comment'},
{label: 'OBS!', desc: 'Attention'},
],
},
]
export const normalization: Taxonomy = [
{
group: 'Other',
entries: [
{
label: 'Cit-FL',
desc: 'Citation for a language'
},
{
label: 'Com!',
desc: 'Comment'
},
{
label: 'OBS!',
desc: 'Attention'
},
{
label: 'X',
desc: 'Impossible to interpret the writer’s intention',
},
],
},
]
// Julia's updated taxonomy 19 April 2018
export const correctannot: Taxonomy = [
{
group: 'Orthographic',
entries: [
{
label: 'O',
desc: 'Spelling',
},
{
label: 'O-Cap',
desc: 'Upper/lower case',
},
{
label: 'O-Comp',
desc: 'Spaces and hyphens between words',
},
],
},
{
group: 'Lexical',
entries: [
{
label: 'L-Der',
desc: 'Word formation (derivation and compounding)',
},
{
label: 'L-FL',
desc: 'Non-Swedish word corrected to Swedish word',
},
{
label: 'L-Ref',
desc: 'Choice of anaphoric expression',
},
{
label: 'L-W',
desc:
'Wrong word or phrase, other',
},
],
},
{
group: 'Morphological',
entries: [
{
label: 'M-Adj/adv',
desc: 'Adjective form of word corrected to adverb form',
},
{
label: 'M-Case',
desc: 'Nominative vs genitive/accusative',
},
{label: 'M-Def', desc: 'Definiteness: articles; forms of nouns and adjectives'},
{label: 'M-F', desc: 'Grammatical category kept, form changed'},
{label: 'M-Gend', desc: 'Gender'},
{label: 'M-Num', desc: 'Number'},
{
label: 'M-Other',
desc:
'Other morphological corrections, including change between different comparational forms of adjectives',
},
{label: 'M-Verb', desc: 'Verb forms; use of ha, komma and skola auxiliaries'},
],
},
{
group: 'Punctuation',
entries: [
{
label: 'P-M',
desc: 'Punctuation missing (added)',
},
{
label: 'P-R',
desc: 'Punctuation redundant (removed)',
},
{
label: 'P-Sent',
desc: 'Sentence segmentation',
},
{
label: 'P-W',
desc: 'Wrong punctuation',
},
],
},
{
group: 'Syntactical',
entries: [
{
label: 'S-Adv',
desc: 'Adverbial placement',
},
{
label: 'S-Comp',
desc: 'Compound vs multi-word expression, and other restructuring of the same lexical morphemes within a phrase',
},
{
label: 'S-Clause',
desc: 'Change of basic clause structure: syntactic function of components, hierarchical clause structure',
},
{
label: 'S-Ext',
desc: 'Extensive and complex correction',
},
{
label: 'S-FinV',
desc: 'Finite verb placement',
},
{
label: 'S-M',
desc:
'Word missing (added)',
},
{
label: 'S-Msubj',
desc: 'Subject missing (added)',
},
{
label: 'S-Other',
desc:
'Other syntactical correction',
},
{
label: 'S-R',
desc: 'Word redundant (removed)',
},
{
label: 'S-Type',
desc: 'Change of phrase type/part of speech',
},
{
label: 'S-WO',
desc: 'Word order, other',
},
],
},
{
group: 'Other',
entries: [
{
label: 'C',
desc: 'Consistency correction, necessitated by other correction',
},
{
label: 'Cit-FL',
desc: 'Non-Swedish word kept, i.e. not corrected',
},
{
label: 'Com!',
desc: 'Comments for the corpus user'
},
{
label: 'OBS!',
desc: 'Internal and temporary comments for the annotators'
},
{
label: 'Unid',
desc: 'Unidentified correction',
},
{
label: 'X',
desc: 'Unintelligible string',
},
],
},
]
function doc_url(title: string): string {
return 'https://spraakbanken.github.io/swell-project/' + title
}
const docs: Record<string, Record<string, string>> = {
anonymization: {
'pseudonymization guidelines': doc_url('Pseudonymization_guidelines'),
},
normalization: {
'normalization guidelines': doc_url('Normalization_guidelines'),
},
correctannot: {
'annotation guidelines': doc_url('Correction-annotation_guidelines'),
},
}
export const config = {
order_changing_labels,
examples,
image_ws_url,
pseuws_url,
taxonomy: {anonymization, normalization, correctannot},
docs,
}
/** What group does this label belong to?
(label_group('country') as TaxonomyGroup).group // => 'Geographic data'
label_group('quux') // => undefined
*/
export function label_group(label: string): TaxonomyGroup | undefined {
return config.taxonomy.anonymization.find(
group => !!group.entries.find(entry => entry.label == label)
)
}
export interface TaxonomyFind {
taxonomy: string
group: string
entry: {label: string; desc: string}
}
export function find_label(label: string): TaxonomyFind | undefined {
const order = label_order(label)
if (order === LabelOrder.NUM) {
return {taxonomy: 'anonymization', group: 'Number', entry: {label, desc: 'number'}}
}
if (order === LabelOrder.TEMP) {
return undefined
}
for (let taxonomy in config.taxonomy) {
for (let group of (config.taxonomy as {[mode: string]: Taxonomy})[taxonomy]) {
let entry = group.entries.find(entry => entry.label == label)
if (entry !== undefined) return {taxonomy, group: group.group, entry}
}
}
}
/** Get the taxonomy domain (editor mode) of a label. */
export function label_taxonomy(label: string): string | null {
return find_label(label) ? find_label(label)!.taxonomy : null
}
/** Does the named taxonomy include the given label? */
export function ta | xonomy_has_label(t | identifier_name |
|
Config.ts | desc: string
}[]
}
export type Taxonomy = TaxonomyGroup[]
const extra = 'gen def pl foreign'.split(' ')
const temporary = 'OBS! Cit-FL Com!'.split(' ')
const digits = /^\d+$/
/** An ordered set of label categories. */
export enum LabelOrder {
BASE,
NUM,
EXTRA,
TEMP,
}
/** Maps a label to a category in LabelOrder. */
export function label_order(label: string): LabelOrder {
if (temporary.includes(label)) {
return LabelOrder.TEMP
} else if (extra.includes(label)) {
return LabelOrder.EXTRA
} else if (digits.test(label)) {
return LabelOrder.NUM
} else {
return LabelOrder.BASE
}
}
/** Sorting function for labels. */
// Sort first by taxonomy, then label type, and finally alphabetically.
export const label_sort: Comparator<string> = chain_cmps(
mkcmp(label_taxonomy),
mkcmp(label_order),
cmp_order
)
const anonymization: Taxonomy = [
{
group: 'Morphology',
entries: [
{label: 'gen', desc: 'genitive'},
{label: 'def', desc: 'definite'},
{label: 'pl', desc: 'plural'},
],
},
{
group: 'Names',
entries: [
{label: 'firstname_male', desc: ''},
{label: 'firstname_female', desc: ''},
{label: 'firstname_unknown', desc: ''},
{label: 'initials', desc: ''},
{label: 'middlename', desc: ''},
{label: 'surname', desc: ''},
],
},
{
group: 'Geographic data',
entries: [
{label: 'foreign', desc: ''},
{label: 'area', desc: ''},
{label: 'city', desc: 'city including villages'},
{label: 'country', desc: 'except Sweden'},
{label: 'geo', desc: 'forest, lake, mountain, etc'},
{label: 'place', desc: ''},
{label: 'region', desc: ''},
{label: 'street_nr', desc: 'street number'},
{label: 'zip_code', desc: ''},
],
},
{
group: 'Institutions',
entries: [
{label: 'school', desc: ''},
{label: 'work', desc: ''},
{label: 'other_institution', desc: ''},
],
},
{
group: 'Transportation',
entries: [
{label: 'transport_name', desc: 'bus, metro, tram, train, express'},
{label: 'transport_nr', desc: 'number, color'},
],
},
{
group: 'Age',
entries: [{label: 'age_digits', desc: ''}, {label: 'age_string', desc: ''}],
},
{
group: 'Dates',
entries: [
{label: 'date_digits', desc: 'numerical date represenation, delimiters are retained'},
{label: 'day', desc: ''},
{label: 'month_digit', desc: ''},
{label: 'month_word', desc: ''},
{label: 'year', desc: ''},
],
},
{
group: 'Misc',
entries: [
{label: 'account_nr', desc: ''},
{label: 'email', desc: ''},
{label: 'extra', desc: ''},
{label: 'license_nr', desc: ''},
{label: 'other_nr_seq', desc: 'a sequence of numbers'},
{label: 'phone_nr', desc: ''},
{label: 'personid_nr', desc: ''},
{label: 'url', desc: ''},
],
},
{
group: 'Mark',
entries: [
{label: 'edu', desc: 'education, courses'},
{label: 'fam', desc: 'family members'},
{label: 'prof', desc: 'profession'},
{label: 'sensitive', desc: ''},
],
},
{
group: 'Other',
entries: [
{label: 'Cit-FL', desc: 'Citation for a language'},
{label: 'Com!', desc: 'Comment'},
{label: 'OBS!', desc: 'Attention'},
],
},
]
export const normalization: Taxonomy = [
{
group: 'Other',
entries: [
{
label: 'Cit-FL',
desc: 'Citation for a language'
},
{
label: 'Com!',
desc: 'Comment'
},
{
label: 'OBS!',
desc: 'Attention'
},
{
label: 'X',
desc: 'Impossible to interpret the writer’s intention',
},
],
},
]
// Julia's updated taxonomy 19 April 2018
export const correctannot: Taxonomy = [
{
group: 'Orthographic',
entries: [
{
label: 'O',
desc: 'Spelling',
},
{
label: 'O-Cap',
desc: 'Upper/lower case',
},
{
label: 'O-Comp',
desc: 'Spaces and hyphens between words',
},
],
},
{
group: 'Lexical',
entries: [
{
label: 'L-Der',
desc: 'Word formation (derivation and compounding)',
},
{
label: 'L-FL',
desc: 'Non-Swedish word corrected to Swedish word',
},
{
label: 'L-Ref',
desc: 'Choice of anaphoric expression',
},
{
label: 'L-W',
desc:
'Wrong word or phrase, other',
},
],
},
{
group: 'Morphological',
entries: [
{
label: 'M-Adj/adv',
desc: 'Adjective form of word corrected to adverb form',
},
{
label: 'M-Case',
desc: 'Nominative vs genitive/accusative',
},
{label: 'M-Def', desc: 'Definiteness: articles; forms of nouns and adjectives'},
{label: 'M-F', desc: 'Grammatical category kept, form changed'},
{label: 'M-Gend', desc: 'Gender'},
{label: 'M-Num', desc: 'Number'},
{
label: 'M-Other',
desc:
'Other morphological corrections, including change between different comparational forms of adjectives',
},
{label: 'M-Verb', desc: 'Verb forms; use of ha, komma and skola auxiliaries'},
],
},
{
group: 'Punctuation',
entries: [
{
label: 'P-M',
desc: 'Punctuation missing (added)',
},
{
label: 'P-R',
desc: 'Punctuation redundant (removed)',
},
{
label: 'P-Sent',
desc: 'Sentence segmentation',
},
{
label: 'P-W',
desc: 'Wrong punctuation',
},
],
},
{
group: 'Syntactical',
entries: [
{
label: 'S-Adv',
desc: 'Adverbial placement',
},
{
label: 'S-Comp',
desc: 'Compound vs multi-word expression, and other restructuring of the same lexical morphemes within a phrase',
},
{
label: 'S-Clause',
desc: 'Change of basic clause structure: syntactic function of components, hierarchical clause structure',
},
{
label: 'S-Ext',
desc: 'Extensive and complex correction',
},
{
label: 'S-FinV',
desc: 'Finite verb placement',
},
{
label: 'S-M',
desc:
'Word missing (added)',
},
{
label: 'S-Msubj',
desc: 'Subject missing (added)',
},
{
label: 'S-Other',
desc:
'Other syntactical correction',
},
{
label: 'S-R',
desc: 'Word redundant (removed)',
},
{
label: 'S-Type',
desc: 'Change of phrase type/part of speech',
},
{
label: 'S-WO',
desc: 'Word order, other',
},
],
},
{
group: 'Other',
entries: [
{
label: 'C',
desc: 'Consistency correction, necessitated by other correction',
},
{
label: 'Cit-FL',
desc: 'Non-Swedish word kept, i.e. not corrected',
},
{
label: 'Com!',
desc: 'Comments for the corpus user'
},
{
label: 'OBS!',
desc: 'Internal and temporary comments for the annotators'
},
{
label: 'Unid',
desc: 'Unidentified correction',
},
{
label: 'X',
desc: 'Unintelligible string',
},
],
},
]
function doc_url(title: string): string {
| return 'https://spraakbanken.github.io/swell-project/' + title
}
| identifier_body |
|
filesystem.rs | = args[0];
let distributed_filename = args[1];
// Figure out who I am giving this file to
let dest_ids = gen_file_owners(&distributed_filename)?;
// Gossip who has the file now
sender.send(
SendableOperation::for_successors(Box::new(NewFileOwnersOperation {
distributed_filename: distributed_filename.to_string(),
new_owners: dest_ids
.iter()
.map(|x| x.to_string())
.collect::<HashSet<_>>()
}))
)?;
// Send them the file
async_std::task::block_on(send_file_to_all(local_path.to_string(),
distributed_filename.to_string(),
&dest_ids))?;
Ok(())
}
pub fn ls(args: Vec<&str>) -> BoxedErrorResult<()> {
check_joined()?;
let invalid_args: BoxedErrorResult<()> = Err("Usage: ls [distributed_filename]".into());
match args.len() {
0 => {
// All
print_file_owners(None, true)?;
Ok(())
},
1 => {
// Just File
let distributed_filename = args[0];
print_file_owners(Some(distributed_filename), false)?;
Ok(())
},
_ => invalid_args
}
}
// TODO: You wrote this very late - maybe fix
fn print_file_owners(maybe_distributed_filename: Option<&str>, full: bool) -> BoxedErrorResult<()> {
let all_file_owners = globals::ALL_FILE_OWNERS.read();
match (maybe_distributed_filename, full) {
(Some(_), true) => {
Err("Cannot set distributed_filename and full to true when printing owners".into())
},
(Some(distributed_filename), false) => {
// Print the files owners
match all_file_owners.get(distributed_filename) {
Some(owners) => {
println!("{:?}", owners);
},
None => {
// A little unoptimal - change if above format changes
println!("{{}}");
}
}
Ok(())
},
(None, true) => {
// Print the whole map
println!("{:?}", *all_file_owners);
Ok(())
},
(None, false) => {
Err("Cannot print owners of nonexistant distributed_filename with full set to false".into())
}
}
}
async fn get_distributed_file(distributed_filename: String, local_path: String) -> BoxedErrorResult<()> {
// TODO: Find owners
let operation = SendableOperation::for_owners(&distributed_filename, Box::new(GetOperation {
distributed_filename: distributed_filename.clone(),
local_path: local_path
}));
let mut streams = operation
.write_all_tcp_async()
.await?;
// TODO: Redo whatever tf going on here
match streams.len() {
0 => Err(format!("No owners found for file {}", distributed_filename).into()),
_ => {
let (result, source) = streams[0]
.try_read_operation()
.await?;
result.execute(source)?;
Ok(())
}
}
}
async fn read_file_to_buf(local_path: &String) -> BoxedErrorResult<Vec<u8>> {
let mut data_buf: Vec<u8> = Vec::new();
let mut file = async_std::fs::File::open(&local_path).await?;
file.read_to_end(&mut data_buf).await?;
Ok(data_buf)
}
async fn send_file_to_all(local_path: String, distributed_filename: String, dest_ids: &Vec<String>) ->
BoxedErrorResult<()> {
let data_buf = read_file_to_buf(&local_path).await?;
let operation = SendableOperation::for_id_list(dest_ids.clone(), Box::new(SendFileOperation {
filename: distributed_filename,
data: data_buf,
is_distributed: true
}));
operation.write_all_tcp_async().await?;
Ok(())
}
pub async fn file_server<'a>(_sender: &'a OperationSender) -> BoxedErrorResult<()> {
let server = globals::SERVER_SOCKET.read();
let mut incoming = server.incoming();
while let Some(stream) = incoming.next().await {
let connection = stream?;
log(format!("Handling connection from {:?}", connection.peer_addr()));
spawn(handle_connection(connection));
}
Ok(())
}
async fn handle_connection(mut connection: async_std::net::TcpStream) -> BoxedErrorResult<()> {
let (operation, source) = connection.try_read_operation().await?;
// TODO: Think about what standard we want with these
let _generated_operations = operation.execute(source)?;
Ok(())
}
// Helpers
fn gen_file_owners(filename: &str) -> BoxedErrorResult<Vec<String>> {
let file_idx = filename.easyhash();
heartbeat::gen_neighbor_list_from(file_idx as i32, 1, constants::NUM_OWNERS, true)
}
// TODO: This function makes the entire system assume there are always at least two nodes in the system
// and the file must have an owner or else the operation will not work correctly. This is fine for now
// but it is worth improving sooner rather than later (make distinct Error types to differentiate, etc).
fn gen_new_file_owner(filename: &str) -> BoxedErrorResult<String> {
match globals::ALL_FILE_OWNERS.read().get(filename) {
Some(owners) => {
let potential_owners = gen_file_owners(filename)?;
for potential_owner in &potential_owners {
if !owners.contains(potential_owner) {
return Ok(potential_owner.clone());
}
}
Err(format!("No new owners available for file {}", filename).into())
},
None => Err(format!("No owner found for file {}", filename).into())
}
}
fn | (filename: &String) -> String {
format!("{}/{}", constants::DATA_DIR, filename)
}
// Returns messages to be gossiped
pub fn handle_failed_node(failed_id: &String) -> BoxedErrorResult<Vec<SendableOperation>> {
match heartbeat::is_master() {
true => {
let mut generated_operations: Vec<SendableOperation> = Vec::new();
let myself_source = Source::myself();
// Find files they owned
let mut lost_files: HashSet<String> = HashSet::new();
for (distributed_filename, owners) in globals::ALL_FILE_OWNERS.read().iter() {
if owners.contains(failed_id) {
lost_files.insert(distributed_filename.clone());
}
}
log("Found lost files".to_string());
// Send that they no longer own those files
// Separate operation so that this acts like a confirmation to fully forget about the node from
// the master. Can be used with a delay later if you want more error resistance.
let lost_file_operation = LostFilesOperation {
failed_owner: failed_id.clone(),
lost_files: lost_files.clone()
};
generated_operations.append(&mut lost_file_operation.execute(myself_source.clone())?);
log("Executed lost files operation locally".to_string());
// Gen new owners of the file and propagate
let mut new_owners: HashMap<String, HashSet<String>> = HashMap::new();
for lost_file in &lost_files {
let new_owner = gen_new_file_owner(&lost_file)?;
// TODO: Maybe optimize this into one fat packet - probably a new operation?
let new_owner_operation = NewFileOwnersOperation {
distributed_filename: lost_file.clone(),
new_owners: vec![new_owner].iter().map(|x| x.to_string()).collect()
};
generated_operations.append(&mut new_owner_operation.execute(myself_source.clone())?);
}
log("Executed all new_owner operations locally".to_string());
Ok(generated_operations)
},
false => {
Ok(vec![])
}
}
}
// Operations
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetOperation {
pub distributed_filename: String,
pub local_path: String
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NewFileOwnersOperation {
pub distributed_filename: String,
pub new_owners: HashSet<String>
}
#[derive(Serialize, Deserialize, Clone)]
pub struct SendFileOperation {
pub filename: String,
pub data: Vec<u8>,
pub is_distributed: bool
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LostFilesOperation {
pub failed_owner: String,
pub lost_files: HashSet<String>
}
// Trait Impls
impl OperationWriteExecute for GetOperation {
fn to_bytes(&self) -> BoxedErrorResult<Vec<u8>> {
Ok(create_buf(&self, str_to_vec("GET ")))
}
fn execute(&self, source: Source) -> BoxedErrorResult<Vec<SendableOperation>> {
let local_path = distributed_file_path(&self.distributed_filename);
let data_buf = async_std::task::block_on(read_file_to_buf(&local_path))?;
let operation = SendableOperation::for_single_tcp_stream(
TryInto::<async_std::net::TcpStream>::try_into(source)?,
Box::new(SendFileOperation {
filename: self.local_path.clone(),
data: data_buf,
is_distributed: false
}));
async_std::task::block_on(operation.write_all_tcp_async());
Ok(vec![])
}
fn to_string(&self) -> String { format!("{:?}", self) }
}
impl OperationWriteExecute for NewFileOwnersOperation {
fn to_bytes(&self) | distributed_file_path | identifier_name |
filesystem.rs | = args[0];
let distributed_filename = args[1];
// Figure out who I am giving this file to
let dest_ids = gen_file_owners(&distributed_filename)?;
// Gossip who has the file now
sender.send(
SendableOperation::for_successors(Box::new(NewFileOwnersOperation {
distributed_filename: distributed_filename.to_string(),
new_owners: dest_ids
.iter()
.map(|x| x.to_string())
.collect::<HashSet<_>>()
}))
)?;
// Send them the file
async_std::task::block_on(send_file_to_all(local_path.to_string(),
distributed_filename.to_string(),
&dest_ids))?;
Ok(())
}
pub fn ls(args: Vec<&str>) -> BoxedErrorResult<()> {
check_joined()?;
let invalid_args: BoxedErrorResult<()> = Err("Usage: ls [distributed_filename]".into());
match args.len() {
0 => {
// All
print_file_owners(None, true)?;
Ok(())
},
1 => {
// Just File
let distributed_filename = args[0];
print_file_owners(Some(distributed_filename), false)?;
Ok(())
},
_ => invalid_args
}
}
// TODO: You wrote this very late - maybe fix
fn print_file_owners(maybe_distributed_filename: Option<&str>, full: bool) -> BoxedErrorResult<()> {
let all_file_owners = globals::ALL_FILE_OWNERS.read();
match (maybe_distributed_filename, full) {
(Some(_), true) => {
Err("Cannot set distributed_filename and full to true when printing owners".into())
},
(Some(distributed_filename), false) => {
// Print the files owners
match all_file_owners.get(distributed_filename) {
Some(owners) => {
println!("{:?}", owners);
},
None => {
// A little unoptimal - change if above format changes
println!("{{}}");
}
}
Ok(())
},
(None, true) => {
// Print the whole map
println!("{:?}", *all_file_owners);
Ok(())
},
(None, false) => {
Err("Cannot print owners of nonexistant distributed_filename with full set to false".into())
}
}
}
async fn get_distributed_file(distributed_filename: String, local_path: String) -> BoxedErrorResult<()> {
// TODO: Find owners
let operation = SendableOperation::for_owners(&distributed_filename, Box::new(GetOperation {
distributed_filename: distributed_filename.clone(),
local_path: local_path
}));
let mut streams = operation
.write_all_tcp_async()
.await?;
// TODO: Redo whatever tf going on here
match streams.len() {
0 => Err(format!("No owners found for file {}", distributed_filename).into()),
_ => {
let (result, source) = streams[0]
.try_read_operation()
.await?;
result.execute(source)?;
Ok(())
}
}
}
async fn read_file_to_buf(local_path: &String) -> BoxedErrorResult<Vec<u8>> {
let mut data_buf: Vec<u8> = Vec::new();
let mut file = async_std::fs::File::open(&local_path).await?;
file.read_to_end(&mut data_buf).await?;
Ok(data_buf)
}
async fn send_file_to_all(local_path: String, distributed_filename: String, dest_ids: &Vec<String>) ->
BoxedErrorResult<()> {
let data_buf = read_file_to_buf(&local_path).await?;
let operation = SendableOperation::for_id_list(dest_ids.clone(), Box::new(SendFileOperation {
filename: distributed_filename,
data: data_buf,
is_distributed: true
}));
operation.write_all_tcp_async().await?;
Ok(())
}
pub async fn file_server<'a>(_sender: &'a OperationSender) -> BoxedErrorResult<()> {
let server = globals::SERVER_SOCKET.read();
let mut incoming = server.incoming();
while let Some(stream) = incoming.next().await {
let connection = stream?;
log(format!("Handling connection from {:?}", connection.peer_addr()));
spawn(handle_connection(connection));
}
Ok(())
}
async fn handle_connection(mut connection: async_std::net::TcpStream) -> BoxedErrorResult<()> {
let (operation, source) = connection.try_read_operation().await?;
// TODO: Think about what standard we want with these
let _generated_operations = operation.execute(source)?;
Ok(())
}
// Helpers
fn gen_file_owners(filename: &str) -> BoxedErrorResult<Vec<String>> {
let file_idx = filename.easyhash();
heartbeat::gen_neighbor_list_from(file_idx as i32, 1, constants::NUM_OWNERS, true)
}
// TODO: This function makes the entire system assume there are always at least two nodes in the system
// and the file must have an owner or else the operation will not work correctly. This is fine for now
// but it is worth improving sooner rather than later (make distinct Error types to differentiate, etc).
fn gen_new_file_owner(filename: &str) -> BoxedErrorResult<String> {
match globals::ALL_FILE_OWNERS.read().get(filename) {
Some(owners) => {
let potential_owners = gen_file_owners(filename)?;
for potential_owner in &potential_owners {
if !owners.contains(potential_owner) |
}
Err(format!("No new owners available for file {}", filename).into())
},
None => Err(format!("No owner found for file {}", filename).into())
}
}
fn distributed_file_path(filename: &String) -> String {
format!("{}/{}", constants::DATA_DIR, filename)
}
// Returns messages to be gossiped
pub fn handle_failed_node(failed_id: &String) -> BoxedErrorResult<Vec<SendableOperation>> {
match heartbeat::is_master() {
true => {
let mut generated_operations: Vec<SendableOperation> = Vec::new();
let myself_source = Source::myself();
// Find files they owned
let mut lost_files: HashSet<String> = HashSet::new();
for (distributed_filename, owners) in globals::ALL_FILE_OWNERS.read().iter() {
if owners.contains(failed_id) {
lost_files.insert(distributed_filename.clone());
}
}
log("Found lost files".to_string());
// Send that they no longer own those files
// Separate operation so that this acts like a confirmation to fully forget about the node from
// the master. Can be used with a delay later if you want more error resistance.
let lost_file_operation = LostFilesOperation {
failed_owner: failed_id.clone(),
lost_files: lost_files.clone()
};
generated_operations.append(&mut lost_file_operation.execute(myself_source.clone())?);
log("Executed lost files operation locally".to_string());
// Gen new owners of the file and propagate
let mut new_owners: HashMap<String, HashSet<String>> = HashMap::new();
for lost_file in &lost_files {
let new_owner = gen_new_file_owner(&lost_file)?;
// TODO: Maybe optimize this into one fat packet - probably a new operation?
let new_owner_operation = NewFileOwnersOperation {
distributed_filename: lost_file.clone(),
new_owners: vec![new_owner].iter().map(|x| x.to_string()).collect()
};
generated_operations.append(&mut new_owner_operation.execute(myself_source.clone())?);
}
log("Executed all new_owner operations locally".to_string());
Ok(generated_operations)
},
false => {
Ok(vec![])
}
}
}
// Operations
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetOperation {
pub distributed_filename: String,
pub local_path: String
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NewFileOwnersOperation {
pub distributed_filename: String,
pub new_owners: HashSet<String>
}
#[derive(Serialize, Deserialize, Clone)]
pub struct SendFileOperation {
pub filename: String,
pub data: Vec<u8>,
pub is_distributed: bool
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LostFilesOperation {
pub failed_owner: String,
pub lost_files: HashSet<String>
}
// Trait Impls
impl OperationWriteExecute for GetOperation {
fn to_bytes(&self) -> BoxedErrorResult<Vec<u8>> {
Ok(create_buf(&self, str_to_vec("GET ")))
}
fn execute(&self, source: Source) -> BoxedErrorResult<Vec<SendableOperation>> {
let local_path = distributed_file_path(&self.distributed_filename);
let data_buf = async_std::task::block_on(read_file_to_buf(&local_path))?;
let operation = SendableOperation::for_single_tcp_stream(
TryInto::<async_std::net::TcpStream>::try_into(source)?,
Box::new(SendFileOperation {
filename: self.local_path.clone(),
data: data_buf,
is_distributed: false
}));
async_std::task::block_on(operation.write_all_tcp_async());
Ok(vec![])
}
fn to_string(&self) -> String { format!("{:?}", self) }
}
impl OperationWriteExecute for NewFileOwnersOperation {
fn to_bytes(&self | {
return Ok(potential_owner.clone());
} | conditional_block |
filesystem.rs | = args[0];
let distributed_filename = args[1];
// Figure out who I am giving this file to
let dest_ids = gen_file_owners(&distributed_filename)?;
// Gossip who has the file now
sender.send(
SendableOperation::for_successors(Box::new(NewFileOwnersOperation {
distributed_filename: distributed_filename.to_string(),
new_owners: dest_ids
.iter()
.map(|x| x.to_string())
.collect::<HashSet<_>>()
}))
)?;
// Send them the file
async_std::task::block_on(send_file_to_all(local_path.to_string(),
distributed_filename.to_string(),
&dest_ids))?;
Ok(())
}
pub fn ls(args: Vec<&str>) -> BoxedErrorResult<()> {
check_joined()?;
let invalid_args: BoxedErrorResult<()> = Err("Usage: ls [distributed_filename]".into());
match args.len() {
0 => {
// All
print_file_owners(None, true)?;
Ok(())
},
1 => {
// Just File
let distributed_filename = args[0];
print_file_owners(Some(distributed_filename), false)?;
Ok(())
},
_ => invalid_args
}
}
// TODO: You wrote this very late - maybe fix
fn print_file_owners(maybe_distributed_filename: Option<&str>, full: bool) -> BoxedErrorResult<()> {
let all_file_owners = globals::ALL_FILE_OWNERS.read();
match (maybe_distributed_filename, full) {
(Some(_), true) => {
Err("Cannot set distributed_filename and full to true when printing owners".into())
},
(Some(distributed_filename), false) => {
// Print the files owners
match all_file_owners.get(distributed_filename) {
Some(owners) => {
println!("{:?}", owners);
},
None => {
// A little unoptimal - change if above format changes
println!("{{}}");
}
}
Ok(())
},
(None, true) => {
// Print the whole map
println!("{:?}", *all_file_owners);
Ok(())
},
(None, false) => {
Err("Cannot print owners of nonexistant distributed_filename with full set to false".into())
}
}
}
async fn get_distributed_file(distributed_filename: String, local_path: String) -> BoxedErrorResult<()> {
// TODO: Find owners
let operation = SendableOperation::for_owners(&distributed_filename, Box::new(GetOperation {
distributed_filename: distributed_filename.clone(),
local_path: local_path
}));
let mut streams = operation
.write_all_tcp_async()
.await?;
// TODO: Redo whatever tf going on here
match streams.len() {
0 => Err(format!("No owners found for file {}", distributed_filename).into()),
_ => {
let (result, source) = streams[0]
.try_read_operation()
.await?;
result.execute(source)?;
Ok(())
}
}
}
async fn read_file_to_buf(local_path: &String) -> BoxedErrorResult<Vec<u8>> {
let mut data_buf: Vec<u8> = Vec::new();
let mut file = async_std::fs::File::open(&local_path).await?;
file.read_to_end(&mut data_buf).await?;
Ok(data_buf)
}
async fn send_file_to_all(local_path: String, distributed_filename: String, dest_ids: &Vec<String>) ->
BoxedErrorResult<()> {
let data_buf = read_file_to_buf(&local_path).await?;
let operation = SendableOperation::for_id_list(dest_ids.clone(), Box::new(SendFileOperation {
filename: distributed_filename,
data: data_buf,
is_distributed: true
}));
operation.write_all_tcp_async().await?;
Ok(())
}
pub async fn file_server<'a>(_sender: &'a OperationSender) -> BoxedErrorResult<()> {
let server = globals::SERVER_SOCKET.read();
let mut incoming = server.incoming();
while let Some(stream) = incoming.next().await {
let connection = stream?;
log(format!("Handling connection from {:?}", connection.peer_addr()));
spawn(handle_connection(connection));
}
Ok(())
}
async fn handle_connection(mut connection: async_std::net::TcpStream) -> BoxedErrorResult<()> {
let (operation, source) = connection.try_read_operation().await?;
// TODO: Think about what standard we want with these
let _generated_operations = operation.execute(source)?;
Ok(())
}
// Helpers
fn gen_file_owners(filename: &str) -> BoxedErrorResult<Vec<String>> {
let file_idx = filename.easyhash();
heartbeat::gen_neighbor_list_from(file_idx as i32, 1, constants::NUM_OWNERS, true)
} |
// TODO: This function makes the entire system assume there are always at least two nodes in the system
// and the file must have an owner or else the operation will not work correctly. This is fine for now
// but it is worth improving sooner rather than later (make distinct Error types to differentiate, etc).
fn gen_new_file_owner(filename: &str) -> BoxedErrorResult<String> {
match globals::ALL_FILE_OWNERS.read().get(filename) {
Some(owners) => {
let potential_owners = gen_file_owners(filename)?;
for potential_owner in &potential_owners {
if !owners.contains(potential_owner) {
return Ok(potential_owner.clone());
}
}
Err(format!("No new owners available for file {}", filename).into())
},
None => Err(format!("No owner found for file {}", filename).into())
}
}
fn distributed_file_path(filename: &String) -> String {
format!("{}/{}", constants::DATA_DIR, filename)
}
// Returns messages to be gossiped
pub fn handle_failed_node(failed_id: &String) -> BoxedErrorResult<Vec<SendableOperation>> {
match heartbeat::is_master() {
true => {
let mut generated_operations: Vec<SendableOperation> = Vec::new();
let myself_source = Source::myself();
// Find files they owned
let mut lost_files: HashSet<String> = HashSet::new();
for (distributed_filename, owners) in globals::ALL_FILE_OWNERS.read().iter() {
if owners.contains(failed_id) {
lost_files.insert(distributed_filename.clone());
}
}
log("Found lost files".to_string());
// Send that they no longer own those files
// Separate operation so that this acts like a confirmation to fully forget about the node from
// the master. Can be used with a delay later if you want more error resistance.
let lost_file_operation = LostFilesOperation {
failed_owner: failed_id.clone(),
lost_files: lost_files.clone()
};
generated_operations.append(&mut lost_file_operation.execute(myself_source.clone())?);
log("Executed lost files operation locally".to_string());
// Gen new owners of the file and propagate
let mut new_owners: HashMap<String, HashSet<String>> = HashMap::new();
for lost_file in &lost_files {
let new_owner = gen_new_file_owner(&lost_file)?;
// TODO: Maybe optimize this into one fat packet - probably a new operation?
let new_owner_operation = NewFileOwnersOperation {
distributed_filename: lost_file.clone(),
new_owners: vec![new_owner].iter().map(|x| x.to_string()).collect()
};
generated_operations.append(&mut new_owner_operation.execute(myself_source.clone())?);
}
log("Executed all new_owner operations locally".to_string());
Ok(generated_operations)
},
false => {
Ok(vec![])
}
}
}
// Operations
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetOperation {
pub distributed_filename: String,
pub local_path: String
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NewFileOwnersOperation {
pub distributed_filename: String,
pub new_owners: HashSet<String>
}
#[derive(Serialize, Deserialize, Clone)]
pub struct SendFileOperation {
pub filename: String,
pub data: Vec<u8>,
pub is_distributed: bool
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LostFilesOperation {
pub failed_owner: String,
pub lost_files: HashSet<String>
}
// Trait Impls
impl OperationWriteExecute for GetOperation {
fn to_bytes(&self) -> BoxedErrorResult<Vec<u8>> {
Ok(create_buf(&self, str_to_vec("GET ")))
}
fn execute(&self, source: Source) -> BoxedErrorResult<Vec<SendableOperation>> {
let local_path = distributed_file_path(&self.distributed_filename);
let data_buf = async_std::task::block_on(read_file_to_buf(&local_path))?;
let operation = SendableOperation::for_single_tcp_stream(
TryInto::<async_std::net::TcpStream>::try_into(source)?,
Box::new(SendFileOperation {
filename: self.local_path.clone(),
data: data_buf,
is_distributed: false
}));
async_std::task::block_on(operation.write_all_tcp_async());
Ok(vec![])
}
fn to_string(&self) -> String { format!("{:?}", self) }
}
impl OperationWriteExecute for NewFileOwnersOperation {
fn to_bytes(&self) | random_line_split |
|
filesystem.rs | = args[0];
let distributed_filename = args[1];
// Figure out who I am giving this file to
let dest_ids = gen_file_owners(&distributed_filename)?;
// Gossip who has the file now
sender.send(
SendableOperation::for_successors(Box::new(NewFileOwnersOperation {
distributed_filename: distributed_filename.to_string(),
new_owners: dest_ids
.iter()
.map(|x| x.to_string())
.collect::<HashSet<_>>()
}))
)?;
// Send them the file
async_std::task::block_on(send_file_to_all(local_path.to_string(),
distributed_filename.to_string(),
&dest_ids))?;
Ok(())
}
pub fn ls(args: Vec<&str>) -> BoxedErrorResult<()> {
check_joined()?;
let invalid_args: BoxedErrorResult<()> = Err("Usage: ls [distributed_filename]".into());
match args.len() {
0 => {
// All
print_file_owners(None, true)?;
Ok(())
},
1 => {
// Just File
let distributed_filename = args[0];
print_file_owners(Some(distributed_filename), false)?;
Ok(())
},
_ => invalid_args
}
}
// TODO: You wrote this very late - maybe fix
fn print_file_owners(maybe_distributed_filename: Option<&str>, full: bool) -> BoxedErrorResult<()> {
let all_file_owners = globals::ALL_FILE_OWNERS.read();
match (maybe_distributed_filename, full) {
(Some(_), true) => {
Err("Cannot set distributed_filename and full to true when printing owners".into())
},
(Some(distributed_filename), false) => {
// Print the files owners
match all_file_owners.get(distributed_filename) {
Some(owners) => {
println!("{:?}", owners);
},
None => {
// A little unoptimal - change if above format changes
println!("{{}}");
}
}
Ok(())
},
(None, true) => {
// Print the whole map
println!("{:?}", *all_file_owners);
Ok(())
},
(None, false) => {
Err("Cannot print owners of nonexistant distributed_filename with full set to false".into())
}
}
}
async fn get_distributed_file(distributed_filename: String, local_path: String) -> BoxedErrorResult<()> {
// TODO: Find owners
let operation = SendableOperation::for_owners(&distributed_filename, Box::new(GetOperation {
distributed_filename: distributed_filename.clone(),
local_path: local_path
}));
let mut streams = operation
.write_all_tcp_async()
.await?;
// TODO: Redo whatever tf going on here
match streams.len() {
0 => Err(format!("No owners found for file {}", distributed_filename).into()),
_ => {
let (result, source) = streams[0]
.try_read_operation()
.await?;
result.execute(source)?;
Ok(())
}
}
}
async fn read_file_to_buf(local_path: &String) -> BoxedErrorResult<Vec<u8>> {
let mut data_buf: Vec<u8> = Vec::new();
let mut file = async_std::fs::File::open(&local_path).await?;
file.read_to_end(&mut data_buf).await?;
Ok(data_buf)
}
async fn send_file_to_all(local_path: String, distributed_filename: String, dest_ids: &Vec<String>) ->
BoxedErrorResult<()> {
let data_buf = read_file_to_buf(&local_path).await?;
let operation = SendableOperation::for_id_list(dest_ids.clone(), Box::new(SendFileOperation {
filename: distributed_filename,
data: data_buf,
is_distributed: true
}));
operation.write_all_tcp_async().await?;
Ok(())
}
pub async fn file_server<'a>(_sender: &'a OperationSender) -> BoxedErrorResult<()> |
async fn handle_connection(mut connection: async_std::net::TcpStream) -> BoxedErrorResult<()> {
let (operation, source) = connection.try_read_operation().await?;
// TODO: Think about what standard we want with these
let _generated_operations = operation.execute(source)?;
Ok(())
}
// Helpers
fn gen_file_owners(filename: &str) -> BoxedErrorResult<Vec<String>> {
let file_idx = filename.easyhash();
heartbeat::gen_neighbor_list_from(file_idx as i32, 1, constants::NUM_OWNERS, true)
}
// TODO: This function makes the entire system assume there are always at least two nodes in the system
// and the file must have an owner or else the operation will not work correctly. This is fine for now
// but it is worth improving sooner rather than later (make distinct Error types to differentiate, etc).
fn gen_new_file_owner(filename: &str) -> BoxedErrorResult<String> {
match globals::ALL_FILE_OWNERS.read().get(filename) {
Some(owners) => {
let potential_owners = gen_file_owners(filename)?;
for potential_owner in &potential_owners {
if !owners.contains(potential_owner) {
return Ok(potential_owner.clone());
}
}
Err(format!("No new owners available for file {}", filename).into())
},
None => Err(format!("No owner found for file {}", filename).into())
}
}
fn distributed_file_path(filename: &String) -> String {
format!("{}/{}", constants::DATA_DIR, filename)
}
// Returns messages to be gossiped
pub fn handle_failed_node(failed_id: &String) -> BoxedErrorResult<Vec<SendableOperation>> {
match heartbeat::is_master() {
true => {
let mut generated_operations: Vec<SendableOperation> = Vec::new();
let myself_source = Source::myself();
// Find files they owned
let mut lost_files: HashSet<String> = HashSet::new();
for (distributed_filename, owners) in globals::ALL_FILE_OWNERS.read().iter() {
if owners.contains(failed_id) {
lost_files.insert(distributed_filename.clone());
}
}
log("Found lost files".to_string());
// Send that they no longer own those files
// Separate operation so that this acts like a confirmation to fully forget about the node from
// the master. Can be used with a delay later if you want more error resistance.
let lost_file_operation = LostFilesOperation {
failed_owner: failed_id.clone(),
lost_files: lost_files.clone()
};
generated_operations.append(&mut lost_file_operation.execute(myself_source.clone())?);
log("Executed lost files operation locally".to_string());
// Gen new owners of the file and propagate
let mut new_owners: HashMap<String, HashSet<String>> = HashMap::new();
for lost_file in &lost_files {
let new_owner = gen_new_file_owner(&lost_file)?;
// TODO: Maybe optimize this into one fat packet - probably a new operation?
let new_owner_operation = NewFileOwnersOperation {
distributed_filename: lost_file.clone(),
new_owners: vec![new_owner].iter().map(|x| x.to_string()).collect()
};
generated_operations.append(&mut new_owner_operation.execute(myself_source.clone())?);
}
log("Executed all new_owner operations locally".to_string());
Ok(generated_operations)
},
false => {
Ok(vec![])
}
}
}
// Operations
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GetOperation {
pub distributed_filename: String,
pub local_path: String
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct NewFileOwnersOperation {
pub distributed_filename: String,
pub new_owners: HashSet<String>
}
#[derive(Serialize, Deserialize, Clone)]
pub struct SendFileOperation {
pub filename: String,
pub data: Vec<u8>,
pub is_distributed: bool
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct LostFilesOperation {
pub failed_owner: String,
pub lost_files: HashSet<String>
}
// Trait Impls
impl OperationWriteExecute for GetOperation {
fn to_bytes(&self) -> BoxedErrorResult<Vec<u8>> {
Ok(create_buf(&self, str_to_vec("GET ")))
}
fn execute(&self, source: Source) -> BoxedErrorResult<Vec<SendableOperation>> {
let local_path = distributed_file_path(&self.distributed_filename);
let data_buf = async_std::task::block_on(read_file_to_buf(&local_path))?;
let operation = SendableOperation::for_single_tcp_stream(
TryInto::<async_std::net::TcpStream>::try_into(source)?,
Box::new(SendFileOperation {
filename: self.local_path.clone(),
data: data_buf,
is_distributed: false
}));
async_std::task::block_on(operation.write_all_tcp_async());
Ok(vec![])
}
fn to_string(&self) -> String { format!("{:?}", self) }
}
impl OperationWriteExecute for NewFileOwnersOperation {
fn to_bytes(&self | {
let server = globals::SERVER_SOCKET.read();
let mut incoming = server.incoming();
while let Some(stream) = incoming.next().await {
let connection = stream?;
log(format!("Handling connection from {:?}", connection.peer_addr()));
spawn(handle_connection(connection));
}
Ok(())
} | identifier_body |
main.rs | let guid = &item.guid;
items.entry(&guid).or_insert_with(|| Item {
title: item.title.to_owned(),
link: item.link.to_owned(),
content: item.content.to_owned(),
pub_date: item.pub_date.to_owned(),
guid: guid.to_owned(),
unread: true,
});
}
self.items = items.drain().map(|(_, v)| v).collect();
self.items.sort_by_key(|item| item.pub_date.clone());
}
}
#[derive(Serialize)]
struct FeedInfo {
pub url: String,
pub title: String,
pub last_updated: DateTime<Utc>,
}
struct DownloadFeed(String);
#[derive(Deserialize)]
struct AddFeed { url: String }
#[derive(Deserialize)]
struct RemoveFeed { url: String }
#[derive(Deserialize, Debug)]
struct GetFeed { url: String }
struct ListFeeds;
#[derive(Deserialize, Debug)]
struct MarkRead { url: String, guid: String }
#[derive(Message)]
struct UpdateFeed { url: String, feed: Feed }
impl Message for DownloadFeed {
type Result = Result<Feed, String>;
}
impl Message for AddFeed {
type Result = Result<(), String>;
}
impl Message for RemoveFeed {
type Result = Result<(), String>;
}
impl Message for GetFeed {
type Result = Result<Feed, String>;
}
impl Message for ListFeeds {
type Result = Result<Vec<FeedInfo>, String>;
}
impl Message for MarkRead {
type Result = Result<bool, String>;
}
struct FeedStorage {
feeds: HashMap<String, Feed>,
downloader: actix::Addr<Downloader>,
}
impl Actor for FeedStorage {
type Context = actix::SyncContext<Self>;
}
impl Handler<DownloadFeed> for FeedStorage {
type Result = <DownloadFeed as Message>::Result;
fn handle(&mut self, msg: DownloadFeed, _: &mut Self::Context) -> Self::Result {
self.downloader.send(msg).wait().or_err("Download failed")?
}
}
impl Handler<AddFeed> for FeedStorage {
type Result = <AddFeed as Message>::Result;
fn handle(&mut self, msg: AddFeed, _: &mut Self::Context) -> Self::Result {
match self.feeds.entry(msg.url.clone()) {
std::collections::hash_map::Entry::Occupied(_) => Err("Feed already exists".into()),
std::collections::hash_map::Entry::Vacant(e) => {
debug!("will download {}", &msg.url);
self.downloader.send(DownloadFeed(msg.url))
.wait()
.or_err("Failed to download")?
.map(|feed| {
debug!("downloaded");
e.insert(feed);
})
}
}
}
}
impl Handler<RemoveFeed> for FeedStorage {
type Result = <RemoveFeed as Message>::Result;
fn handle(&mut self, msg: RemoveFeed, _: &mut Self::Context) -> Self::Result {
self.feeds.remove(&msg.url);
Ok(())
}
}
impl Handler<GetFeed> for FeedStorage {
type Result = <GetFeed as Message>::Result;
fn handle(&mut self, msg: GetFeed, _: &mut Self::Context) -> Self::Result {
match self.feeds.get(&msg.url) {
None => Err("Feed not found".into()),
Some(feed) => Ok(feed.clone()),
}
}
}
impl Handler<ListFeeds> for FeedStorage {
type Result = <ListFeeds as Message>::Result;
fn handle(&mut self, _: ListFeeds, _: &mut Self::Context) -> Self::Result {
Ok(self.feeds.iter().map(|(k, v)| FeedInfo{url: k.clone(), title: v.title.clone(), last_updated: v.last_updated.clone()}).collect())
}
}
impl Handler<MarkRead> for FeedStorage {
type Result = <MarkRead as Message>::Result;
fn handle(&mut self, msg: MarkRead, _: &mut Self::Context) -> Self::Result {
let mut updated = false;
if let Some(feed) = self.feeds.get_mut(&msg.url) {
for item in feed.items.iter_mut().filter(|k| &k.guid == &msg.guid).take(1) {
item.unread = false;
updated = true;
}
}
Ok(updated)
}
}
impl Handler<UpdateFeed> for FeedStorage {
type Result = <UpdateFeed as Message>::Result;
fn handle(&mut self, msg: UpdateFeed, _: &mut Self::Context) -> Self::Result {
if let Some(feed) = self.feeds.get_mut(&msg.url) | ;
}
}
struct Downloader;
impl Actor for Downloader {
type Context = actix::Context<Self>;
}
impl Handler<DownloadFeed> for Downloader {
type Result = <DownloadFeed as Message>::Result;
fn handle(&mut self, msg: DownloadFeed, _: &mut Self::Context) -> Self::Result {
let channel = rss::Channel::from_url(&msg.0).or_err("Channel not downloaded")?;
let mut items = vec![];
for item in channel.items().iter() {
let guid = item.guid().or_err("broken channel")?.value();
items.push(Item {
title: item.title().map(|s| s.to_string()),
link: item.link().map(|s| s.to_string()),
content: item.content().or(item.description()).map(|s| s.to_string()),
pub_date: item.pub_date().and_then(|date| DateTime::parse_from_rfc2822(date).ok().map(|d| d.with_timezone(&Utc))),
guid: guid.to_string(),
unread: true,
});
}
Ok(Feed{
title: channel.title().to_owned(),
last_updated: match channel.last_build_date() {
None => items
.iter()
.map(|item| &item.pub_date)
.max()
.map(|date| date.to_owned())
.unwrap_or(Some(Utc.timestamp(0, 0)))
.unwrap_or(Utc.timestamp(0, 0)),
Some(s) => DateTime::parse_from_rfc2822(s).map(|d| d.with_timezone(&Utc)).unwrap_or(Utc.timestamp(0, 0))
},
items: items
})
}
}
struct Updater {
storage: actix::Addr<FeedStorage>,
downloader: actix::Addr<Downloader>,
handle: Option<actix::SpawnHandle>,
arbiter: actix::Arbiter,
}
impl Actor for Updater {
type Context = actix::Context<Self>;
fn started(&mut self, ctx: &mut <Self as Actor>::Context) {
let storage = self.storage.clone();
let downloader = self.downloader.clone();
let arbiter = self.arbiter.clone();
self.handle = Some(ctx.run_interval(std::time::Duration::new(60, 0), move |_, _| {
let storage = storage.clone();
let downloader = downloader.clone();
let arbiter = arbiter.clone();
arbiter.exec_fn(move || {
if let Ok(Ok(infos)) = storage.send(ListFeeds).wait() {
debug!("got {} feeds, updating", infos.len());
for info in infos {
if let Ok(Ok(new_feed)) = downloader.send(DownloadFeed(info.url.clone())).wait() {
if let Ok(()) = storage.send(UpdateFeed{url: info.url.clone(), feed: new_feed}).wait() {
debug!("successfully updated {}", info.url);
}
}
}
}
});
}));
}
}
fn process_response<T: Serialize, E: Serialize, E2, F: FnOnce(E) -> actix_web::Error>(response: Result<Result<T, E>, E2>, f: F) -> Result<HttpResponse, actix_web::Error> {
match response {
Ok(Ok(data)) => Ok(HttpResponse::Ok().json(data)),
Ok(Err(e)) => Err(f(e)),
_ => Err(actix_web::error::ErrorInternalServerError("Application overload"))
}
}
#[derive(Clone)]
struct State { storage: actix::Addr<FeedStorage> }
fn add_feed(url_info: web::Form<AddFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorInternalServerError))
}
fn remove_feed(url_info: web::Form<RemoveFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorInternalServerError))
}
fn get_feed(url_info: web::Query<GetFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorNotFound))
}
fn list_feeds(data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(ListFeeds).wait())
.then(|res| process_response(res, actix_web:: | {
feed.merge(msg.feed)
} | conditional_block |
main.rs | Entry::Occupied(_) => Err("Feed already exists".into()),
std::collections::hash_map::Entry::Vacant(e) => {
debug!("will download {}", &msg.url);
self.downloader.send(DownloadFeed(msg.url))
.wait()
.or_err("Failed to download")?
.map(|feed| {
debug!("downloaded");
e.insert(feed);
})
}
}
}
}
impl Handler<RemoveFeed> for FeedStorage {
type Result = <RemoveFeed as Message>::Result;
fn handle(&mut self, msg: RemoveFeed, _: &mut Self::Context) -> Self::Result {
self.feeds.remove(&msg.url);
Ok(())
}
}
impl Handler<GetFeed> for FeedStorage {
type Result = <GetFeed as Message>::Result;
fn handle(&mut self, msg: GetFeed, _: &mut Self::Context) -> Self::Result {
match self.feeds.get(&msg.url) {
None => Err("Feed not found".into()),
Some(feed) => Ok(feed.clone()),
}
}
}
impl Handler<ListFeeds> for FeedStorage {
type Result = <ListFeeds as Message>::Result;
fn handle(&mut self, _: ListFeeds, _: &mut Self::Context) -> Self::Result {
Ok(self.feeds.iter().map(|(k, v)| FeedInfo{url: k.clone(), title: v.title.clone(), last_updated: v.last_updated.clone()}).collect())
}
}
impl Handler<MarkRead> for FeedStorage {
type Result = <MarkRead as Message>::Result;
fn handle(&mut self, msg: MarkRead, _: &mut Self::Context) -> Self::Result {
let mut updated = false;
if let Some(feed) = self.feeds.get_mut(&msg.url) {
for item in feed.items.iter_mut().filter(|k| &k.guid == &msg.guid).take(1) {
item.unread = false;
updated = true;
}
}
Ok(updated)
}
}
impl Handler<UpdateFeed> for FeedStorage {
type Result = <UpdateFeed as Message>::Result;
fn handle(&mut self, msg: UpdateFeed, _: &mut Self::Context) -> Self::Result {
if let Some(feed) = self.feeds.get_mut(&msg.url) {
feed.merge(msg.feed)
};
}
}
struct Downloader;
impl Actor for Downloader {
type Context = actix::Context<Self>;
}
impl Handler<DownloadFeed> for Downloader {
type Result = <DownloadFeed as Message>::Result;
fn handle(&mut self, msg: DownloadFeed, _: &mut Self::Context) -> Self::Result {
let channel = rss::Channel::from_url(&msg.0).or_err("Channel not downloaded")?;
let mut items = vec![];
for item in channel.items().iter() {
let guid = item.guid().or_err("broken channel")?.value();
items.push(Item {
title: item.title().map(|s| s.to_string()),
link: item.link().map(|s| s.to_string()),
content: item.content().or(item.description()).map(|s| s.to_string()),
pub_date: item.pub_date().and_then(|date| DateTime::parse_from_rfc2822(date).ok().map(|d| d.with_timezone(&Utc))),
guid: guid.to_string(),
unread: true,
});
}
Ok(Feed{
title: channel.title().to_owned(),
last_updated: match channel.last_build_date() {
None => items
.iter()
.map(|item| &item.pub_date)
.max()
.map(|date| date.to_owned())
.unwrap_or(Some(Utc.timestamp(0, 0)))
.unwrap_or(Utc.timestamp(0, 0)),
Some(s) => DateTime::parse_from_rfc2822(s).map(|d| d.with_timezone(&Utc)).unwrap_or(Utc.timestamp(0, 0))
},
items: items
})
}
}
struct Updater {
storage: actix::Addr<FeedStorage>,
downloader: actix::Addr<Downloader>,
handle: Option<actix::SpawnHandle>,
arbiter: actix::Arbiter,
}
impl Actor for Updater {
type Context = actix::Context<Self>;
fn started(&mut self, ctx: &mut <Self as Actor>::Context) {
let storage = self.storage.clone();
let downloader = self.downloader.clone();
let arbiter = self.arbiter.clone();
self.handle = Some(ctx.run_interval(std::time::Duration::new(60, 0), move |_, _| {
let storage = storage.clone();
let downloader = downloader.clone();
let arbiter = arbiter.clone();
arbiter.exec_fn(move || {
if let Ok(Ok(infos)) = storage.send(ListFeeds).wait() {
debug!("got {} feeds, updating", infos.len());
for info in infos {
if let Ok(Ok(new_feed)) = downloader.send(DownloadFeed(info.url.clone())).wait() {
if let Ok(()) = storage.send(UpdateFeed{url: info.url.clone(), feed: new_feed}).wait() {
debug!("successfully updated {}", info.url);
}
}
}
}
});
}));
}
}
fn process_response<T: Serialize, E: Serialize, E2, F: FnOnce(E) -> actix_web::Error>(response: Result<Result<T, E>, E2>, f: F) -> Result<HttpResponse, actix_web::Error> {
match response {
Ok(Ok(data)) => Ok(HttpResponse::Ok().json(data)),
Ok(Err(e)) => Err(f(e)),
_ => Err(actix_web::error::ErrorInternalServerError("Application overload"))
}
}
#[derive(Clone)]
struct State { storage: actix::Addr<FeedStorage> }
fn add_feed(url_info: web::Form<AddFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorInternalServerError))
}
fn remove_feed(url_info: web::Form<RemoveFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorInternalServerError))
}
fn get_feed(url_info: web::Query<GetFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorNotFound))
}
fn list_feeds(data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(ListFeeds).wait())
.then(|res| process_response(res, actix_web::error::ErrorInternalServerError))
}
fn mark_read(url_info: web::Form<MarkRead>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorInternalServerError))
}
fn actix_main() -> Result<(), std::io::Error> {
let downloader_addr = Downloader.start();
let feed_storage_addr = {
let addr = downloader_addr.clone();
actix::SyncArbiter::start(1, move || FeedStorage{
feeds: HashMap::new(),
downloader: addr.clone(),
})
};
let state = State{storage: feed_storage_addr.clone()};
let updater = Updater{storage: feed_storage_addr, downloader: downloader_addr.clone(), handle: None, arbiter: actix::Arbiter::new()};
updater.start();
let mut server = actix_web::HttpServer::new(move || {
App::new()
.data(state.clone())
.wrap(
Cors::new()
.allowed_methods(vec!["GET", "POST", "OPTIONS"])
.allowed_headers(vec![
http::header::ACCEPT,
http::header::CONTENT_TYPE,
http::header::HeaderName::from_static("x-requested-with")
])
.max_age(3600)
)
.wrap(actix_web::middleware::Logger::default())
.route("/add", web::post().to_async(add_feed))
.route("/remove", web::post().to_async(remove_feed))
.route("/read", web::post().to_async(mark_read))
.route("/list", web::get().to_async(list_feeds))
.route("/get", web::get().to_async(get_feed))
});
let mut listenfd = listenfd::ListenFd::from_env();
server = if let Some(l) = listenfd.take_tcp_listener(0)? { | server.listen(l)?
} else {
server.bind("[::1]:8000")?
};
println!("Started HTTP server on {:?}", server.addrs_with_scheme().iter().map(|(a, s)| format!("{}://{}/", s, a)).collect::<Vec<_>>()); | random_line_split |
|
main.rs | {
pub title: Option<String>,
pub link: Option<String>,
pub content: Option<String>,
pub pub_date: Option<DateTime<Utc>>,
pub guid: String,
pub unread: bool,
}
#[derive(Clone, Debug, Serialize)]
struct Feed {
pub title: String,
pub last_updated: DateTime<Utc>,
pub items: Vec<Item>,
}
impl Feed {
pub fn merge(&mut self, other: Feed) {
self.title = other.title;
self.last_updated = other.last_updated;
let mut items: HashMap<&str, Item> = self.items.iter().map(|item| (item.guid.as_str(), item.clone())).collect();
for item in other.items.iter() {
let guid = &item.guid;
items.entry(&guid).or_insert_with(|| Item {
title: item.title.to_owned(),
link: item.link.to_owned(),
content: item.content.to_owned(),
pub_date: item.pub_date.to_owned(),
guid: guid.to_owned(),
unread: true,
});
}
self.items = items.drain().map(|(_, v)| v).collect();
self.items.sort_by_key(|item| item.pub_date.clone());
}
}
#[derive(Serialize)]
struct FeedInfo {
pub url: String,
pub title: String,
pub last_updated: DateTime<Utc>,
}
struct DownloadFeed(String);
#[derive(Deserialize)]
struct AddFeed { url: String }
#[derive(Deserialize)]
struct RemoveFeed { url: String }
#[derive(Deserialize, Debug)]
struct GetFeed { url: String }
struct ListFeeds;
#[derive(Deserialize, Debug)]
struct MarkRead { url: String, guid: String }
#[derive(Message)]
struct UpdateFeed { url: String, feed: Feed }
impl Message for DownloadFeed {
type Result = Result<Feed, String>;
}
impl Message for AddFeed {
type Result = Result<(), String>;
}
impl Message for RemoveFeed {
type Result = Result<(), String>;
}
impl Message for GetFeed {
type Result = Result<Feed, String>;
}
impl Message for ListFeeds {
type Result = Result<Vec<FeedInfo>, String>;
}
impl Message for MarkRead {
type Result = Result<bool, String>;
}
struct FeedStorage {
feeds: HashMap<String, Feed>,
downloader: actix::Addr<Downloader>,
}
impl Actor for FeedStorage {
type Context = actix::SyncContext<Self>;
}
impl Handler<DownloadFeed> for FeedStorage {
type Result = <DownloadFeed as Message>::Result;
fn handle(&mut self, msg: DownloadFeed, _: &mut Self::Context) -> Self::Result {
self.downloader.send(msg).wait().or_err("Download failed")?
}
}
impl Handler<AddFeed> for FeedStorage {
type Result = <AddFeed as Message>::Result;
fn handle(&mut self, msg: AddFeed, _: &mut Self::Context) -> Self::Result {
match self.feeds.entry(msg.url.clone()) {
std::collections::hash_map::Entry::Occupied(_) => Err("Feed already exists".into()),
std::collections::hash_map::Entry::Vacant(e) => {
debug!("will download {}", &msg.url);
self.downloader.send(DownloadFeed(msg.url))
.wait()
.or_err("Failed to download")?
.map(|feed| {
debug!("downloaded");
e.insert(feed);
})
}
}
}
}
impl Handler<RemoveFeed> for FeedStorage {
type Result = <RemoveFeed as Message>::Result;
fn handle(&mut self, msg: RemoveFeed, _: &mut Self::Context) -> Self::Result {
self.feeds.remove(&msg.url);
Ok(())
}
}
impl Handler<GetFeed> for FeedStorage {
type Result = <GetFeed as Message>::Result;
fn handle(&mut self, msg: GetFeed, _: &mut Self::Context) -> Self::Result {
match self.feeds.get(&msg.url) {
None => Err("Feed not found".into()),
Some(feed) => Ok(feed.clone()),
}
}
}
impl Handler<ListFeeds> for FeedStorage {
type Result = <ListFeeds as Message>::Result;
fn handle(&mut self, _: ListFeeds, _: &mut Self::Context) -> Self::Result {
Ok(self.feeds.iter().map(|(k, v)| FeedInfo{url: k.clone(), title: v.title.clone(), last_updated: v.last_updated.clone()}).collect())
}
}
impl Handler<MarkRead> for FeedStorage {
type Result = <MarkRead as Message>::Result;
fn handle(&mut self, msg: MarkRead, _: &mut Self::Context) -> Self::Result {
let mut updated = false;
if let Some(feed) = self.feeds.get_mut(&msg.url) {
for item in feed.items.iter_mut().filter(|k| &k.guid == &msg.guid).take(1) {
item.unread = false;
updated = true;
}
}
Ok(updated)
}
}
impl Handler<UpdateFeed> for FeedStorage {
type Result = <UpdateFeed as Message>::Result;
fn handle(&mut self, msg: UpdateFeed, _: &mut Self::Context) -> Self::Result {
if let Some(feed) = self.feeds.get_mut(&msg.url) {
feed.merge(msg.feed)
};
}
}
struct Downloader;
impl Actor for Downloader {
type Context = actix::Context<Self>;
}
impl Handler<DownloadFeed> for Downloader {
type Result = <DownloadFeed as Message>::Result;
fn handle(&mut self, msg: DownloadFeed, _: &mut Self::Context) -> Self::Result {
let channel = rss::Channel::from_url(&msg.0).or_err("Channel not downloaded")?;
let mut items = vec![];
for item in channel.items().iter() {
let guid = item.guid().or_err("broken channel")?.value();
items.push(Item {
title: item.title().map(|s| s.to_string()),
link: item.link().map(|s| s.to_string()),
content: item.content().or(item.description()).map(|s| s.to_string()),
pub_date: item.pub_date().and_then(|date| DateTime::parse_from_rfc2822(date).ok().map(|d| d.with_timezone(&Utc))),
guid: guid.to_string(),
unread: true,
});
}
Ok(Feed{
title: channel.title().to_owned(),
last_updated: match channel.last_build_date() {
None => items
.iter()
.map(|item| &item.pub_date)
.max()
.map(|date| date.to_owned())
.unwrap_or(Some(Utc.timestamp(0, 0)))
.unwrap_or(Utc.timestamp(0, 0)),
Some(s) => DateTime::parse_from_rfc2822(s).map(|d| d.with_timezone(&Utc)).unwrap_or(Utc.timestamp(0, 0))
},
items: items
})
}
}
struct Updater {
storage: actix::Addr<FeedStorage>,
downloader: actix::Addr<Downloader>,
handle: Option<actix::SpawnHandle>,
arbiter: actix::Arbiter,
}
impl Actor for Updater {
type Context = actix::Context<Self>;
fn started(&mut self, ctx: &mut <Self as Actor>::Context) {
let storage = self.storage.clone();
let downloader = self.downloader.clone();
let arbiter = self.arbiter.clone();
self.handle = Some(ctx.run_interval(std::time::Duration::new(60, 0), move |_, _| {
let storage = storage.clone();
let downloader = downloader.clone();
let arbiter = arbiter.clone();
arbiter.exec_fn(move || {
if let Ok(Ok(infos)) = storage.send(ListFeeds).wait() {
debug!("got {} feeds, updating", infos.len());
for info in infos {
if let Ok(Ok(new_feed)) = downloader.send(DownloadFeed(info.url.clone())).wait() {
if let Ok(()) = storage.send(UpdateFeed{url: info.url.clone(), feed: new_feed}).wait() {
debug!("successfully updated {}", info.url);
}
}
}
}
});
}));
}
}
fn process_response<T: Serialize, E: Serialize, E2, F: FnOnce(E) -> actix_web::Error>(response: Result<Result<T, E>, E2>, f: F) -> Result<HttpResponse, actix_web::Error> {
match response {
Ok(Ok(data)) => Ok(HttpResponse::Ok().json(data)),
Ok(Err(e)) => Err(f(e)),
_ => Err(actix_web::error::ErrorInternalServerError("Application overload"))
}
}
#[derive(Clone)]
struct State { storage: actix::Addr<FeedStorage> }
fn add_feed(url_info: web::Form<AddFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()).wait())
.then(|res| process_response(res, actix_web::error::ErrorInternalServerError))
}
fn remove_feed(url_info: web::Form<RemoveFeed>, data: web::Data<State>) -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
web::block(move || data.storage.send(url_info.into_inner()). | Item | identifier_name |
|
sssmc39_scheme.rs | cover_secret(&self.member_shares, self.member_threshold)
}
}
/// Split a master secret into mnemonic shares
/// group_threshold: The number of groups required to reconstruct the master secret
/// groups: A list of (member_threshold, member_count) pairs for each group, where member_count
/// is the number of shares to generate for the group and member_threshold is the number of
/// members required to reconstruct the group secret.
/// master_secret: The master secret to split.
/// passphrase: The passphrase used to encrypt the master secret.
/// iteration_exponent: The iteration exponent.
/// return: List of mnemonics.
pub fn generate_mnemonics(
group_threshold: u8,
groups: &[(u8, u8)],
master_secret: &[u8],
passphrase: &str,
iteration_exponent: u8,
) -> Result<Vec<GroupShare>, Error> {
// Generate a 'proto share' so to speak, with identifer generated and group data filled
let mut proto_share = Share::new()?;
proto_share.group_threshold = group_threshold;
proto_share.group_count = groups.len() as u8;
if master_secret.len() * 8 < proto_share.config.min_strength_bits as usize {
return Err(ErrorKind::Value(format!(
"The length of the master secret ({} bytes) must be at least {} bytes.",
master_secret.len(),
(f64::from(proto_share.config.min_strength_bits) / 8f64).ceil(),
)))?;
}
if master_secret.len() % 2 != 0 {
return Err(ErrorKind::Value(
"The length of the master secret in bytes must be an even number".to_string(),
))?;
}
if group_threshold as usize > groups.len() {
return Err(ErrorKind::Value(format!(
"The requested group threshold ({}) must not exceed the number of groups ({}).",
group_threshold,
groups.len()
)))?;
}
let encoder = util::encrypt::MasterSecretEnc::new()?;
let encrypted_master_secret = encoder.encrypt(
master_secret,
passphrase,
iteration_exponent,
proto_share.identifier,
);
let sp = Splitter::new(None);
let group_shares = sp.split_secret(
&proto_share,
group_threshold,
groups.len() as u8,
&encrypted_master_secret,
)?;
let mut retval: Vec<GroupShare> = vec![];
let gs_len = group_shares.len();
for (i, elem) in group_shares.into_iter().enumerate() {
proto_share.group_index = i as u8;
proto_share.group_threshold = group_threshold;
proto_share.group_count = gs_len as u8;
let (member_threshold, member_count) = groups[i];
let member_shares = sp.split_secret(
&proto_share,
member_threshold,
member_count,
&elem.share_value,
)?;
retval.push(GroupShare {
group_id: proto_share.identifier,
iteration_exponent,
group_index: i as u8,
group_threshold,
group_count: gs_len as u8,
member_threshold,
member_shares,
});
}
Ok(retval)
}
pub fn generate_mnemonics_random(
group_threshold: u8,
groups: &[(u8, u8)],
strength_bits: u16,
passphrase: &str,
iteration_exponent: u8,
) -> Result<Vec<GroupShare>, Error> {
let proto_share = Share::new()?;
if strength_bits < proto_share.config.min_strength_bits {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be at least {} bits.",
strength_bits, proto_share.config.min_strength_bits,
)))?;
}
if strength_bits % 16 != 0 {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be a multiple of 16 bits.",
strength_bits,
)))?;
}
generate_mnemonics(
group_threshold,
groups,
&util::fill_vec_rand(strength_bits as usize / 8),
passphrase,
iteration_exponent,
)
}
/// Combines mnemonic shares to obtain the master secret which was previously split using
/// Shamir's secret sharing scheme.
/// mnemonics: List of mnemonics.
/// passphrase: The passphrase used to encrypt the master secret.
/// return: The master secret.
pub fn combine_mnemonics(mnemonics: &[Vec<String>], passphrase: &str) -> Result<Vec<u8>, Error> {
let group_shares = decode_mnemonics(mnemonics)?;
let mut shares = vec![];
for mut gs in group_shares {
shares.push(gs.decode_shares()?);
}
let sp = Splitter::new(None);
// restore proper member index for groups
let shares = shares
.into_iter()
.map(|mut s| {
s.member_index = s.group_index;
s
})
.collect::<Vec<_>>();
let ems = sp.recover_secret(&shares, shares[0].group_threshold)?;
let encoder = util::encrypt::MasterSecretEnc::new()?;
let dms = encoder.decrypt( | );
Ok(dms)
}
/// Decodes all Mnemonics to a list of shares and performs error checking
fn decode_mnemonics(mnemonics: &[Vec<String>]) -> Result<Vec<GroupShare>, Error> {
let mut shares = vec![];
if mnemonics.is_empty() {
return Err(ErrorKind::Mnemonic(
"List of mnemonics is empty.".to_string(),
))?;
}
let check_len = mnemonics[0].len();
for m in mnemonics {
if m.len() != check_len {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same length.".to_string(),
))?;
}
shares.push(Share::from_mnemonic(m)?);
}
let check_share = shares[0].clone();
for s in shares.iter() {
if s.identifier != check_share.identifier
|| s.iteration_exponent != check_share.iteration_exponent
{
return Err(ErrorKind::Mnemonic(format!(
"Invalid set of mnemonics. All mnemonics must begin with the same {} words. \
(Identifier and iteration exponent must be the same).",
s.config.id_exp_length_words,
)))?;
}
if s.group_threshold != check_share.group_threshold {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group threshold"
.to_string(),
))?;
}
if s.group_count != check_share.group_count {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group count"
.to_string(),
))?;
}
}
let mut group_index_map = BTreeMap::new();
for s in shares {
if !group_index_map.contains_key(&s.group_index) {
let group_share = GroupShare {
group_id: s.identifier,
group_index: s.group_index,
group_threshold: s.group_threshold,
iteration_exponent: s.iteration_exponent,
group_count: s.group_count,
member_shares: vec![s.clone()],
member_threshold: s.member_threshold,
};
group_index_map.insert(group_share.group_index, group_share);
} else {
let e = group_index_map.get_mut(&s.group_index).unwrap();
e.member_shares.push(s);
}
}
if group_index_map.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonic groups ({}). The required number \
of groups is {}.",
group_index_map.len(),
check_share.group_threshold,
)))?;
}
let groups: Vec<GroupShare> = group_index_map
.into_iter()
.map(|g| g.1)
// remove groups where number of shares is below the member threshold
.filter(|g| g.member_shares.len() >= g.member_threshold as usize)
.collect();
if groups.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(
"Insufficient number of groups with member counts that meet member threshold."
.to_string(),
))?;
}
// TODO: Should probably return info making problem mnemonics easier to identify
for g in groups.iter() {
if g.member_shares.len() < g.member_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonics (Group {}). At least {} mnemonics \
are required.",
g.group_index, g.member_threshold,
)))?;
}
let test_share = g.member_shares[0].clone();
for ms in g.member_shares.iter() {
if test_share.member_threshold != ms.member_threshold {
return Err(ErrorKind::Mnemonic(
"Mismatching member thresholds".to_string(),
))?;
}
}
}
Ok(groups)
}
#[cfg(test)]
mod | &ems.share_value,
passphrase,
ems.iteration_exponent,
ems.identifier, | random_line_split |
sssmc39_scheme.rs | % 2 != 0 {
return Err(ErrorKind::Value(
"The length of the master secret in bytes must be an even number".to_string(),
))?;
}
if group_threshold as usize > groups.len() {
return Err(ErrorKind::Value(format!(
"The requested group threshold ({}) must not exceed the number of groups ({}).",
group_threshold,
groups.len()
)))?;
}
let encoder = util::encrypt::MasterSecretEnc::new()?;
let encrypted_master_secret = encoder.encrypt(
master_secret,
passphrase,
iteration_exponent,
proto_share.identifier,
);
let sp = Splitter::new(None);
let group_shares = sp.split_secret(
&proto_share,
group_threshold,
groups.len() as u8,
&encrypted_master_secret,
)?;
let mut retval: Vec<GroupShare> = vec![];
let gs_len = group_shares.len();
for (i, elem) in group_shares.into_iter().enumerate() {
proto_share.group_index = i as u8;
proto_share.group_threshold = group_threshold;
proto_share.group_count = gs_len as u8;
let (member_threshold, member_count) = groups[i];
let member_shares = sp.split_secret(
&proto_share,
member_threshold,
member_count,
&elem.share_value,
)?;
retval.push(GroupShare {
group_id: proto_share.identifier,
iteration_exponent,
group_index: i as u8,
group_threshold,
group_count: gs_len as u8,
member_threshold,
member_shares,
});
}
Ok(retval)
}
pub fn generate_mnemonics_random(
group_threshold: u8,
groups: &[(u8, u8)],
strength_bits: u16,
passphrase: &str,
iteration_exponent: u8,
) -> Result<Vec<GroupShare>, Error> {
let proto_share = Share::new()?;
if strength_bits < proto_share.config.min_strength_bits {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be at least {} bits.",
strength_bits, proto_share.config.min_strength_bits,
)))?;
}
if strength_bits % 16 != 0 {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be a multiple of 16 bits.",
strength_bits,
)))?;
}
generate_mnemonics(
group_threshold,
groups,
&util::fill_vec_rand(strength_bits as usize / 8),
passphrase,
iteration_exponent,
)
}
/// Combines mnemonic shares to obtain the master secret which was previously split using
/// Shamir's secret sharing scheme.
/// mnemonics: List of mnemonics.
/// passphrase: The passphrase used to encrypt the master secret.
/// return: The master secret.
pub fn combine_mnemonics(mnemonics: &[Vec<String>], passphrase: &str) -> Result<Vec<u8>, Error> {
let group_shares = decode_mnemonics(mnemonics)?;
let mut shares = vec![];
for mut gs in group_shares {
shares.push(gs.decode_shares()?);
}
let sp = Splitter::new(None);
// restore proper member index for groups
let shares = shares
.into_iter()
.map(|mut s| {
s.member_index = s.group_index;
s
})
.collect::<Vec<_>>();
let ems = sp.recover_secret(&shares, shares[0].group_threshold)?;
let encoder = util::encrypt::MasterSecretEnc::new()?;
let dms = encoder.decrypt(
&ems.share_value,
passphrase,
ems.iteration_exponent,
ems.identifier,
);
Ok(dms)
}
/// Decodes all Mnemonics to a list of shares and performs error checking
fn decode_mnemonics(mnemonics: &[Vec<String>]) -> Result<Vec<GroupShare>, Error> {
let mut shares = vec![];
if mnemonics.is_empty() {
return Err(ErrorKind::Mnemonic(
"List of mnemonics is empty.".to_string(),
))?;
}
let check_len = mnemonics[0].len();
for m in mnemonics {
if m.len() != check_len {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same length.".to_string(),
))?;
}
shares.push(Share::from_mnemonic(m)?);
}
let check_share = shares[0].clone();
for s in shares.iter() {
if s.identifier != check_share.identifier
|| s.iteration_exponent != check_share.iteration_exponent
{
return Err(ErrorKind::Mnemonic(format!(
"Invalid set of mnemonics. All mnemonics must begin with the same {} words. \
(Identifier and iteration exponent must be the same).",
s.config.id_exp_length_words,
)))?;
}
if s.group_threshold != check_share.group_threshold {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group threshold"
.to_string(),
))?;
}
if s.group_count != check_share.group_count {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group count"
.to_string(),
))?;
}
}
let mut group_index_map = BTreeMap::new();
for s in shares {
if !group_index_map.contains_key(&s.group_index) {
let group_share = GroupShare {
group_id: s.identifier,
group_index: s.group_index,
group_threshold: s.group_threshold,
iteration_exponent: s.iteration_exponent,
group_count: s.group_count,
member_shares: vec![s.clone()],
member_threshold: s.member_threshold,
};
group_index_map.insert(group_share.group_index, group_share);
} else {
let e = group_index_map.get_mut(&s.group_index).unwrap();
e.member_shares.push(s);
}
}
if group_index_map.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonic groups ({}). The required number \
of groups is {}.",
group_index_map.len(),
check_share.group_threshold,
)))?;
}
let groups: Vec<GroupShare> = group_index_map
.into_iter()
.map(|g| g.1)
// remove groups where number of shares is below the member threshold
.filter(|g| g.member_shares.len() >= g.member_threshold as usize)
.collect();
if groups.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(
"Insufficient number of groups with member counts that meet member threshold."
.to_string(),
))?;
}
// TODO: Should probably return info making problem mnemonics easier to identify
for g in groups.iter() {
if g.member_shares.len() < g.member_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonics (Group {}). At least {} mnemonics \
are required.",
g.group_index, g.member_threshold,
)))?;
}
let test_share = g.member_shares[0].clone();
for ms in g.member_shares.iter() {
if test_share.member_threshold != ms.member_threshold {
return Err(ErrorKind::Mnemonic(
"Mismatching member thresholds".to_string(),
))?;
}
}
}
Ok(groups)
}
#[cfg(test)]
mod tests {
use super::*;
fn flatten_mnemonics(nms: &[GroupShare]) -> Result<Vec<Vec<String>>, Error> {
let mut ret = vec![];
for m in nms {
for s in m.member_shares.iter() {
ret.push(s.to_mnemonic()?);
}
}
Ok(ret)
}
#[test]
fn generate_mnemonics_test() -> Result<(), Error> | {
let master_secret = b"\x0c\x94\x90\xbcn\xd6\xbc\xbf\xac>\xbe}\xeeV\xf2P".to_vec();
// single 3 of 5 test, splat out all mnemonics
println!("Single 3 of 5 Encoded: {:?}", master_secret);
let mns = generate_mnemonics(1, &[(3, 5)], &master_secret, "", 0)?;
for s in &mns {
println!("{}", s);
}
let result = combine_mnemonics(&flatten_mnemonics(&mns)?, "")?;
println!("Single 3 of 5 Decoded: {:?}", result);
assert_eq!(result, master_secret);
// Test a few distinct groups
let mns = generate_mnemonics(
2,
&[(3, 5), (2, 5), (3, 3), (13, 16)],
&master_secret,
"",
0, | identifier_body |
|
sssmc39_scheme.rs | _secret(&self.member_shares, self.member_threshold)
}
}
/// Split a master secret into mnemonic shares
/// group_threshold: The number of groups required to reconstruct the master secret
/// groups: A list of (member_threshold, member_count) pairs for each group, where member_count
/// is the number of shares to generate for the group and member_threshold is the number of
/// members required to reconstruct the group secret.
/// master_secret: The master secret to split.
/// passphrase: The passphrase used to encrypt the master secret.
/// iteration_exponent: The iteration exponent.
/// return: List of mnemonics.
pub fn generate_mnemonics(
group_threshold: u8,
groups: &[(u8, u8)],
master_secret: &[u8],
passphrase: &str,
iteration_exponent: u8,
) -> Result<Vec<GroupShare>, Error> {
// Generate a 'proto share' so to speak, with identifer generated and group data filled
let mut proto_share = Share::new()?;
proto_share.group_threshold = group_threshold;
proto_share.group_count = groups.len() as u8;
if master_secret.len() * 8 < proto_share.config.min_strength_bits as usize {
return Err(ErrorKind::Value(format!(
"The length of the master secret ({} bytes) must be at least {} bytes.",
master_secret.len(),
(f64::from(proto_share.config.min_strength_bits) / 8f64).ceil(),
)))?;
}
if master_secret.len() % 2 != 0 {
return Err(ErrorKind::Value(
"The length of the master secret in bytes must be an even number".to_string(),
))?;
}
if group_threshold as usize > groups.len() {
return Err(ErrorKind::Value(format!(
"The requested group threshold ({}) must not exceed the number of groups ({}).",
group_threshold,
groups.len()
)))?;
}
let encoder = util::encrypt::MasterSecretEnc::new()?;
let encrypted_master_secret = encoder.encrypt(
master_secret,
passphrase,
iteration_exponent,
proto_share.identifier,
);
let sp = Splitter::new(None);
let group_shares = sp.split_secret(
&proto_share,
group_threshold,
groups.len() as u8,
&encrypted_master_secret,
)?;
let mut retval: Vec<GroupShare> = vec![];
let gs_len = group_shares.len();
for (i, elem) in group_shares.into_iter().enumerate() {
proto_share.group_index = i as u8;
proto_share.group_threshold = group_threshold;
proto_share.group_count = gs_len as u8;
let (member_threshold, member_count) = groups[i];
let member_shares = sp.split_secret(
&proto_share,
member_threshold,
member_count,
&elem.share_value,
)?;
retval.push(GroupShare {
group_id: proto_share.identifier,
iteration_exponent,
group_index: i as u8,
group_threshold,
group_count: gs_len as u8,
member_threshold,
member_shares,
});
}
Ok(retval)
}
pub fn generate_mnemonics_random(
group_threshold: u8,
groups: &[(u8, u8)],
strength_bits: u16,
passphrase: &str,
iteration_exponent: u8,
) -> Result<Vec<GroupShare>, Error> {
let proto_share = Share::new()?;
if strength_bits < proto_share.config.min_strength_bits {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be at least {} bits.",
strength_bits, proto_share.config.min_strength_bits,
)))?;
}
if strength_bits % 16 != 0 {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be a multiple of 16 bits.",
strength_bits,
)))?;
}
generate_mnemonics(
group_threshold,
groups,
&util::fill_vec_rand(strength_bits as usize / 8),
passphrase,
iteration_exponent,
)
}
/// Combines mnemonic shares to obtain the master secret which was previously split using
/// Shamir's secret sharing scheme.
/// mnemonics: List of mnemonics.
/// passphrase: The passphrase used to encrypt the master secret.
/// return: The master secret.
pub fn combine_mnemonics(mnemonics: &[Vec<String>], passphrase: &str) -> Result<Vec<u8>, Error> {
let group_shares = decode_mnemonics(mnemonics)?;
let mut shares = vec![];
for mut gs in group_shares {
shares.push(gs.decode_shares()?);
}
let sp = Splitter::new(None);
// restore proper member index for groups
let shares = shares
.into_iter()
.map(|mut s| {
s.member_index = s.group_index;
s
})
.collect::<Vec<_>>();
let ems = sp.recover_secret(&shares, shares[0].group_threshold)?;
let encoder = util::encrypt::MasterSecretEnc::new()?;
let dms = encoder.decrypt(
&ems.share_value,
passphrase,
ems.iteration_exponent,
ems.identifier,
);
Ok(dms)
}
/// Decodes all Mnemonics to a list of shares and performs error checking
fn decode_mnemonics(mnemonics: &[Vec<String>]) -> Result<Vec<GroupShare>, Error> {
let mut shares = vec![];
if mnemonics.is_empty() |
let check_len = mnemonics[0].len();
for m in mnemonics {
if m.len() != check_len {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same length.".to_string(),
))?;
}
shares.push(Share::from_mnemonic(m)?);
}
let check_share = shares[0].clone();
for s in shares.iter() {
if s.identifier != check_share.identifier
|| s.iteration_exponent != check_share.iteration_exponent
{
return Err(ErrorKind::Mnemonic(format!(
"Invalid set of mnemonics. All mnemonics must begin with the same {} words. \
(Identifier and iteration exponent must be the same).",
s.config.id_exp_length_words,
)))?;
}
if s.group_threshold != check_share.group_threshold {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group threshold"
.to_string(),
))?;
}
if s.group_count != check_share.group_count {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group count"
.to_string(),
))?;
}
}
let mut group_index_map = BTreeMap::new();
for s in shares {
if !group_index_map.contains_key(&s.group_index) {
let group_share = GroupShare {
group_id: s.identifier,
group_index: s.group_index,
group_threshold: s.group_threshold,
iteration_exponent: s.iteration_exponent,
group_count: s.group_count,
member_shares: vec![s.clone()],
member_threshold: s.member_threshold,
};
group_index_map.insert(group_share.group_index, group_share);
} else {
let e = group_index_map.get_mut(&s.group_index).unwrap();
e.member_shares.push(s);
}
}
if group_index_map.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonic groups ({}). The required number \
of groups is {}.",
group_index_map.len(),
check_share.group_threshold,
)))?;
}
let groups: Vec<GroupShare> = group_index_map
.into_iter()
.map(|g| g.1)
// remove groups where number of shares is below the member threshold
.filter(|g| g.member_shares.len() >= g.member_threshold as usize)
.collect();
if groups.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(
"Insufficient number of groups with member counts that meet member threshold."
.to_string(),
))?;
}
// TODO: Should probably return info making problem mnemonics easier to identify
for g in groups.iter() {
if g.member_shares.len() < g.member_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonics (Group {}). At least {} mnemonics \
are required.",
g.group_index, g.member_threshold,
)))?;
}
let test_share = g.member_shares[0].clone();
for ms in g.member_shares.iter() {
if test_share.member_threshold != ms.member_threshold {
return Err(ErrorKind::Mnemonic(
"Mismatching member thresholds".to_string(),
))?;
}
}
}
Ok(groups)
}
#[cfg(test)]
| {
return Err(ErrorKind::Mnemonic(
"List of mnemonics is empty.".to_string(),
))?;
} | conditional_block |
sssmc39_scheme.rs | _secret(&self.member_shares, self.member_threshold)
}
}
/// Split a master secret into mnemonic shares
/// group_threshold: The number of groups required to reconstruct the master secret
/// groups: A list of (member_threshold, member_count) pairs for each group, where member_count
/// is the number of shares to generate for the group and member_threshold is the number of
/// members required to reconstruct the group secret.
/// master_secret: The master secret to split.
/// passphrase: The passphrase used to encrypt the master secret.
/// iteration_exponent: The iteration exponent.
/// return: List of mnemonics.
pub fn generate_mnemonics(
group_threshold: u8,
groups: &[(u8, u8)],
master_secret: &[u8],
passphrase: &str,
iteration_exponent: u8,
) -> Result<Vec<GroupShare>, Error> {
// Generate a 'proto share' so to speak, with identifer generated and group data filled
let mut proto_share = Share::new()?;
proto_share.group_threshold = group_threshold;
proto_share.group_count = groups.len() as u8;
if master_secret.len() * 8 < proto_share.config.min_strength_bits as usize {
return Err(ErrorKind::Value(format!(
"The length of the master secret ({} bytes) must be at least {} bytes.",
master_secret.len(),
(f64::from(proto_share.config.min_strength_bits) / 8f64).ceil(),
)))?;
}
if master_secret.len() % 2 != 0 {
return Err(ErrorKind::Value(
"The length of the master secret in bytes must be an even number".to_string(),
))?;
}
if group_threshold as usize > groups.len() {
return Err(ErrorKind::Value(format!(
"The requested group threshold ({}) must not exceed the number of groups ({}).",
group_threshold,
groups.len()
)))?;
}
let encoder = util::encrypt::MasterSecretEnc::new()?;
let encrypted_master_secret = encoder.encrypt(
master_secret,
passphrase,
iteration_exponent,
proto_share.identifier,
);
let sp = Splitter::new(None);
let group_shares = sp.split_secret(
&proto_share,
group_threshold,
groups.len() as u8,
&encrypted_master_secret,
)?;
let mut retval: Vec<GroupShare> = vec![];
let gs_len = group_shares.len();
for (i, elem) in group_shares.into_iter().enumerate() {
proto_share.group_index = i as u8;
proto_share.group_threshold = group_threshold;
proto_share.group_count = gs_len as u8;
let (member_threshold, member_count) = groups[i];
let member_shares = sp.split_secret(
&proto_share,
member_threshold,
member_count,
&elem.share_value,
)?;
retval.push(GroupShare {
group_id: proto_share.identifier,
iteration_exponent,
group_index: i as u8,
group_threshold,
group_count: gs_len as u8,
member_threshold,
member_shares,
});
}
Ok(retval)
}
pub fn generate_mnemonics_random(
group_threshold: u8,
groups: &[(u8, u8)],
strength_bits: u16,
passphrase: &str,
iteration_exponent: u8,
) -> Result<Vec<GroupShare>, Error> {
let proto_share = Share::new()?;
if strength_bits < proto_share.config.min_strength_bits {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be at least {} bits.",
strength_bits, proto_share.config.min_strength_bits,
)))?;
}
if strength_bits % 16 != 0 {
return Err(ErrorKind::Value(format!(
"The requested strength of the master secret({} bits) must be a multiple of 16 bits.",
strength_bits,
)))?;
}
generate_mnemonics(
group_threshold,
groups,
&util::fill_vec_rand(strength_bits as usize / 8),
passphrase,
iteration_exponent,
)
}
/// Combines mnemonic shares to obtain the master secret which was previously split using
/// Shamir's secret sharing scheme.
/// mnemonics: List of mnemonics.
/// passphrase: The passphrase used to encrypt the master secret.
/// return: The master secret.
pub fn combine_mnemonics(mnemonics: &[Vec<String>], passphrase: &str) -> Result<Vec<u8>, Error> {
let group_shares = decode_mnemonics(mnemonics)?;
let mut shares = vec![];
for mut gs in group_shares {
shares.push(gs.decode_shares()?);
}
let sp = Splitter::new(None);
// restore proper member index for groups
let shares = shares
.into_iter()
.map(|mut s| {
s.member_index = s.group_index;
s
})
.collect::<Vec<_>>();
let ems = sp.recover_secret(&shares, shares[0].group_threshold)?;
let encoder = util::encrypt::MasterSecretEnc::new()?;
let dms = encoder.decrypt(
&ems.share_value,
passphrase,
ems.iteration_exponent,
ems.identifier,
);
Ok(dms)
}
/// Decodes all Mnemonics to a list of shares and performs error checking
fn | (mnemonics: &[Vec<String>]) -> Result<Vec<GroupShare>, Error> {
let mut shares = vec![];
if mnemonics.is_empty() {
return Err(ErrorKind::Mnemonic(
"List of mnemonics is empty.".to_string(),
))?;
}
let check_len = mnemonics[0].len();
for m in mnemonics {
if m.len() != check_len {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same length.".to_string(),
))?;
}
shares.push(Share::from_mnemonic(m)?);
}
let check_share = shares[0].clone();
for s in shares.iter() {
if s.identifier != check_share.identifier
|| s.iteration_exponent != check_share.iteration_exponent
{
return Err(ErrorKind::Mnemonic(format!(
"Invalid set of mnemonics. All mnemonics must begin with the same {} words. \
(Identifier and iteration exponent must be the same).",
s.config.id_exp_length_words,
)))?;
}
if s.group_threshold != check_share.group_threshold {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group threshold"
.to_string(),
))?;
}
if s.group_count != check_share.group_count {
return Err(ErrorKind::Mnemonic(
"Invalid set of mnemonics. All mnemonics must have the same group count"
.to_string(),
))?;
}
}
let mut group_index_map = BTreeMap::new();
for s in shares {
if !group_index_map.contains_key(&s.group_index) {
let group_share = GroupShare {
group_id: s.identifier,
group_index: s.group_index,
group_threshold: s.group_threshold,
iteration_exponent: s.iteration_exponent,
group_count: s.group_count,
member_shares: vec![s.clone()],
member_threshold: s.member_threshold,
};
group_index_map.insert(group_share.group_index, group_share);
} else {
let e = group_index_map.get_mut(&s.group_index).unwrap();
e.member_shares.push(s);
}
}
if group_index_map.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonic groups ({}). The required number \
of groups is {}.",
group_index_map.len(),
check_share.group_threshold,
)))?;
}
let groups: Vec<GroupShare> = group_index_map
.into_iter()
.map(|g| g.1)
// remove groups where number of shares is below the member threshold
.filter(|g| g.member_shares.len() >= g.member_threshold as usize)
.collect();
if groups.len() < check_share.group_threshold as usize {
return Err(ErrorKind::Mnemonic(
"Insufficient number of groups with member counts that meet member threshold."
.to_string(),
))?;
}
// TODO: Should probably return info making problem mnemonics easier to identify
for g in groups.iter() {
if g.member_shares.len() < g.member_threshold as usize {
return Err(ErrorKind::Mnemonic(format!(
"Insufficient number of mnemonics (Group {}). At least {} mnemonics \
are required.",
g.group_index, g.member_threshold,
)))?;
}
let test_share = g.member_shares[0].clone();
for ms in g.member_shares.iter() {
if test_share.member_threshold != ms.member_threshold {
return Err(ErrorKind::Mnemonic(
"Mismatching member thresholds".to_string(),
))?;
}
}
}
Ok(groups)
}
#[cfg(test)]
mod | decode_mnemonics | identifier_name |
project.py | ", type(d["pick_pose"]), "place_pose", type(d["place_pose"])
data_dict = {"object_list": dict_list}
with open(yaml_filename, 'w') as outfile:
yaml.dump(data_dict, outfile, default_flow_style=False)
def statistical_outlier_removal(cloud):
# Much like the previous filters, we start by creating a filter object:
outlier_filter = cloud.make_statistical_outlier_filter()
# Set the number of neighboring points to analyze for any given point
outlier_filter.set_mean_k(50)
# Set threshold scale factor
x = 0.9
# Any point with a mean distance larger than global (mean distance+x*std_dev) will be considered outlier
outlier_filter.set_std_dev_mul_thresh(x)
# Finally call the filter function for magic
cloud_filtered = outlier_filter.filter()
return cloud_filtered
def voxel_downsample(cloud): | cloud (PointCloud_PointXYZRGB): A point cloud
Returns:
PointCloud_PointXYZRGB: A downsampled point cloud
"""
# Create a VoxelGrid filter object for our input point cloud
vox = cloud.make_voxel_grid_filter()
# Choose a voxel (also known as leaf) size
LEAF_SIZE = 0.005
# Set the voxel (or leaf) size
vox.set_leaf_size(LEAF_SIZE, LEAF_SIZE, LEAF_SIZE)
# Call the filter function to obtain the resultant downsampled point cloud
cloud_filtered = vox.filter()
return cloud_filtered
def apply_passthrough_filter(cloud, axis, axis_min, axis_max):
""" Apply a passthrough filter to a cloud
Args:
cloud (PointCloud_PointXYZRGB): A point cloud
Returns:
PointCloud_PointXYZRGB: A filtered point cloud
"""
# Create a PassThrough filter object.
passthrough = cloud.make_passthrough_filter()
# Assign axis and range to the passthrough filter object.
filter_axis = axis
passthrough.set_filter_field_name(filter_axis)
#axis_min = 0.6
#axis_max = 1.1
passthrough.set_filter_limits(axis_min, axis_max)
# Finally use the filter function to obtain the resultant point cloud.
cloud_filtered = passthrough.filter()
return cloud_filtered
def ransac(cloud, sacmodel):
""" Segments a cloud using a sac model
Args:
cloud (PointCloud_PointXYZRGB): A point cloud
sacmodel (pcl.SACMODEL): A model points will be fit to
Returns:
A set of inliers and coefficients
"""
# Create the segmentation object
seg = cloud.make_segmenter()
# Set the model you wish to fit
seg.set_model_type(sacmodel)
seg.set_method_type(pcl.SAC_RANSAC)
# Max distance for a point to be considered fitting the model
# Experiment with different values for max_distance
# for segmenting the table
max_distance = 0.01
seg.set_distance_threshold(max_distance)
# Call the segment function to obtain set of inlier indices and model coefficients
inliers, coefficients = seg.segment()
return inliers, coefficients
def euclidean_clustering(cloud):
white_cloud = XYZRGB_to_XYZ(cloud)
tree = white_cloud.make_kdtree()
# Create a cluster extraction object
ec = white_cloud.make_EuclideanClusterExtraction()
# Set tolerances for distance threshold
# as well as minimum and maximum cluster size (in points)
ec.set_ClusterTolerance(0.01)
ec.set_MinClusterSize(10)
ec.set_MaxClusterSize(25000)
# Search the k-d tree for clusters
ec.set_SearchMethod(tree)
# Extract indices for each of the discovered clusters
cluster_indices = ec.Extract()
return cluster_indices, white_cloud
def color_clusters(cluster_indices, white_cloud):
#Assign a color corresponding to each segmented object in scene
cluster_color = get_color_list(len(cluster_indices))
color_cluster_point_list = []
for j, indices in enumerate(cluster_indices):
for i, indice in enumerate(indices):
color_cluster_point_list.append([white_cloud[indice][0],
white_cloud[indice][1],
white_cloud[indice][2],
rgb_to_float(cluster_color[j])])
#Create new cloud containing all clusters, each with unique color
cluster_cloud = pcl.PointCloud_PointXYZRGB()
cluster_cloud.from_list(color_cluster_point_list)
return cluster_cloud
# Callback function for your Point Cloud Subscriber
def pcl_callback(pcl_msg):
# Exercise-2 TODOs:
# Convert ROS msg to PCL data
pcl_data = ros_to_pcl(pcl_msg)
#filename = 'pcl_data.pcd'
#pcl.save(pcl_data, filename)
# Statistical Outlier Filtering
cloud_filtered = statistical_outlier_removal(pcl_data)
#filename = 'statistical_outlier_removal.pcd'
#pcl.save(cloud_filtered, filename)
# Voxel Grid Downsampling
cloud_filtered = voxel_downsample(cloud_filtered)
#filename = 'voxel_downsampled.pcd'
#pcl.save(cloud_filtered, filename)
# PassThrough Filter along z
axis_min = 0.6
axis_max = 1.1
cloud_filtered = apply_passthrough_filter(cloud_filtered, 'z', axis_min, axis_max)
#filename = 'pass_through_filtered.pcd'
#pcl.save(cloud_filtered, filename)
# PassThrough Filter along y
axis_min = -0.5
axis_max = 0.5
cloud_filtered = apply_passthrough_filter(cloud_filtered, 'y', axis_min, axis_max)
filename = 'pass_through_filtered_y.pcd'
pcl.save(cloud_filtered, filename)
# RANSAC Plane Segmentation
inliers, coefficients = ransac(cloud_filtered, pcl.SACMODEL_PLANE)
# Extract inliers and outliers
extracted_inliers = cloud_filtered.extract(inliers, negative=False)
#filename = 'extracted_inliers.pcd'
#pcl.save(extracted_inliers, filename)
extracted_outliers = cloud_filtered.extract(inliers, negative=True)
#filename = 'extracted_outliers.pcd'
#pcl.save(extracted_outliers, filename)
cloud_table = extracted_inliers
cloud_objects = extracted_outliers
# Euclidean Clustering
cluster_indices, white_cloud = euclidean_clustering(cloud_objects)
# Create Cluster-Mask Point Cloud to visualize each cluster separately
cluster_cloud = color_clusters(cluster_indices, white_cloud)
filename = 'colored_cluster_cloud.pcd'
pcl.save(cluster_cloud, filename)
# Convert PCL data to ROS messages
ros_cloud_table = pcl_to_ros(cloud_table)
ros_cloud_objects = pcl_to_ros(cloud_objects)
ros_cluster_cloud = pcl_to_ros(cluster_cloud)
# Publish ROS messages
pcl_objects_pub.publish(ros_cloud_objects)
pcl_table_pub.publish(ros_cloud_table)
pcl_cluster_pub.publish(ros_cluster_cloud)
# Exercise-3 TODOs:
# Classify the clusters! (loop through each detected cluster one at a time)
detected_objects_labels = []
detected_objects = []
for index, pts_list in enumerate(cluster_indices):
# Grab the points for the cluster
pcl_cluster = cloud_objects.extract(pts_list)
# Compute the associated feature vector
ros_cluster = pcl_to_ros(pcl_cluster)
sample_cloud = ros_cluster
chists = compute_color_histograms(sample_cloud, using_hsv=True)
normals = get_normals(sample_cloud)
nhists = compute_normal_histograms(normals)
feature = np.concatenate((chists, nhists))
# Make the prediction
prediction = clf.predict(scaler.transform(feature.reshape(1,-1)))
label = encoder.inverse_transform(prediction)[0]
detected_objects_labels.append(label)
# Publish a label into RViz
label_pos = list(white_cloud[pts_list[0]])
label_pos[2] += .4
object_markers_pub.publish(make_label(label,label_pos, index))
# Add the detected object to the list of detected objects.
do = DetectedObject()
do.label = label
do.cloud = ros_cluster
detected_objects.append(do)
rospy.loginfo('Detected {} objects: {}'.format(len(detected_objects_labels), detected_objects_labels))
# Publish the list of detected objects
detected_objects_pub.publish(detected_objects)
# Suggested location for where to invoke your pr2_mover() function within pcl_callback()
# Could add some logic to determine whether or not your object detections are robust
# before calling pr2_mover()
detected_objects_list = detected_objects
try:
pr2_mover(detected_objects_list)
except rospy.ROSInterruptException:
pass
# function to load parameters and request PickPlace service
def pr2_mover(object_list):
# TODO: Initialize variables
dict_list = []
# TODO: Get/Read parameters
object_list_param = rospy.get_param('/object_list')
dropbox_list_param = rospy.get_param('/dropbox')
# TODO: Parse parameters into individual variables
test_scene_num = Int32()
test_scene_num.data = 3
""" labels = []
centroids = [] # to | """ Voxel Grid filter
Args: | random_line_split |
project.py | _pose", type(d["pick_pose"]), "place_pose", type(d["place_pose"])
data_dict = {"object_list": dict_list}
with open(yaml_filename, 'w') as outfile:
yaml.dump(data_dict, outfile, default_flow_style=False)
def statistical_outlier_removal(cloud):
# Much like the previous filters, we start by creating a filter object:
outlier_filter = cloud.make_statistical_outlier_filter()
# Set the number of neighboring points to analyze for any given point
outlier_filter.set_mean_k(50)
# Set threshold scale factor
x = 0.9
# Any point with a mean distance larger than global (mean distance+x*std_dev) will be considered outlier
outlier_filter.set_std_dev_mul_thresh(x)
# Finally call the filter function for magic
cloud_filtered = outlier_filter.filter()
return cloud_filtered
def voxel_downsample(cloud):
""" Voxel Grid filter
Args:
cloud (PointCloud_PointXYZRGB): A point cloud
Returns:
PointCloud_PointXYZRGB: A downsampled point cloud
"""
# Create a VoxelGrid filter object for our input point cloud
vox = cloud.make_voxel_grid_filter()
# Choose a voxel (also known as leaf) size
LEAF_SIZE = 0.005
# Set the voxel (or leaf) size
vox.set_leaf_size(LEAF_SIZE, LEAF_SIZE, LEAF_SIZE)
# Call the filter function to obtain the resultant downsampled point cloud
cloud_filtered = vox.filter()
return cloud_filtered
def apply_passthrough_filter(cloud, axis, axis_min, axis_max):
""" Apply a passthrough filter to a cloud
Args:
cloud (PointCloud_PointXYZRGB): A point cloud
Returns:
PointCloud_PointXYZRGB: A filtered point cloud
"""
# Create a PassThrough filter object.
passthrough = cloud.make_passthrough_filter()
# Assign axis and range to the passthrough filter object.
filter_axis = axis
passthrough.set_filter_field_name(filter_axis)
#axis_min = 0.6
#axis_max = 1.1
passthrough.set_filter_limits(axis_min, axis_max)
# Finally use the filter function to obtain the resultant point cloud.
cloud_filtered = passthrough.filter()
return cloud_filtered
def ransac(cloud, sacmodel):
| seg.set_distance_threshold(max_distance)
# Call the segment function to obtain set of inlier indices and model coefficients
inliers, coefficients = seg.segment()
return inliers, coefficients
def euclidean_clustering(cloud):
white_cloud = XYZRGB_to_XYZ(cloud)
tree = white_cloud.make_kdtree()
# Create a cluster extraction object
ec = white_cloud.make_EuclideanClusterExtraction()
# Set tolerances for distance threshold
# as well as minimum and maximum cluster size (in points)
ec.set_ClusterTolerance(0.01)
ec.set_MinClusterSize(10)
ec.set_MaxClusterSize(25000)
# Search the k-d tree for clusters
ec.set_SearchMethod(tree)
# Extract indices for each of the discovered clusters
cluster_indices = ec.Extract()
return cluster_indices, white_cloud
def color_clusters(cluster_indices, white_cloud):
#Assign a color corresponding to each segmented object in scene
cluster_color = get_color_list(len(cluster_indices))
color_cluster_point_list = []
for j, indices in enumerate(cluster_indices):
for i, indice in enumerate(indices):
color_cluster_point_list.append([white_cloud[indice][0],
white_cloud[indice][1],
white_cloud[indice][2],
rgb_to_float(cluster_color[j])])
#Create new cloud containing all clusters, each with unique color
cluster_cloud = pcl.PointCloud_PointXYZRGB()
cluster_cloud.from_list(color_cluster_point_list)
return cluster_cloud
# Callback function for your Point Cloud Subscriber
def pcl_callback(pcl_msg):
# Exercise-2 TODOs:
# Convert ROS msg to PCL data
pcl_data = ros_to_pcl(pcl_msg)
#filename = 'pcl_data.pcd'
#pcl.save(pcl_data, filename)
# Statistical Outlier Filtering
cloud_filtered = statistical_outlier_removal(pcl_data)
#filename = 'statistical_outlier_removal.pcd'
#pcl.save(cloud_filtered, filename)
# Voxel Grid Downsampling
cloud_filtered = voxel_downsample(cloud_filtered)
#filename = 'voxel_downsampled.pcd'
#pcl.save(cloud_filtered, filename)
# PassThrough Filter along z
axis_min = 0.6
axis_max = 1.1
cloud_filtered = apply_passthrough_filter(cloud_filtered, 'z', axis_min, axis_max)
#filename = 'pass_through_filtered.pcd'
#pcl.save(cloud_filtered, filename)
# PassThrough Filter along y
axis_min = -0.5
axis_max = 0.5
cloud_filtered = apply_passthrough_filter(cloud_filtered, 'y', axis_min, axis_max)
filename = 'pass_through_filtered_y.pcd'
pcl.save(cloud_filtered, filename)
# RANSAC Plane Segmentation
inliers, coefficients = ransac(cloud_filtered, pcl.SACMODEL_PLANE)
# Extract inliers and outliers
extracted_inliers = cloud_filtered.extract(inliers, negative=False)
#filename = 'extracted_inliers.pcd'
#pcl.save(extracted_inliers, filename)
extracted_outliers = cloud_filtered.extract(inliers, negative=True)
#filename = 'extracted_outliers.pcd'
#pcl.save(extracted_outliers, filename)
cloud_table = extracted_inliers
cloud_objects = extracted_outliers
# Euclidean Clustering
cluster_indices, white_cloud = euclidean_clustering(cloud_objects)
# Create Cluster-Mask Point Cloud to visualize each cluster separately
cluster_cloud = color_clusters(cluster_indices, white_cloud)
filename = 'colored_cluster_cloud.pcd'
pcl.save(cluster_cloud, filename)
# Convert PCL data to ROS messages
ros_cloud_table = pcl_to_ros(cloud_table)
ros_cloud_objects = pcl_to_ros(cloud_objects)
ros_cluster_cloud = pcl_to_ros(cluster_cloud)
# Publish ROS messages
pcl_objects_pub.publish(ros_cloud_objects)
pcl_table_pub.publish(ros_cloud_table)
pcl_cluster_pub.publish(ros_cluster_cloud)
# Exercise-3 TODOs:
# Classify the clusters! (loop through each detected cluster one at a time)
detected_objects_labels = []
detected_objects = []
for index, pts_list in enumerate(cluster_indices):
# Grab the points for the cluster
pcl_cluster = cloud_objects.extract(pts_list)
# Compute the associated feature vector
ros_cluster = pcl_to_ros(pcl_cluster)
sample_cloud = ros_cluster
chists = compute_color_histograms(sample_cloud, using_hsv=True)
normals = get_normals(sample_cloud)
nhists = compute_normal_histograms(normals)
feature = np.concatenate((chists, nhists))
# Make the prediction
prediction = clf.predict(scaler.transform(feature.reshape(1,-1)))
label = encoder.inverse_transform(prediction)[0]
detected_objects_labels.append(label)
# Publish a label into RViz
label_pos = list(white_cloud[pts_list[0]])
label_pos[2] += .4
object_markers_pub.publish(make_label(label,label_pos, index))
# Add the detected object to the list of detected objects.
do = DetectedObject()
do.label = label
do.cloud = ros_cluster
detected_objects.append(do)
rospy.loginfo('Detected {} objects: {}'.format(len(detected_objects_labels), detected_objects_labels))
# Publish the list of detected objects
detected_objects_pub.publish(detected_objects)
# Suggested location for where to invoke your pr2_mover() function within pcl_callback()
# Could add some logic to determine whether or not your object detections are robust
# before calling pr2_mover()
detected_objects_list = detected_objects
try:
pr2_mover(detected_objects_list)
except rospy.ROSInterruptException:
pass
# function to load parameters and request PickPlace service
def pr2_mover(object_list):
# TODO: Initialize variables
dict_list = []
# TODO: Get/Read parameters
object_list_param = rospy.get_param('/object_list')
dropbox_list_param = rospy.get_param('/dropbox')
# TODO: Parse parameters into individual variables
test_scene_num = Int32()
test_scene_num.data = 3
""" labels = []
centroids = [] # to | """ Segments a cloud using a sac model
Args:
cloud (PointCloud_PointXYZRGB): A point cloud
sacmodel (pcl.SACMODEL): A model points will be fit to
Returns:
A set of inliers and coefficients
"""
# Create the segmentation object
seg = cloud.make_segmenter()
# Set the model you wish to fit
seg.set_model_type(sacmodel)
seg.set_method_type(pcl.SAC_RANSAC)
# Max distance for a point to be considered fitting the model
# Experiment with different values for max_distance
# for segmenting the table
max_distance = 0.01 | identifier_body |
project.py | _cluster_point_list.append([white_cloud[indice][0],
white_cloud[indice][1],
white_cloud[indice][2],
rgb_to_float(cluster_color[j])])
#Create new cloud containing all clusters, each with unique color
cluster_cloud = pcl.PointCloud_PointXYZRGB()
cluster_cloud.from_list(color_cluster_point_list)
return cluster_cloud
# Callback function for your Point Cloud Subscriber
def pcl_callback(pcl_msg):
# Exercise-2 TODOs:
# Convert ROS msg to PCL data
pcl_data = ros_to_pcl(pcl_msg)
#filename = 'pcl_data.pcd'
#pcl.save(pcl_data, filename)
# Statistical Outlier Filtering
cloud_filtered = statistical_outlier_removal(pcl_data)
#filename = 'statistical_outlier_removal.pcd'
#pcl.save(cloud_filtered, filename)
# Voxel Grid Downsampling
cloud_filtered = voxel_downsample(cloud_filtered)
#filename = 'voxel_downsampled.pcd'
#pcl.save(cloud_filtered, filename)
# PassThrough Filter along z
axis_min = 0.6
axis_max = 1.1
cloud_filtered = apply_passthrough_filter(cloud_filtered, 'z', axis_min, axis_max)
#filename = 'pass_through_filtered.pcd'
#pcl.save(cloud_filtered, filename)
# PassThrough Filter along y
axis_min = -0.5
axis_max = 0.5
cloud_filtered = apply_passthrough_filter(cloud_filtered, 'y', axis_min, axis_max)
filename = 'pass_through_filtered_y.pcd'
pcl.save(cloud_filtered, filename)
# RANSAC Plane Segmentation
inliers, coefficients = ransac(cloud_filtered, pcl.SACMODEL_PLANE)
# Extract inliers and outliers
extracted_inliers = cloud_filtered.extract(inliers, negative=False)
#filename = 'extracted_inliers.pcd'
#pcl.save(extracted_inliers, filename)
extracted_outliers = cloud_filtered.extract(inliers, negative=True)
#filename = 'extracted_outliers.pcd'
#pcl.save(extracted_outliers, filename)
cloud_table = extracted_inliers
cloud_objects = extracted_outliers
# Euclidean Clustering
cluster_indices, white_cloud = euclidean_clustering(cloud_objects)
# Create Cluster-Mask Point Cloud to visualize each cluster separately
cluster_cloud = color_clusters(cluster_indices, white_cloud)
filename = 'colored_cluster_cloud.pcd'
pcl.save(cluster_cloud, filename)
# Convert PCL data to ROS messages
ros_cloud_table = pcl_to_ros(cloud_table)
ros_cloud_objects = pcl_to_ros(cloud_objects)
ros_cluster_cloud = pcl_to_ros(cluster_cloud)
# Publish ROS messages
pcl_objects_pub.publish(ros_cloud_objects)
pcl_table_pub.publish(ros_cloud_table)
pcl_cluster_pub.publish(ros_cluster_cloud)
# Exercise-3 TODOs:
# Classify the clusters! (loop through each detected cluster one at a time)
detected_objects_labels = []
detected_objects = []
for index, pts_list in enumerate(cluster_indices):
# Grab the points for the cluster
pcl_cluster = cloud_objects.extract(pts_list)
# Compute the associated feature vector
ros_cluster = pcl_to_ros(pcl_cluster)
sample_cloud = ros_cluster
chists = compute_color_histograms(sample_cloud, using_hsv=True)
normals = get_normals(sample_cloud)
nhists = compute_normal_histograms(normals)
feature = np.concatenate((chists, nhists))
# Make the prediction
prediction = clf.predict(scaler.transform(feature.reshape(1,-1)))
label = encoder.inverse_transform(prediction)[0]
detected_objects_labels.append(label)
# Publish a label into RViz
label_pos = list(white_cloud[pts_list[0]])
label_pos[2] += .4
object_markers_pub.publish(make_label(label,label_pos, index))
# Add the detected object to the list of detected objects.
do = DetectedObject()
do.label = label
do.cloud = ros_cluster
detected_objects.append(do)
rospy.loginfo('Detected {} objects: {}'.format(len(detected_objects_labels), detected_objects_labels))
# Publish the list of detected objects
detected_objects_pub.publish(detected_objects)
# Suggested location for where to invoke your pr2_mover() function within pcl_callback()
# Could add some logic to determine whether or not your object detections are robust
# before calling pr2_mover()
detected_objects_list = detected_objects
try:
pr2_mover(detected_objects_list)
except rospy.ROSInterruptException:
pass
# function to load parameters and request PickPlace service
def pr2_mover(object_list):
# TODO: Initialize variables
dict_list = []
# TODO: Get/Read parameters
object_list_param = rospy.get_param('/object_list')
dropbox_list_param = rospy.get_param('/dropbox')
# TODO: Parse parameters into individual variables
test_scene_num = Int32()
test_scene_num.data = 3
""" labels = []
centroids = [] # to be list of tuples (x, y, z)
for object in object_list:
labels.append(object.label)
points_arr = ros_to_pcl(object.cloud).to_array()
centroids.append(np.mean(points_arr, axis=0)[:3])
"""
# TODO: Rotate PR2 in place to capture side tables for the collision map
# TODO: Loop through the pick list
for object in object_list:
# TODO: Get the PointCloud for a given object and obtain it's centroid
points_arr = ros_to_pcl(object.cloud).to_array()
c = np.mean(points_arr, axis=0)[:3]
centroid = map(np.asscalar, c)
print "type(centroid)", type(centroid), "[0]", type(centroid[0]), "[1]", type(centroid[1]), "[2]", type(centroid[2])
#centroids.append(np.mean(points_arr, axis=0)[:3])
object_name = String()
object_name.data = str(object.label)
# TODO: Create 'place_pose' for the object
group = None
for o in object_list_param:
if object.label == o['name']:
group = o['group']
print "for ", o['name'], "group found",group
object_arm_name = String()
place_pose = Pose()
for box in dropbox_list_param:
if group == box['group']:
# Assign the arm to be used for pick_place
object_arm_name.data = box['name']
place_pose.position.x = box['position'][0]
place_pose.position.y = box['position'][1]
place_pose.position.z = box['position'][2]
print "type(place_pose.x,y,z): (", type(place_pose.position.x), ",", type(place_pose.position.y), ",", type(place_pose.position.z), ")"
pick_pose = Pose()
pick_pose.position.x = centroid[0]
pick_pose.position.y = centroid[1]
pick_pose.position.z = centroid[2]
# TODO: Create a list of dictionaries (made with make_yaml_dict()) for later output to yaml format
yaml_dict = make_yaml_dict(test_scene_num, object_arm_name, object_name, pick_pose, place_pose)
dict_list.append(yaml_dict)
# Wait for 'pick_place_routine' service to come up
rospy.wait_for_service('pick_place_routine')
try:
pick_place_routine = rospy.ServiceProxy('pick_place_routine', PickPlace)
# Insert your message variables to be sent as a service request
resp = pick_place_routine(test_scene_num, object_name, object_arm_name, pick_pose, place_pose)
print ("Response: ",resp.success)
except rospy.ServiceException, e:
print "Service call failed: %s"%e
# Output your request parameters into output yaml file
yaml_filename = "output_" + str(test_scene_num.data) + ".yaml"
send_to_yaml(yaml_filename, dict_list)
if __name__ == '__main__':
# ROS node initialization
rospy.init_node('clustering', anonymous=True)
# Create Subscribers
#pcl_sub = rospy.Subscriber("/sensor_stick/point_cloud", pc2.PointCloud2, pcl_callback, queue_size=1)
pcl_cam_sub = rospy.Subscriber("/pr2/world/points", pc2.PointCloud2, pcl_callback, queue_size=1)
# Create Publishers
pcl_objects_pub = rospy.Publisher("/pcl_objects", PointCloud2, queue_size=1)
pcl_table_pub = rospy.Publisher("/pcl_table", PointCloud2, queue_size=1)
pcl_cluster_pub = rospy.Publisher("/pcl_cluster", PointCloud2, queue_size=1)
object_markers_pub = rospy.Publisher("/object_markers", Marker, queue_size=1)
detected_objects_pub = rospy.Publisher("/detected_objects", DetectedObjectsArray, queue_size=1)
# Load Model From disk
model = pickle.load(open('model.sav', 'rb'))
clf = model['classifier']
encoder = LabelEncoder()
encoder.classes_ = model['classes']
scaler = model['scaler']
# Initialize color_list
get_color_list.color_list = []
# Spin while node is not shutdown
while not rospy.is_shutdown():
| rospy.spin() | conditional_block |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.