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 |
|---|---|---|---|---|
timer.rs | `advance_to` is what actually fires timers on the `Timer`, and should be
/// called essentially every iteration of the event loop, or when the time
/// specified by `next_wake` has elapsed.
/// * The `Future` implementation for `Timer` is used to process incoming timer
/// updates and requests. This is used to schedule new timeouts, update
/// existing ones, or delete existing timeouts. The `Future` implementation
/// will never resolve, but it'll schedule notifications of when to wake up
/// and process more messages.
///
/// Note that if you're using this crate you probably don't need to use a
/// `Timer` as there is a global one already available for you run on a helper
/// thread. If this isn't desirable, though, then the
/// `TimerHandle::set_fallback` method can be used instead!
pub struct Timer {
inner: Arc<Inner>,
timer_heap: Heap<HeapTimer>,
}
/// A handle to a `Timer` which is used to create instances of a `Delay`.
#[derive(Clone)]
pub struct TimerHandle {
pub(crate) inner: Weak<Inner>,
}
pub(crate) struct Inner {
/// List of updates the `Timer` needs to process
pub(crate) list: ArcList<ScheduledTimer>,
/// The blocked `Timer` task to receive notifications to the `list` above.
pub(crate) waker: AtomicWaker,
}
/// Shared state between the `Timer` and a `Delay`.
pub(crate) struct ScheduledTimer {
pub(crate) waker: AtomicWaker,
// The lowest bit here is whether the timer has fired or not, the second
// lowest bit is whether the timer has been invalidated, and all the other
// bits are the "generation" of the timer which is reset during the `reset`
// function. Only timers for a matching generation are fired.
pub(crate) state: AtomicUsize,
pub(crate) inner: Weak<Inner>,
pub(crate) at: Mutex<Option<Instant>>,
// TODO: this is only accessed by the timer thread, should have a more
// lightweight protection than a `Mutex`
pub(crate) slot: Mutex<Option<Slot>>,
}
impl Timer {
/// Creates a new timer heap ready to create new timers.
pub fn new() -> Timer {
Timer {
inner: Arc::new(Inner {
list: ArcList::new(),
waker: AtomicWaker::new(),
}),
timer_heap: Heap::new(),
}
}
/// Returns a handle to this timer heap, used to create new timeouts.
pub fn handle(&self) -> TimerHandle {
TimerHandle {
inner: Arc::downgrade(&self.inner),
}
}
/// Returns the time at which this timer next needs to be invoked with
/// `advance_to`.
///
/// Event loops or threads typically want to sleep until the specified
/// instant.
pub fn next_event(&self) -> Option<Instant> {
self.timer_heap.peek().map(|t| t.at)
}
/// Proces any timers which are supposed to fire at or before the current
/// instant.
///
/// This method is equivalent to `self.advance_to(Instant::now())`.
pub fn advance(&mut self) {
self.advance_to(Instant::now())
}
/// Proces any timers which are supposed to fire before `now` specified.
///
/// This method should be called on `Timer` periodically to advance the
/// internal state and process any pending timers which need to fire.
pub fn advance_to(&mut self, now: Instant) {
loop {
match self.timer_heap.peek() {
Some(head) if head.at <= now => {}
Some(_) => break,
None => break,
};
// Flag the timer as fired and then notify its task, if any, that's
// blocked.
let heap_timer = self.timer_heap.pop().unwrap();
*heap_timer.node.slot.lock().unwrap() = None;
let bits = heap_timer.gen << 2;
match heap_timer
.node
.state
.compare_exchange(bits, bits | 0b01, SeqCst, SeqCst)
{
Ok(_) => heap_timer.node.waker.wake(),
Err(_b) => {}
}
}
}
/// Either updates the timer at slot `idx` to fire at `at`, or adds a new
/// timer at `idx` and sets it to fire at `at`.
fn update_or_add(&mut self, at: Instant, node: Arc<Node<ScheduledTimer>>) {
// TODO: avoid remove + push and instead just do one sift of the heap?
// In theory we could update it in place and then do the percolation
// as necessary
let gen = node.state.load(SeqCst) >> 2;
let mut slot = node.slot.lock().unwrap();
if let Some(heap_slot) = slot.take() {
self.timer_heap.remove(heap_slot);
}
*slot = Some(self.timer_heap.push(HeapTimer {
at,
gen,
node: node.clone(),
}));
}
fn remove(&mut self, node: Arc<Node<ScheduledTimer>>) {
// If this `idx` is still around and it's still got a registered timer,
// then we jettison it form the timer heap.
let mut slot = node.slot.lock().unwrap();
let heap_slot = match slot.take() {
Some(slot) => slot,
None => return,
};
self.timer_heap.remove(heap_slot);
}
fn invalidate(&mut self, node: Arc<Node<ScheduledTimer>>) {
node.state.fetch_or(0b10, SeqCst);
node.waker.wake();
}
}
impl Future for Timer {
type Output = ();
fn | (mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
Pin::new(&mut self.inner).waker.register(cx.waker());
let mut list = self.inner.list.take();
while let Some(node) = list.pop() {
let at = *node.at.lock().unwrap();
match at {
Some(at) => self.update_or_add(at, node),
None => self.remove(node),
}
}
Poll::Pending
}
}
impl Drop for Timer {
fn drop(&mut self) {
// Seal off our list to prevent any more updates from getting pushed on.
// Any timer which sees an error from the push will immediately become
// inert.
let mut list = self.inner.list.take_and_seal();
// Now that we'll never receive another timer, drain the list of all
// updates and also drain our heap of all active timers, invalidating
// everything.
while let Some(t) = list.pop() {
self.invalidate(t);
}
while let Some(t) = self.timer_heap.pop() {
self.invalidate(t.node);
}
}
}
impl fmt::Debug for Timer {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
f.debug_struct("Timer").field("heap", &"...").finish()
}
}
impl Default for Timer {
fn default() -> Self {
Self::new()
}
}
static HANDLE_FALLBACK: AtomicUsize = AtomicUsize::new(0);
/// Error returned from `TimerHandle::set_fallback`.
#[derive(Clone, Debug)]
struct SetDefaultError(());
impl TimerHandle {
/// Configures this timer handle to be the one returned by
/// `TimerHandle::default`.
///
/// By default a global thread is initialized on the first call to
/// `TimerHandle::default`. This first call can happen transitively through
/// `Delay::new`. If, however, that hasn't happened yet then the global
/// default timer handle can be configured through this method.
///
/// This method can be used to prevent the global helper thread from
/// spawning. If this method is successful then the global helper thread
/// will never get spun up.
///
/// On success this timer handle will have installed itself globally to be
/// used as the return value for `TimerHandle::default` unless otherwise
/// specified.
///
/// # Errors
///
/// If another thread has already called `set_as_global_fallback` or this
/// thread otherwise loses a race to call this method then it will fail
/// returning an error. Once a call to `set_as_global_fallback` is
/// successful then no future calls may succeed.
fn set_as_global_fallback(self) -> Result<(), SetDefaultError> {
unsafe {
let val = self.into_usize();
match HANDLE_FALLBACK.compare_exchange(0, val, SeqCst, SeqCst) {
Ok(_) => Ok(()),
Err(_) => {
drop(TimerHandle::from_usize(val));
Err(SetDefaultError(()))
}
}
}
}
fn into_usize(self) -> usize {
unsafe { mem::transmute::<Weak<Inner>, usize>(self.inner) }
}
unsafe fn from_usize(val: usize) -> TimerHandle {
let inner = mem::transmute::<usize, Weak<Inner>>(val);
TimerHandle { inner }
}
}
impl Default for TimerHandle {
fn default() -> TimerHandle {
let mut fallback = HANDLE_FALLBACK | poll | identifier_name |
timer.rs | <Inner>,
}
pub(crate) struct Inner {
/// List of updates the `Timer` needs to process
pub(crate) list: ArcList<ScheduledTimer>,
/// The blocked `Timer` task to receive notifications to the `list` above.
pub(crate) waker: AtomicWaker,
}
/// Shared state between the `Timer` and a `Delay`.
pub(crate) struct ScheduledTimer {
pub(crate) waker: AtomicWaker,
// The lowest bit here is whether the timer has fired or not, the second
// lowest bit is whether the timer has been invalidated, and all the other
// bits are the "generation" of the timer which is reset during the `reset`
// function. Only timers for a matching generation are fired.
pub(crate) state: AtomicUsize,
pub(crate) inner: Weak<Inner>,
pub(crate) at: Mutex<Option<Instant>>,
// TODO: this is only accessed by the timer thread, should have a more
// lightweight protection than a `Mutex`
pub(crate) slot: Mutex<Option<Slot>>,
}
impl Timer {
/// Creates a new timer heap ready to create new timers.
pub fn new() -> Timer {
Timer {
inner: Arc::new(Inner {
list: ArcList::new(),
waker: AtomicWaker::new(),
}),
timer_heap: Heap::new(),
}
}
/// Returns a handle to this timer heap, used to create new timeouts.
pub fn handle(&self) -> TimerHandle {
TimerHandle {
inner: Arc::downgrade(&self.inner),
}
}
/// Returns the time at which this timer next needs to be invoked with
/// `advance_to`.
///
/// Event loops or threads typically want to sleep until the specified
/// instant.
pub fn next_event(&self) -> Option<Instant> {
self.timer_heap.peek().map(|t| t.at)
}
/// Proces any timers which are supposed to fire at or before the current
/// instant.
///
/// This method is equivalent to `self.advance_to(Instant::now())`.
pub fn advance(&mut self) {
self.advance_to(Instant::now())
}
/// Proces any timers which are supposed to fire before `now` specified.
///
/// This method should be called on `Timer` periodically to advance the
/// internal state and process any pending timers which need to fire.
pub fn advance_to(&mut self, now: Instant) {
loop {
match self.timer_heap.peek() {
Some(head) if head.at <= now => {}
Some(_) => break,
None => break,
};
// Flag the timer as fired and then notify its task, if any, that's
// blocked.
let heap_timer = self.timer_heap.pop().unwrap();
*heap_timer.node.slot.lock().unwrap() = None;
let bits = heap_timer.gen << 2;
match heap_timer
.node
.state
.compare_exchange(bits, bits | 0b01, SeqCst, SeqCst)
{
Ok(_) => heap_timer.node.waker.wake(),
Err(_b) => {}
}
}
}
/// Either updates the timer at slot `idx` to fire at `at`, or adds a new
/// timer at `idx` and sets it to fire at `at`.
fn update_or_add(&mut self, at: Instant, node: Arc<Node<ScheduledTimer>>) {
// TODO: avoid remove + push and instead just do one sift of the heap?
// In theory we could update it in place and then do the percolation
// as necessary
let gen = node.state.load(SeqCst) >> 2;
let mut slot = node.slot.lock().unwrap();
if let Some(heap_slot) = slot.take() {
self.timer_heap.remove(heap_slot);
}
*slot = Some(self.timer_heap.push(HeapTimer {
at,
gen,
node: node.clone(),
}));
}
fn remove(&mut self, node: Arc<Node<ScheduledTimer>>) {
// If this `idx` is still around and it's still got a registered timer,
// then we jettison it form the timer heap.
let mut slot = node.slot.lock().unwrap();
let heap_slot = match slot.take() {
Some(slot) => slot,
None => return,
};
self.timer_heap.remove(heap_slot);
}
fn invalidate(&mut self, node: Arc<Node<ScheduledTimer>>) {
node.state.fetch_or(0b10, SeqCst);
node.waker.wake();
}
}
impl Future for Timer {
type Output = ();
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
Pin::new(&mut self.inner).waker.register(cx.waker());
let mut list = self.inner.list.take();
while let Some(node) = list.pop() {
let at = *node.at.lock().unwrap();
match at {
Some(at) => self.update_or_add(at, node),
None => self.remove(node),
}
}
Poll::Pending
}
}
impl Drop for Timer {
fn drop(&mut self) {
// Seal off our list to prevent any more updates from getting pushed on.
// Any timer which sees an error from the push will immediately become
// inert.
let mut list = self.inner.list.take_and_seal();
// Now that we'll never receive another timer, drain the list of all
// updates and also drain our heap of all active timers, invalidating
// everything.
while let Some(t) = list.pop() {
self.invalidate(t);
}
while let Some(t) = self.timer_heap.pop() {
self.invalidate(t.node);
}
}
}
impl fmt::Debug for Timer {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
f.debug_struct("Timer").field("heap", &"...").finish()
}
}
impl Default for Timer {
fn default() -> Self {
Self::new()
}
}
static HANDLE_FALLBACK: AtomicUsize = AtomicUsize::new(0);
/// Error returned from `TimerHandle::set_fallback`.
#[derive(Clone, Debug)]
struct SetDefaultError(());
impl TimerHandle {
/// Configures this timer handle to be the one returned by
/// `TimerHandle::default`.
///
/// By default a global thread is initialized on the first call to
/// `TimerHandle::default`. This first call can happen transitively through
/// `Delay::new`. If, however, that hasn't happened yet then the global
/// default timer handle can be configured through this method.
///
/// This method can be used to prevent the global helper thread from
/// spawning. If this method is successful then the global helper thread
/// will never get spun up.
///
/// On success this timer handle will have installed itself globally to be
/// used as the return value for `TimerHandle::default` unless otherwise
/// specified.
///
/// # Errors
///
/// If another thread has already called `set_as_global_fallback` or this
/// thread otherwise loses a race to call this method then it will fail
/// returning an error. Once a call to `set_as_global_fallback` is
/// successful then no future calls may succeed.
fn set_as_global_fallback(self) -> Result<(), SetDefaultError> {
unsafe {
let val = self.into_usize();
match HANDLE_FALLBACK.compare_exchange(0, val, SeqCst, SeqCst) {
Ok(_) => Ok(()),
Err(_) => {
drop(TimerHandle::from_usize(val));
Err(SetDefaultError(()))
}
}
}
}
fn into_usize(self) -> usize {
unsafe { mem::transmute::<Weak<Inner>, usize>(self.inner) }
}
unsafe fn from_usize(val: usize) -> TimerHandle {
let inner = mem::transmute::<usize, Weak<Inner>>(val);
TimerHandle { inner }
}
}
impl Default for TimerHandle {
fn default() -> TimerHandle {
let mut fallback = HANDLE_FALLBACK.load(SeqCst);
// If the fallback hasn't been previously initialized then let's spin
// up a helper thread and try to initialize with that. If we can't
// actually create a helper thread then we'll just return a "defunkt"
// handle which will return errors when timer objects are attempted to
// be associated.
if fallback == 0 {
let helper = match global::HelperThread::new() {
Ok(helper) => helper,
Err(_) => return TimerHandle { inner: Weak::new() },
};
// If we successfully set ourselves as the actual fallback then we
// want to `forget` the helper thread to ensure that it persists
// globally. If we fail to set ourselves as the fallback that means
// that someone was racing with this call to
// `TimerHandle::default`. They ended up winning so we'll destroy
// our helper thread (which shuts down the thread) and reload the
// fallback.
if helper.handle().set_as_global_fallback().is_ok() {
let ret = helper.handle();
helper.forget();
return ret; | random_line_split |
||
openapi_terraform_provider_doc_generator.go | ser("v2", openAPIDocURL)
if err != nil {
return TerraformProviderDocGenerator{}, err
}
return TerraformProviderDocGenerator{
ProviderName: providerName,
Hostname: hostname,
Namespace: namespace,
SpecAnalyser: analyser,
}, nil
}
// GenerateDocumentation creates a TerraformProviderDocumentation object populated based on the OpenAPIDocURL documentation
func (t TerraformProviderDocGenerator) GenerateDocumentation() (TerraformProviderDocumentation, error) {
if t.ProviderName == "" {
return TerraformProviderDocumentation{}, errors.New("provider name not provided")
}
if t.Hostname == "" {
return TerraformProviderDocumentation{}, errors.New("hostname not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
}
if t.Namespace == "" {
return TerraformProviderDocumentation{}, errors.New("namespace not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
}
if t.PluginVersionConstraint == "" {
log.Println("PluginVersionConstraint not provided, default value in the plugin's terraform required_providers rendered documentation will be version = \">= 2.1.0\"")
}
regions, err := getRegions(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
globalSecuritySchemes, securityDefinitions, err := getSecurity(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
headers := t.SpecAnalyser.GetAllHeaderParameters()
configRegions, configProperties := t.getRequiredProviderConfigurationProperties(regions, globalSecuritySchemes, securityDefinitions, headers)
r, err := t.SpecAnalyser.GetTerraformCompliantResources()
if err != nil {
return TerraformProviderDocumentation{}, err
}
resources, err := t.getProviderResources(r)
if err != nil {
return TerraformProviderDocumentation{}, err
}
// ignoring error from getDataSourceInstances bc resource errors will be caught when looping through resources in getProviderResources
dataSourceInstances, _ := t.getDataSourceInstances(r)
compliantDataSources := t.SpecAnalyser.GetTerraformCompliantDataSources()
dataSourceFilters, err := t.getDataSourceFilters(compliantDataSources)
if err != nil {
return TerraformProviderDocumentation{}, err
}
sort.SliceStable(resources, func(i, j int) bool {
return resources[i].Name < resources[j].Name
})
sort.SliceStable(dataSourceInstances, func(i, j int) bool {
return dataSourceInstances[i].Name < dataSourceInstances[j].Name
})
sort.SliceStable(dataSourceFilters, func(i, j int) bool {
return dataSourceFilters[i].Name < dataSourceFilters[j].Name
})
return TerraformProviderDocumentation{
ProviderName: t.ProviderName,
ProviderInstallation: ProviderInstallation{
ProviderName: t.ProviderName,
Namespace: t.Namespace,
Hostname: t.Hostname,
PluginVersionConstraint: t.PluginVersionConstraint,
Example: fmt.Sprintf("$ export PROVIDER_NAME=%s && curl -fsSL https://raw.githubusercontent.com/dikhan/terraform-provider-openapi/master/scripts/install.sh | bash -s -- --provider-name $PROVIDER_NAME<br>"+
"[INFO] Downloading https://github.com/dikhan/terraform-provider-openapi/v3/releases/download/v3.0.0/terraform-provider-openapi_3.0.0_darwin_amd64.tar.gz in temporally folder /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh...<br>"+
"[INFO] Extracting terraform-provider-openapi from terraform-provider-openapi_0.29.4_darwin_amd64.tar.gz...<br>"+
"[INFO] Cleaning up tmp dir created for installation purposes: /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh<br>"+
"[INFO] Terraform provider 'terraform-provider-%s' successfully installed at: '~/.terraform.d/plugins'!", t.ProviderName, t.ProviderName),
Other: "You can then start running the Terraform provider:",
OtherCommand: fmt.Sprintf(`$ export OTF_VAR_%s_PLUGIN_CONFIGURATION_FILE="https://api.service.com/openapi.yaml"<br>`, t.ProviderName),
},
ProviderConfiguration: ProviderConfiguration{
ProviderName: t.ProviderName,
Regions: configRegions,
ConfigProperties: configProperties,
},
ProviderResources: ProviderResources{
ProviderName: t.ProviderName,
Resources: resources,
},
DataSources: DataSources{
ProviderName: t.ProviderName,
DataSources: dataSourceFilters,
DataSourceInstances: dataSourceInstances,
},
}, err
}
func getRegions(s openapi.SpecAnalyser) ([]string, error) {
backendConfig, err := s.GetAPIBackendConfiguration()
if err != nil {
return nil, err
}
if backendConfig != nil {
_, _, regions, err := backendConfig.IsMultiRegion()
if err != nil {
return nil, err
}
return regions, nil
}
return nil, nil
}
func getSecurity(s openapi.SpecAnalyser) (openapi.SpecSecuritySchemes, *openapi.SpecSecurityDefinitions, error) {
security := s.GetSecurity()
if security != nil {
globalSecuritySchemes, err := security.GetGlobalSecuritySchemes()
if err != nil {
return nil, nil, err
}
securityDefinitions, err := security.GetAPIKeySecurityDefinitions()
if err != nil {
return nil, nil, err
}
return globalSecuritySchemes, securityDefinitions, nil
}
return nil, nil, nil
}
func (t TerraformProviderDocGenerator) getDataSourceFilters(dataSourcesFilter []openapi.SpecResource) ([]DataSource, error) {
dataSources := []DataSource{}
for _, dataSource := range dataSourcesFilter {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSources = append(dataSources, DataSource{
Name: dataSource.GetResourceName(),
Properties: orderProps(props),
})
}
return dataSources, nil
}
func (t TerraformProviderDocGenerator) getDataSourceInstances(dataSourceInstances []openapi.SpecResource) ([]DataSource, error) {
dataSourcesInstance := []DataSource{}
for _, dataSource := range dataSourceInstances {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSourcesInstance = append(dataSourcesInstance, DataSource{
Name: fmt.Sprintf("%s_instance", dataSource.GetResourceName()),
Properties: orderProps(props),
})
}
return dataSourcesInstance, nil
}
func (t TerraformProviderDocGenerator) getProviderResources(resources []openapi.SpecResource) ([]Resource, error) {
r := []Resource{}
for _, resource := range resources {
if resource.ShouldIgnoreResource() {
continue
}
resourceSchema, err := resource.GetResourceSchema()
if err != nil {
return nil, err
}
props := []Property{}
requiredProps := []Property{}
optionalProps := []Property{}
for _, p := range resourceSchema.Properties {
prop := t.resourceSchemaToProperty(*p)
if prop.Required {
requiredProps = append(requiredProps, prop)
}
if !prop.Required {
optionalProps = append(optionalProps, prop)
}
}
props = append(props, orderProps(requiredProps)...)
props = append(props, orderProps(optionalProps)...)
parentInfo := resource.GetParentResourceInfo()
var parentProperties []string
if parentInfo != nil {
parentProperties = parentInfo.GetParentPropertiesNames()
}
r = append(r, Resource{
Name: resource.GetResourceName(),
Description: "",
Properties: props,
ParentProperties: parentProperties,
ArgumentsReference: ArgumentsReference{
Notes: []string{},
},
})
}
return r, nil
}
func (t TerraformProviderDocGenerator) resourceSchemaToProperty(specSchemaDefinitionProperty openapi.SpecSchemaDefinitionProperty) Property {
var schema []Property
if specSchemaDefinitionProperty.Type == openapi.TypeObject || specSchemaDefinitionProperty.ArrayItemsType == openapi.TypeObject {
if specSchemaDefinitionProperty.SpecSchemaDefinition != nil {
for _, p := range specSchemaDefinitionProperty.SpecSchemaDefinition.Properties | {
schema = append(schema, t.resourceSchemaToProperty(*p))
} | conditional_block |
|
openapi_terraform_provider_doc_generator.go | .0" OpenAPI provider version
PluginVersionConstraint string
// SpecAnalyser analyses the swagger doc and provides helper methods to retrieve all the end points that can
// be used as terraform resources.
SpecAnalyser openapi.SpecAnalyser
}
// NewTerraformProviderDocGenerator returns a TerraformProviderDocGenerator populated with the provider documentation which
// exposes methods to render the documentation in different formats (only html supported at the moment)
func NewTerraformProviderDocGenerator(providerName, hostname, namespace, openAPIDocURL string) (TerraformProviderDocGenerator, error) {
analyser, err := openapi.CreateSpecAnalyser("v2", openAPIDocURL)
if err != nil {
return TerraformProviderDocGenerator{}, err
}
return TerraformProviderDocGenerator{
ProviderName: providerName,
Hostname: hostname,
Namespace: namespace,
SpecAnalyser: analyser,
}, nil
}
// GenerateDocumentation creates a TerraformProviderDocumentation object populated based on the OpenAPIDocURL documentation
func (t TerraformProviderDocGenerator) GenerateDocumentation() (TerraformProviderDocumentation, error) {
if t.ProviderName == "" {
return TerraformProviderDocumentation{}, errors.New("provider name not provided")
}
if t.Hostname == "" {
return TerraformProviderDocumentation{}, errors.New("hostname not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
}
if t.Namespace == "" {
return TerraformProviderDocumentation{}, errors.New("namespace not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
}
if t.PluginVersionConstraint == "" {
log.Println("PluginVersionConstraint not provided, default value in the plugin's terraform required_providers rendered documentation will be version = \">= 2.1.0\"")
}
regions, err := getRegions(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
globalSecuritySchemes, securityDefinitions, err := getSecurity(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
headers := t.SpecAnalyser.GetAllHeaderParameters()
configRegions, configProperties := t.getRequiredProviderConfigurationProperties(regions, globalSecuritySchemes, securityDefinitions, headers)
r, err := t.SpecAnalyser.GetTerraformCompliantResources()
if err != nil {
return TerraformProviderDocumentation{}, err
}
resources, err := t.getProviderResources(r)
if err != nil {
return TerraformProviderDocumentation{}, err
}
// ignoring error from getDataSourceInstances bc resource errors will be caught when looping through resources in getProviderResources
dataSourceInstances, _ := t.getDataSourceInstances(r)
compliantDataSources := t.SpecAnalyser.GetTerraformCompliantDataSources()
dataSourceFilters, err := t.getDataSourceFilters(compliantDataSources)
if err != nil {
return TerraformProviderDocumentation{}, err
}
sort.SliceStable(resources, func(i, j int) bool {
return resources[i].Name < resources[j].Name
})
sort.SliceStable(dataSourceInstances, func(i, j int) bool {
return dataSourceInstances[i].Name < dataSourceInstances[j].Name
})
sort.SliceStable(dataSourceFilters, func(i, j int) bool {
return dataSourceFilters[i].Name < dataSourceFilters[j].Name
})
return TerraformProviderDocumentation{
ProviderName: t.ProviderName,
ProviderInstallation: ProviderInstallation{
ProviderName: t.ProviderName,
Namespace: t.Namespace,
Hostname: t.Hostname,
PluginVersionConstraint: t.PluginVersionConstraint,
Example: fmt.Sprintf("$ export PROVIDER_NAME=%s && curl -fsSL https://raw.githubusercontent.com/dikhan/terraform-provider-openapi/master/scripts/install.sh | bash -s -- --provider-name $PROVIDER_NAME<br>"+
"[INFO] Downloading https://github.com/dikhan/terraform-provider-openapi/v3/releases/download/v3.0.0/terraform-provider-openapi_3.0.0_darwin_amd64.tar.gz in temporally folder /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh...<br>"+
"[INFO] Extracting terraform-provider-openapi from terraform-provider-openapi_0.29.4_darwin_amd64.tar.gz...<br>"+
"[INFO] Cleaning up tmp dir created for installation purposes: /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh<br>"+
"[INFO] Terraform provider 'terraform-provider-%s' successfully installed at: '~/.terraform.d/plugins'!", t.ProviderName, t.ProviderName),
Other: "You can then start running the Terraform provider:",
OtherCommand: fmt.Sprintf(`$ export OTF_VAR_%s_PLUGIN_CONFIGURATION_FILE="https://api.service.com/openapi.yaml"<br>`, t.ProviderName),
},
ProviderConfiguration: ProviderConfiguration{
ProviderName: t.ProviderName,
Regions: configRegions,
ConfigProperties: configProperties,
},
ProviderResources: ProviderResources{
ProviderName: t.ProviderName,
Resources: resources,
},
DataSources: DataSources{
ProviderName: t.ProviderName,
DataSources: dataSourceFilters,
DataSourceInstances: dataSourceInstances,
},
}, err
}
func getRegions(s openapi.SpecAnalyser) ([]string, error) |
func getSecurity(s openapi.SpecAnalyser) (openapi.SpecSecuritySchemes, *openapi.SpecSecurityDefinitions, error) {
security := s.GetSecurity()
if security != nil {
globalSecuritySchemes, err := security.GetGlobalSecuritySchemes()
if err != nil {
return nil, nil, err
}
securityDefinitions, err := security.GetAPIKeySecurityDefinitions()
if err != nil {
return nil, nil, err
}
return globalSecuritySchemes, securityDefinitions, nil
}
return nil, nil, nil
}
func (t TerraformProviderDocGenerator) getDataSourceFilters(dataSourcesFilter []openapi.SpecResource) ([]DataSource, error) {
dataSources := []DataSource{}
for _, dataSource := range dataSourcesFilter {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSources = append(dataSources, DataSource{
Name: dataSource.GetResourceName(),
Properties: orderProps(props),
})
}
return dataSources, nil
}
func (t TerraformProviderDocGenerator) getDataSourceInstances(dataSourceInstances []openapi.SpecResource) ([]DataSource, error) {
dataSourcesInstance := []DataSource{}
for _, dataSource := range dataSourceInstances {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSourcesInstance = append(dataSourcesInstance, DataSource{
Name: fmt.Sprintf("%s_instance", dataSource.GetResourceName()),
Properties: orderProps(props),
})
}
return dataSourcesInstance, nil
}
func (t TerraformProviderDocGenerator) getProviderResources(resources []openapi.SpecResource) ([]Resource, error) {
r := []Resource{}
for _, resource := range resources {
if resource.ShouldIgnoreResource() {
continue
}
resourceSchema, err := resource.GetResourceSchema()
if err != nil {
return nil, err
}
props := []Property{}
requiredProps := []Property{}
optionalProps := []Property{}
for _, p := range resourceSchema.Properties {
prop := t.resourceSchemaToProperty(*p)
if prop.Required {
requiredProps = append(requiredProps, prop)
}
if !prop.Required {
optionalProps = append(optionalProps, prop)
}
}
props = append(props, orderProps(requiredProps)...)
props = append(props, orderProps(optionalProps)...)
parentInfo := resource.GetParentResourceInfo()
var parentProperties []string
if parentInfo != nil {
parentProperties = parentInfo.GetParentPropertiesNames()
}
r = append(r, Resource{
Name: resource.GetResourceName(),
Description: "",
Properties: | {
backendConfig, err := s.GetAPIBackendConfiguration()
if err != nil {
return nil, err
}
if backendConfig != nil {
_, _, regions, err := backendConfig.IsMultiRegion()
if err != nil {
return nil, err
}
return regions, nil
}
return nil, nil
} | identifier_body |
openapi_terraform_provider_doc_generator.go | .0" OpenAPI provider version
PluginVersionConstraint string
// SpecAnalyser analyses the swagger doc and provides helper methods to retrieve all the end points that can
// be used as terraform resources.
SpecAnalyser openapi.SpecAnalyser
}
// NewTerraformProviderDocGenerator returns a TerraformProviderDocGenerator populated with the provider documentation which
// exposes methods to render the documentation in different formats (only html supported at the moment)
func NewTerraformProviderDocGenerator(providerName, hostname, namespace, openAPIDocURL string) (TerraformProviderDocGenerator, error) {
analyser, err := openapi.CreateSpecAnalyser("v2", openAPIDocURL)
if err != nil {
return TerraformProviderDocGenerator{}, err
}
return TerraformProviderDocGenerator{
ProviderName: providerName,
Hostname: hostname,
Namespace: namespace,
SpecAnalyser: analyser,
}, nil
}
// GenerateDocumentation creates a TerraformProviderDocumentation object populated based on the OpenAPIDocURL documentation
func (t TerraformProviderDocGenerator) GenerateDocumentation() (TerraformProviderDocumentation, error) {
if t.ProviderName == "" {
return TerraformProviderDocumentation{}, errors.New("provider name not provided")
}
if t.Hostname == "" {
return TerraformProviderDocumentation{}, errors.New("hostname not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
}
if t.Namespace == "" {
return TerraformProviderDocumentation{}, errors.New("namespace not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
}
if t.PluginVersionConstraint == "" {
log.Println("PluginVersionConstraint not provided, default value in the plugin's terraform required_providers rendered documentation will be version = \">= 2.1.0\"")
}
regions, err := getRegions(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
globalSecuritySchemes, securityDefinitions, err := getSecurity(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
headers := t.SpecAnalyser.GetAllHeaderParameters()
configRegions, configProperties := t.getRequiredProviderConfigurationProperties(regions, globalSecuritySchemes, securityDefinitions, headers)
r, err := t.SpecAnalyser.GetTerraformCompliantResources()
if err != nil {
return TerraformProviderDocumentation{}, err
}
resources, err := t.getProviderResources(r)
if err != nil {
return TerraformProviderDocumentation{}, err
}
// ignoring error from getDataSourceInstances bc resource errors will be caught when looping through resources in getProviderResources
dataSourceInstances, _ := t.getDataSourceInstances(r)
compliantDataSources := t.SpecAnalyser.GetTerraformCompliantDataSources()
dataSourceFilters, err := t.getDataSourceFilters(compliantDataSources)
if err != nil {
return TerraformProviderDocumentation{}, err
}
sort.SliceStable(resources, func(i, j int) bool {
return resources[i].Name < resources[j].Name
})
sort.SliceStable(dataSourceInstances, func(i, j int) bool {
return dataSourceInstances[i].Name < dataSourceInstances[j].Name
})
sort.SliceStable(dataSourceFilters, func(i, j int) bool {
return dataSourceFilters[i].Name < dataSourceFilters[j].Name
})
return TerraformProviderDocumentation{
ProviderName: t.ProviderName,
ProviderInstallation: ProviderInstallation{
ProviderName: t.ProviderName,
Namespace: t.Namespace,
Hostname: t.Hostname,
PluginVersionConstraint: t.PluginVersionConstraint,
Example: fmt.Sprintf("$ export PROVIDER_NAME=%s && curl -fsSL https://raw.githubusercontent.com/dikhan/terraform-provider-openapi/master/scripts/install.sh | bash -s -- --provider-name $PROVIDER_NAME<br>"+
"[INFO] Downloading https://github.com/dikhan/terraform-provider-openapi/v3/releases/download/v3.0.0/terraform-provider-openapi_3.0.0_darwin_amd64.tar.gz in temporally folder /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh...<br>"+
"[INFO] Extracting terraform-provider-openapi from terraform-provider-openapi_0.29.4_darwin_amd64.tar.gz...<br>"+
"[INFO] Cleaning up tmp dir created for installation purposes: /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh<br>"+
"[INFO] Terraform provider 'terraform-provider-%s' successfully installed at: '~/.terraform.d/plugins'!", t.ProviderName, t.ProviderName),
Other: "You can then start running the Terraform provider:",
OtherCommand: fmt.Sprintf(`$ export OTF_VAR_%s_PLUGIN_CONFIGURATION_FILE="https://api.service.com/openapi.yaml"<br>`, t.ProviderName),
},
ProviderConfiguration: ProviderConfiguration{
ProviderName: t.ProviderName,
Regions: configRegions,
ConfigProperties: configProperties,
},
ProviderResources: ProviderResources{
ProviderName: t.ProviderName,
Resources: resources,
},
DataSources: DataSources{
ProviderName: t.ProviderName,
DataSources: dataSourceFilters,
DataSourceInstances: dataSourceInstances,
},
}, err
}
func | (s openapi.SpecAnalyser) ([]string, error) {
backendConfig, err := s.GetAPIBackendConfiguration()
if err != nil {
return nil, err
}
if backendConfig != nil {
_, _, regions, err := backendConfig.IsMultiRegion()
if err != nil {
return nil, err
}
return regions, nil
}
return nil, nil
}
func getSecurity(s openapi.SpecAnalyser) (openapi.SpecSecuritySchemes, *openapi.SpecSecurityDefinitions, error) {
security := s.GetSecurity()
if security != nil {
globalSecuritySchemes, err := security.GetGlobalSecuritySchemes()
if err != nil {
return nil, nil, err
}
securityDefinitions, err := security.GetAPIKeySecurityDefinitions()
if err != nil {
return nil, nil, err
}
return globalSecuritySchemes, securityDefinitions, nil
}
return nil, nil, nil
}
func (t TerraformProviderDocGenerator) getDataSourceFilters(dataSourcesFilter []openapi.SpecResource) ([]DataSource, error) {
dataSources := []DataSource{}
for _, dataSource := range dataSourcesFilter {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSources = append(dataSources, DataSource{
Name: dataSource.GetResourceName(),
Properties: orderProps(props),
})
}
return dataSources, nil
}
func (t TerraformProviderDocGenerator) getDataSourceInstances(dataSourceInstances []openapi.SpecResource) ([]DataSource, error) {
dataSourcesInstance := []DataSource{}
for _, dataSource := range dataSourceInstances {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSourcesInstance = append(dataSourcesInstance, DataSource{
Name: fmt.Sprintf("%s_instance", dataSource.GetResourceName()),
Properties: orderProps(props),
})
}
return dataSourcesInstance, nil
}
func (t TerraformProviderDocGenerator) getProviderResources(resources []openapi.SpecResource) ([]Resource, error) {
r := []Resource{}
for _, resource := range resources {
if resource.ShouldIgnoreResource() {
continue
}
resourceSchema, err := resource.GetResourceSchema()
if err != nil {
return nil, err
}
props := []Property{}
requiredProps := []Property{}
optionalProps := []Property{}
for _, p := range resourceSchema.Properties {
prop := t.resourceSchemaToProperty(*p)
if prop.Required {
requiredProps = append(requiredProps, prop)
}
if !prop.Required {
optionalProps = append(optionalProps, prop)
}
}
props = append(props, orderProps(requiredProps)...)
props = append(props, orderProps(optionalProps)...)
parentInfo := resource.GetParentResourceInfo()
var parentProperties []string
if parentInfo != nil {
parentProperties = parentInfo.GetParentPropertiesNames()
}
r = append(r, Resource{
Name: resource.GetResourceName(),
Description: "",
Properties: | getRegions | identifier_name |
openapi_terraform_provider_doc_generator.go | 1.0" OpenAPI provider version
PluginVersionConstraint string
// SpecAnalyser analyses the swagger doc and provides helper methods to retrieve all the end points that can
// be used as terraform resources.
SpecAnalyser openapi.SpecAnalyser
}
// NewTerraformProviderDocGenerator returns a TerraformProviderDocGenerator populated with the provider documentation which
// exposes methods to render the documentation in different formats (only html supported at the moment)
func NewTerraformProviderDocGenerator(providerName, hostname, namespace, openAPIDocURL string) (TerraformProviderDocGenerator, error) {
analyser, err := openapi.CreateSpecAnalyser("v2", openAPIDocURL)
if err != nil {
return TerraformProviderDocGenerator{}, err
}
return TerraformProviderDocGenerator{
ProviderName: providerName,
Hostname: hostname,
Namespace: namespace,
SpecAnalyser: analyser,
}, nil
}
// GenerateDocumentation creates a TerraformProviderDocumentation object populated based on the OpenAPIDocURL documentation
func (t TerraformProviderDocGenerator) GenerateDocumentation() (TerraformProviderDocumentation, error) {
if t.ProviderName == "" {
return TerraformProviderDocumentation{}, errors.New("provider name not provided")
}
if t.Hostname == "" {
return TerraformProviderDocumentation{}, errors.New("hostname not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
} | return TerraformProviderDocumentation{}, errors.New("namespace not provided, this is required to be able to render the provider installation section containing the required_providers block with the source address configuration in the form of [<HOSTNAME>/]<NAMESPACE>/<TYPE>")
}
if t.PluginVersionConstraint == "" {
log.Println("PluginVersionConstraint not provided, default value in the plugin's terraform required_providers rendered documentation will be version = \">= 2.1.0\"")
}
regions, err := getRegions(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
globalSecuritySchemes, securityDefinitions, err := getSecurity(t.SpecAnalyser)
if err != nil {
return TerraformProviderDocumentation{}, err
}
headers := t.SpecAnalyser.GetAllHeaderParameters()
configRegions, configProperties := t.getRequiredProviderConfigurationProperties(regions, globalSecuritySchemes, securityDefinitions, headers)
r, err := t.SpecAnalyser.GetTerraformCompliantResources()
if err != nil {
return TerraformProviderDocumentation{}, err
}
resources, err := t.getProviderResources(r)
if err != nil {
return TerraformProviderDocumentation{}, err
}
// ignoring error from getDataSourceInstances bc resource errors will be caught when looping through resources in getProviderResources
dataSourceInstances, _ := t.getDataSourceInstances(r)
compliantDataSources := t.SpecAnalyser.GetTerraformCompliantDataSources()
dataSourceFilters, err := t.getDataSourceFilters(compliantDataSources)
if err != nil {
return TerraformProviderDocumentation{}, err
}
sort.SliceStable(resources, func(i, j int) bool {
return resources[i].Name < resources[j].Name
})
sort.SliceStable(dataSourceInstances, func(i, j int) bool {
return dataSourceInstances[i].Name < dataSourceInstances[j].Name
})
sort.SliceStable(dataSourceFilters, func(i, j int) bool {
return dataSourceFilters[i].Name < dataSourceFilters[j].Name
})
return TerraformProviderDocumentation{
ProviderName: t.ProviderName,
ProviderInstallation: ProviderInstallation{
ProviderName: t.ProviderName,
Namespace: t.Namespace,
Hostname: t.Hostname,
PluginVersionConstraint: t.PluginVersionConstraint,
Example: fmt.Sprintf("$ export PROVIDER_NAME=%s && curl -fsSL https://raw.githubusercontent.com/dikhan/terraform-provider-openapi/master/scripts/install.sh | bash -s -- --provider-name $PROVIDER_NAME<br>"+
"[INFO] Downloading https://github.com/dikhan/terraform-provider-openapi/v3/releases/download/v3.0.0/terraform-provider-openapi_3.0.0_darwin_amd64.tar.gz in temporally folder /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh...<br>"+
"[INFO] Extracting terraform-provider-openapi from terraform-provider-openapi_0.29.4_darwin_amd64.tar.gz...<br>"+
"[INFO] Cleaning up tmp dir created for installation purposes: /var/folders/n_/1lrwb99s7f50xmn9jpmfnddh0000gp/T/tmp.Xv1AkIZh<br>"+
"[INFO] Terraform provider 'terraform-provider-%s' successfully installed at: '~/.terraform.d/plugins'!", t.ProviderName, t.ProviderName),
Other: "You can then start running the Terraform provider:",
OtherCommand: fmt.Sprintf(`$ export OTF_VAR_%s_PLUGIN_CONFIGURATION_FILE="https://api.service.com/openapi.yaml"<br>`, t.ProviderName),
},
ProviderConfiguration: ProviderConfiguration{
ProviderName: t.ProviderName,
Regions: configRegions,
ConfigProperties: configProperties,
},
ProviderResources: ProviderResources{
ProviderName: t.ProviderName,
Resources: resources,
},
DataSources: DataSources{
ProviderName: t.ProviderName,
DataSources: dataSourceFilters,
DataSourceInstances: dataSourceInstances,
},
}, err
}
func getRegions(s openapi.SpecAnalyser) ([]string, error) {
backendConfig, err := s.GetAPIBackendConfiguration()
if err != nil {
return nil, err
}
if backendConfig != nil {
_, _, regions, err := backendConfig.IsMultiRegion()
if err != nil {
return nil, err
}
return regions, nil
}
return nil, nil
}
func getSecurity(s openapi.SpecAnalyser) (openapi.SpecSecuritySchemes, *openapi.SpecSecurityDefinitions, error) {
security := s.GetSecurity()
if security != nil {
globalSecuritySchemes, err := security.GetGlobalSecuritySchemes()
if err != nil {
return nil, nil, err
}
securityDefinitions, err := security.GetAPIKeySecurityDefinitions()
if err != nil {
return nil, nil, err
}
return globalSecuritySchemes, securityDefinitions, nil
}
return nil, nil, nil
}
func (t TerraformProviderDocGenerator) getDataSourceFilters(dataSourcesFilter []openapi.SpecResource) ([]DataSource, error) {
dataSources := []DataSource{}
for _, dataSource := range dataSourcesFilter {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSources = append(dataSources, DataSource{
Name: dataSource.GetResourceName(),
Properties: orderProps(props),
})
}
return dataSources, nil
}
func (t TerraformProviderDocGenerator) getDataSourceInstances(dataSourceInstances []openapi.SpecResource) ([]DataSource, error) {
dataSourcesInstance := []DataSource{}
for _, dataSource := range dataSourceInstances {
s, err := dataSource.GetResourceSchema()
if err != nil {
return nil, err
}
dataSourceSchemaDefinition := s.ConvertToDataSourceSpecSchemaDefinition()
props := []Property{}
for _, p := range dataSourceSchemaDefinition.Properties {
prop := t.resourceSchemaToProperty(*p)
props = append(props, prop)
}
dataSourcesInstance = append(dataSourcesInstance, DataSource{
Name: fmt.Sprintf("%s_instance", dataSource.GetResourceName()),
Properties: orderProps(props),
})
}
return dataSourcesInstance, nil
}
func (t TerraformProviderDocGenerator) getProviderResources(resources []openapi.SpecResource) ([]Resource, error) {
r := []Resource{}
for _, resource := range resources {
if resource.ShouldIgnoreResource() {
continue
}
resourceSchema, err := resource.GetResourceSchema()
if err != nil {
return nil, err
}
props := []Property{}
requiredProps := []Property{}
optionalProps := []Property{}
for _, p := range resourceSchema.Properties {
prop := t.resourceSchemaToProperty(*p)
if prop.Required {
requiredProps = append(requiredProps, prop)
}
if !prop.Required {
optionalProps = append(optionalProps, prop)
}
}
props = append(props, orderProps(requiredProps)...)
props = append(props, orderProps(optionalProps)...)
parentInfo := resource.GetParentResourceInfo()
var parentProperties []string
if parentInfo != nil {
parentProperties = parentInfo.GetParentPropertiesNames()
}
r = append(r, Resource{
Name: resource.GetResourceName(),
Description: "",
Properties: | if t.Namespace == "" { | random_line_split |
Teach.js | index, target, record, e, eOpts ) {
var me = this; console.log(record)
me.topic = Ext.create('Youngshine.view.teach.Topic')
me.topic.setParentRecord(record);
//me.topic.down('toolbar').setTitle(record.data.studentName)
Ext.Viewport.setMasked({xtype:'loadmask',message:'正在加载'});
// 预先加载的数据
var obj = {
"courseNo" : record.data.courseNo, //当前课时的练习题集
"subjectID": record.data.subjectID, //学科，题库不同学科不同表table
}
var store = Ext.getStore('Topic');
store.getProxy().setUrl(me.getApplication().dataUrl +
'readTopicListByCourse.php?data=' + JSON.stringify(obj) );
store.load({ //异步async
callback: function(records, operation, success){
if (success){
console.log(records);
Ext.Viewport.setMasked(false);
Ext.Viewport.add(me.topic); //build
Ext.Viewport.setActiveItem(me.topic);
var btnTest = me.topic.down('button[action=test]'),
btnPhoto = me.topic.down('button[action=photo]')
console.log(btnPhoto)
btnTest.setHidden(records.length<10 ? true : false)
//btnPhoto.setHidden(records.length<1 ? true : false)
}else{
Ext.toast('出错',3000);
};
}
});
},
topicBack: function(oldView){
var me = this;
Ext.Viewport.setActiveItem(me.course)
Ext.Viewport.remove(me.topic,true)
},
// pdf保存在腾讯云cos
topicPDF: function(rec){
console.log(rec);
var me = this;
var file = 'http://teach1to1-10060757.file.myqcloud.com/teachPDF/';
if(rec.data.subjectID==1){
file = '../PDF/sx/'
}else if(rec.data.subjectID==2){
file += 'wl/'
}else if(rec.data.subjectID==2){
file += 'hx/'
}
file += rec.data.PDF
console.log(file)
me.pdf = Ext.create('Youngshine.view.teach.PdfFile')
me.pdf.down('pdfpanel').setSrc(file); // pdf file in zsd table
Ext.Viewport.add(me.pdf)
Ext.Viewport.setActiveItem(me.pdf);
},
pdfBack: function(oldView){
var me = this;
Ext.Viewport.setActiveItem(me.topic)
Ext.Viewport.remove(me.pdf,true)
},
// 返回选择学生，store不变, rec是上级course
topicPhotos: function(rec,oldView){
var me = this;
me.studyphotos = Ext.create('Youngshine.view.teach.Topic-teach-photos')
//me.studyphotos.setOldView(oldView); // oldView当前父view
me.studyphotos.setRecord(rec); // record
Ext.Viewport.setMasked({xtype:'loadmask',message:'正在加载'});
var obj = {
"studentstudyID": rec.data.studentstudyID, //zsd & student
}
var store = Ext.getStore('Study-photos');
store.getProxy().setUrl(me.getApplication().dataUrl +
'readStudyPhotosList.php?data='+JSON.stringify(obj) );
store.load({ //异步async
callback: function(records, operation, success){
console.log(records);
Ext.Viewport.setMasked(false);
if (success){
Ext.Viewport.add(me.studyphotos); //build
Ext.Viewport.setActiveItem(me.studyphotos);
}else{
Ext.toast('服务请求失败',3000);
};
}
});
},
// 根据level难度 抓取该生的自适应题目，并把记录添加到store:topic-teach
topicFetch: function(obj){
var me = this;
console.log(obj);
Ext.Viewport.setMasked({xtype:'loadmask',message:'添加自适应题目'});
// 自适应出题：抓取第一组题目（3,4,5）根据学生level，以后的根据做提评分level
// 取得记录，直接保存道 topic-teach表，从新load表
Ext.data.JsonP.request({
url: me.getApplication().dataUrl + 'createTopicteach.php',
callbackKey: 'callback',
timeout: 9000,
params:{
data: JSON.stringify(obj)
/* data: '{"level":"' + level +
'","zsdID":"' + zsdID +
'","studentstudyID":"' + studentstudyID + '"}' */
},
success: function(result){ // 服务器连接成功
Ext.Viewport.setMasked(false);
if (result.success){ // 返回值有success成功
//console.log(result.data)
// 直接添加到后台数据表ghjy_topic-teach，最新在最上面
Ext.getStore('Topic').load()
//store.add(result.data).. store.insert()
//console.log(store.data)
}else{
Ext.toast(result.message,3000);
}
},
});
},
topicItemtap: function(list,index,item,record,e){
var me = this;
if(e.target.className == 'answer'){
//this.topicteach.hide(); //remove(); 返回用
me.topicshow = Ext.create('Youngshine.view.teach.TopicShow');
me.topicshow.setParentRecord(record); // 传递参数而已，题目id
Ext.Viewport.add(me.topicshow) //build
Ext.Viewport.setActiveItem(me.topicshow)
}else{
this.overlay = Ext.Viewport.add({
xtype: 'panel',
modal: true,
hideOnMaskTap: true,
centered: true,
width: 550, height:550,
scrollable: true,
//layout: 'vbox',
items: [{
xtype: 'toolbar',
docked: 'top',
ui: 'light',
title: '题目',
},{
xtype: 'panel',
html: record.data.content,
itemId: 'topicContent',
styleHtmlContent: true
}],
})
this.overlay.show()
}
},
topicshowBack: function(oldView){
var me = this;
Ext.Viewport.setActiveItem(me.topic)
Ext.Viewport.remove(me.topicshow,true)
},
topicshowDelete: function(record,oldView){
var me = this;
Ext.Viewport.setMasked({xtype:'loadmask',message:'正在删除'});
Ext.data.JsonP.request({
// 删除服务端记录: 最好做个标记，别真正删除？或者过期的和定期的不能删除？
// 否则，删除过的题目，添加时候可能再出现
url: me.getApplication().dataUrl + 'deleteOne2nTopic.php',
callbackKey: 'callback',
params:{
data: '{"one2ntopicID":' + record.data.one2ntopicID + '}'
},
success: function(result){
Ext.Viewport.setMasked(false);
if(result.success){
// 服务端删除成功后，客户端store当前记录同时删除，列表list才能相应显示
Ext.getStore('Topic').remove(record); //.removeAt(i);
Ext.Viewport.setActiveItem(me.topic);
Ext.Viewport.remove(me.topicshow,true); //关闭自己
}else{
Ext.toast(result.message,3000);
}
},
failure: function(){
Ext.Viewport.setMasked(false); //unmask
Ext.toast('服务请求失败',3000);
}
});
},
// save & refresh 单个题目show.js
topicshowDone: function(done,fullDone,record,view){
var me = this;
Ext.Viewport.setMasked({xtype:'loadmask',message:'正在评分'});
var obj = {
"done": done,
"one2ntopicID": record.data.one2ntopicID
}
console.log(obj)
Ext.data.JsonP.request({
url: me.getApplication().dataUrl + 'updateOne2nTopic.php',
callbackKey: 'callback',
params:{
data: JSON.stringify(obj)
},
success: function(result){
Ext.Viewport.setMasked(false);
if(result.success){
//本地更新数据：打分结果 model.set, setRecord/updateRecord
//var model = record.data ????????
record.set('done',done)
record.set('fullDone',fullDone)
}else{
Ext.toast(result.message,3000); // 错误模式窗口
}
}
});
},
| topicteachphotosBack: function(){
var me = this
Ext.Viewport.setActiveItem(me.topicteach)
Ext.Viewport.remove(me.topicteachphotos,true) | random_line_split |
|
Teach.js | // 全部下课，才能开始上课
Ext.Array.each(records, function(record) {
console.log(record.data)
if(record.data.endTime < '1901-01-01'){
me.course.down('button[action=addnew]').setDisabled(true)
return false
}
}); */
}else{
Ext.toast('服务请求失败',3000); // toast 1000
};
}
});
},
// 登录后跳转这里，一对多教师的课程表
showKcb: function(teacherID){
var me = this;
console.log(teacherID)
Ext.Viewport.setMasked({xtype:'loadmask',message:'正在加载'});
// 预先加载的数据
var obj = {
"teacherID": teacherID
}
Ext.data.JsonP.request({
url: me.getApplication().dataUrl + 'readTeacher.php',
callbackKey: 'callback',
//timeout: 14000,
//params: obj, // ajax, not jsonp
params:{
data: JSON.stringify(obj)
},
success: function(result){
console.log(result.data)
Ext.Viewport.setMasked(false);
if (result.success){
// 只有一条记录[0]，拆分上课时间列表
var timely_list = result.data.timely_list_one2n.split(',')
timely_list = Ext.Array.sort(timely_list)
console.log(timely_list)
//Ext.getStore('Kcb').setData(timely_list)
var store = Ext.getStore('Kcb')
Ext.Array.each(timely_list, function(timely, index, countriesItSelf) {
//arrTimely.push(timely )
store.add({"timely":timely})
});
console.log(store.data)
/*
var arrTimely = []
Ext.Array.each(timely_list, function(timely, index, countriesItSelf) {
arrTimely.push(timely )
});
arrTimely = Ext.Array.sort()
console.log(arrTimely)
*/
me.kcb = Ext.create('Youngshine.view.teach.Kcb')
Ext.Viewport.add(me.kcb);
Ext.Viewport.setActiveItem(me.kcb);
}
},
});
},
// 如果点击‘下课’
courseItemtap: function( list, index, target, record, e, eOpts ) {
var me = this; console.log(record)
me.topic = Ext.create('Youngshine.view.teach.Topic')
me.topic.setParentRecord(record);
//me.topic.down('toolbar').setTitle(record.data.studentName)
Ext.Viewport.setMasked({xtype:'loadmask',message:'正在加载'});
// 预先加载的数据
var obj = {
"courseNo" : record.data.courseNo, //当前课时的练习题集
"subjectID": record.data.subjectID, //学科，题库不同学科不同表table
}
var store = Ext.getStore('Topic');
store.getProxy().setUrl(me.getApplication().dataUrl +
'readTopicListByCourse.php?data=' + JSON.stringify(obj) );
store.load({ //异步async
callback: function(records, operation, success){
if (success){
console.log(records);
Ext.Viewport.setMasked(false);
Ext.Viewport.add(me.topic); //build
Ext.Viewport.setActiveItem(me.topic);
var btnTest = me.topic.down('button[action=test]'),
btnPhoto = me.topic.down('button[action=photo]')
console.log(btnPhoto)
btnTest.setHidden(records.length<10 ? true : false)
//btnPhoto.setHidden(records.length<1 ? true : false)
}else{
Ext.toast('出错',3000);
};
}
});
},
topicBack: function(oldView){
var me = this;
Ext.Viewport.setActiveItem(me.course)
Ext.Viewport.remove(me.topic,true)
},
// pdf保存在腾讯云cos
topicPDF: function(rec){
console.log(rec);
var me = this;
var file = 'http://teach1to1-10060757.file.myqcloud.com/teachPDF/';
if(rec.data.subjectID==1){
file = '../PDF/sx/'
}else if(rec.data.subjectID==2){
file += 'wl/'
}else if(rec.data.subjectID==2){
file += 'hx/'
}
file += rec.data.PDF
console.log(file)
me.pdf = Ext.create('Youngshine.view.teach.PdfFile')
me.pdf.down('pdfpanel').setSrc(file); // pdf file in zsd table
Ext.Viewport.add(me.pdf)
Ext.Viewport.setActiveItem(me.pdf);
},
pdfBack: function(oldView){
var me = this;
Ext.Viewport.setActiveItem(me.topic)
Ext.Viewport.remove(me.pdf,true)
},
// 返回选择学生，store不变, rec是上级course
topicPhotos: function(rec,oldView){
var me = this;
me.studyphotos = Ext.create('Youngshine.view.teach.Topic-teach-photos')
//me.studyphotos.setOldView(oldView); // oldView当前父view
me.studyphotos.setRecord(rec); // record
Ext.Viewport.setMasked({xtype:'loadmask',message:'正在加载'});
var obj = {
"studentstudyID": rec.data.studentstudyID, //zsd & student
}
var store = Ext.getStore('Study-photos');
store.getProxy().setUrl(me.getApplication().dataUrl +
'readStudyPhotosList.php?data='+JSON.stringify(obj) );
store.load({ //异步async
callback: function(records, operation, success){
console.log(records);
Ext.Viewport.setMasked(false);
if (success){
Ext.Viewport.add(me.studyphotos); //build
Ext.Viewport.setActiveItem(me.studyphotos);
}else{
Ext.toast('服务请求失败',3000);
};
}
});
},
// 根据level难度 抓取该生的自适应题目，并把记录添加到store:topic-teach
topicFetch: function(obj){
var me = this;
console.log(obj);
Ext.Viewport.setMasked({xtype:'loadmask',message:'添加自适应题目'});
// 自适应出题：抓取第一组题目（3,4,5）根据学生level，以后的根据做提评分level
// 取得记录，直接保存道 topic-teach表，从新load表
Ext.data.JsonP.request({
url: me.getApplication().dataUrl + 'createTopicteach.php',
callbackKey: 'callback',
timeout: 9000,
params:{
data: JSON.stringify(obj)
/* data: '{"level":"' + level +
'","zsdID":"' + zsdID +
'","studentstudyID":"' + studentstudyID + '"}' */
},
success: function(result){ // 服务器连接成功
Ext.Viewport.setMasked(false);
if (result.success){ // 返回值有success成功
//console.log(result.data)
// 直接添加到后台数据表ghjy_topic-teach，最新在最上面
Ext.getStore('Topic').load()
//store.add(result.data).. store.insert()
//console.log(store.data)
}else{
Ext.toast(result.message,3000);
}
},
});
},
topicItemtap: function(list,index,item,record,e){
var me = this;
if(e.target.className == 'answer'){
//this.topicteach.hide(); //remove(); 返回用
me.topicshow = Ext.create('Youngshine.view.teach.TopicShow');
me.topicshow.setParentRecord(record); // 传递参数而已，题目id
Ext.Viewport.add(me.topicshow) //build
Ext.Viewport.setActiveItem(me.topicshow)
}else{
this.overlay = Ext.Viewport.add({
xtype: 'panel',
modal: true,
hideOnMaskTap: true,
centered: true,
width: 550, height:550,
scrollable: true,
//layout: 'vbox',
items: [{
xtype: 'toolbar',
docked: 'top',
ui: 'light',
title: '题目',
},{
xtype: 'panel',
| html: record.data.content,
itemId: 'topicContent',
styleHtmlContent: true
}],
})
this.overlay.show()
}
},
topicshowBack: function(oldView){
var me = this;
Ext.Viewport.setActiveItem(me.topic)
Ext.Viewport.remove(me.topicshow,true)
},
top | conditional_block |
|
networkBuilder.go |
// WithStatsAggregator sets the stats aggregators to the network
func (n *NetworkBuilder) WithStatsAggregator(aggregators []workloads.StatsAggregator) *NetworkBuilder {
n.Network.StatsAggregator = aggregators
return n
}
// WithNetworkResources sets the network resources to the network
func (n *NetworkBuilder) WithNetworkResources(netResources []workloads.NetworkNetResource) *NetworkBuilder {
n.Network.NetworkResources = netResources
return n
}
// AddNode adds a node to the network
// the subnet will be added as network resource to the node
// forceHidden will set no public endpoints to the node
func (n *NetworkBuilder) AddNode(nodeID string, subnet string, port uint, forceHidden bool) (*NetworkBuilder, error) {
n.NodeID = nodeID
if subnet == "" {
return n, fmt.Errorf("subnet cannot be empty")
}
ipnet, err := types.ParseIPNet(subnet)
if err != nil {
return n, errors.Wrap(err, "invalid subnet")
}
if port == 0 {
port, err = n.pickPort()
if err != nil {
return n, errors.Wrap(err, "failed to pick wireguard port")
}
}
privateKey, err := wgtypes.GeneratePrivateKey()
if err != nil {
return n, errors.Wrap(err, "error during wireguard key generation")
}
sk := privateKey.String()
pk, err := crypto.KeyFromID(pkg.StrIdentifier(nodeID))
if err != nil {
return n, errors.Wrap(err, "failed to parse nodeID")
}
encrypted, err := crypto.Encrypt([]byte(sk), pk)
if err != nil {
return n, errors.Wrap(err, "failed to encrypt private key")
}
pubSubnets, err := n.getEndPointAddrs(pkg.StrIdentifier(nodeID))
if err != nil {
return n, errors.Wrap(err, "failed to get node public endpoints")
}
var endpoints []net.IP
if !forceHidden {
for _, sn := range pubSubnets {
endpoints = append(endpoints, sn.IP)
}
}
nr := NetResource{
NetworkNetResource: workloads.NetworkNetResource{
NodeId: nodeID,
Iprange: schema.IPRange{ipnet.IPNet},
WireguardListenPort: int64(port),
WireguardPublicKey: privateKey.PublicKey().String(),
WireguardPrivateKeyEncrypted: hex.EncodeToString(encrypted),
},
PubEndpoints: endpoints,
}
n.NetResources = append(n.NetResources, nr)
if err = n.generatePeers(); err != nil {
return n, errors.Wrap(err, "failed to generate peers")
}
return n, nil
}
// AddAccess adds access to a node in the network
// the subnet will be routed through the accesspoint of the node
func (n *NetworkBuilder) AddAccess(nodeID string, subnet schema.IPRange, wgPubKey string, ip4 bool) (*NetworkBuilder, string, error) {
if nodeID == "" {
return n, "", fmt.Errorf("nodeID cannot be empty")
}
var nodeExists bool
var node NetResource
for _, nr := range n.NetResources {
if nr.NodeId == nodeID {
node = nr
nodeExists = true
break
}
}
if !nodeExists {
return n, "", errors.New("can not add access through a node which is not in the network")
}
if len(node.PubEndpoints) == 0 {
return n, "", errors.New("access node must have at least 1 public endpoint")
}
var endpoint string
for _, ep := range node.PubEndpoints {
if ep.To4() != nil {
// ipv4 address
if ip4 {
endpoint = fmt.Sprintf("%s:%d", ep.String(), node.WireguardListenPort)
break
}
// we want ipv6 so use the next address
continue
}
if ep.To16() != nil {
// due to the previous branch this can now only be an ipv6 address
if !ip4 {
endpoint = fmt.Sprintf("[%s]:%d", node.PubEndpoints[0].String(), node.WireguardListenPort)
break
}
// we want ipv4 so use next address
continue
}
}
if endpoint == "" {
return n, "", errors.New("access node has no public endpoint of the requested type")
}
var privateKey wgtypes.Key
if wgPubKey == "" {
privateKey, err := wgtypes.GeneratePrivateKey()
if err != nil {
return n, "", errors.Wrap(err, "error during wireguard key generation")
}
wgPubKey = privateKey.PublicKey().String()
}
ap := AccessPoint{
NodeID: nodeID,
Subnet: subnet,
WGPublicKey: wgPubKey,
IP4: ip4,
}
n.AccessPoints = append(n.AccessPoints, ap)
if err := n.generatePeers(); err != nil {
return n, "", errors.Wrap(err, "failed to generate peers")
}
wgConf, err := genWGQuick(privateKey.String(), subnet, node.WireguardPublicKey, n.Network.Iprange, endpoint)
if err != nil {
return n, "", err
}
return n, wgConf, nil
}
// RemoveNode removes a node
func (n *NetworkBuilder) RemoveNode(schema string, nodeID string) error {
for i, nr := range n.NetResources {
if nr.NodeId == nodeID {
n.NetResources = append(n.NetResources[:i], n.NetResources[i+1:]...)
break
}
}
f, err := os.Open(schema)
if err != nil {
return errors.Wrap(err, "failed to open network schema")
}
return n.Save(f)
}
func (n *NetworkBuilder) setPubEndpoints() error {
for i := range n.NetResources {
pep, err := n.getEndPointAddrs(pkg.StrIdentifier(n.NetResources[i].NodeId))
if err != nil {
return err
}
var endpoints []net.IP
for _, sn := range pep {
endpoints = append(endpoints, sn.IP)
}
n.NetResources[i].PubEndpoints = endpoints
}
// remove the pub endpoints from nodes which we assume have been marked
// as force hidden
hiddenNodes := make(map[string]struct{})
for _, nr := range n.NetResources {
if len(nr.PubEndpoints) > 0 {
for _, peer := range nr.Peers {
if peer.Endpoint == "" {
hiddenNodes[peer.PublicKey] = struct{}{}
}
}
}
}
for i := range n.NetResources {
if _, exists := hiddenNodes[n.NetResources[i].WireguardPublicKey]; exists {
n.NetResources[i].PubEndpoints = nil
}
}
return nil
}
func (n *NetworkBuilder) pickPort() (uint, error) {
node, err := n.explorer.Directory.NodeGet(n.NodeID, false)
if err != nil {
return 0, err
}
p := uint(rand.Intn(6000) + 2000)
for isIn(node.WgPorts, p) {
p = uint(rand.Intn(6000) + 2000)
}
return p, nil
}
func isIn(l []int64, i uint) bool {
for _, x := range l {
if int64(i) == x {
return true
}
}
return false
}
func hasIPv4(n NetResource) bool {
for _, pep := range n.PubEndpoints {
if pep.To4() != nil {
return true
}
}
return false
}
// This function assumes:
// - that a hidden node has functioning IPv4
// - that a public node ALWAYS has public IPv6, and OPTIONALLY public IPv4
// - that any public endpoint on any node is actually reachable (i.e. no firewall
// blocking incoming traffic)
func (n *NetworkBuilder) generatePeers() error {
// Find public node, which will be used to connect all hidden nodes.
// In case there are hidden nodes, the public node needs IPv4 support as well.
var hasHiddenNodes bool
for _, nr := range n.NetResources {
if len(nr.PubEndpoints) == 0 {
hasHiddenNodes = true
break
}
}
// Look for a public node to connect hidden nodes. This is only needed
// in case there are hidden nodes.
var pubNr string
if hasHiddenNodes {
for _, nr := range n.NetResources {
if hasIPv4(nr) {
pubNr = n.NodeID
break
}
}
if pubNr == "" {
return errors.New("Network has hidden nodes but no public IPv4 node exists")
}
}
// We also need to inform nodes how to route the external access subnets.
// Working with the knowledge that these external subnets come in through
// the network through a single access point, which is part of the network
// and thus already routed, we can map the external subnets to the subnet
// of the access point, | {
n.Network.Iprange = ipRange
return n
} | identifier_body |
|
networkBuilder.go | func (n *NetworkBuilder) WithStatsAggregator(aggregators []workloads.StatsAggregator) *NetworkBuilder {
n.Network.StatsAggregator = aggregators
return n
}
// WithNetworkResources sets the network resources to the network
func (n *NetworkBuilder) WithNetworkResources(netResources []workloads.NetworkNetResource) *NetworkBuilder {
n.Network.NetworkResources = netResources
return n
}
// AddNode adds a node to the network
// the subnet will be added as network resource to the node
// forceHidden will set no public endpoints to the node
func (n *NetworkBuilder) AddNode(nodeID string, subnet string, port uint, forceHidden bool) (*NetworkBuilder, error) {
n.NodeID = nodeID
if subnet == "" {
return n, fmt.Errorf("subnet cannot be empty")
}
ipnet, err := types.ParseIPNet(subnet)
if err != nil {
return n, errors.Wrap(err, "invalid subnet")
}
if port == 0 {
port, err = n.pickPort()
if err != nil {
return n, errors.Wrap(err, "failed to pick wireguard port")
}
}
privateKey, err := wgtypes.GeneratePrivateKey()
if err != nil {
return n, errors.Wrap(err, "error during wireguard key generation")
}
sk := privateKey.String()
pk, err := crypto.KeyFromID(pkg.StrIdentifier(nodeID))
if err != nil {
return n, errors.Wrap(err, "failed to parse nodeID")
}
encrypted, err := crypto.Encrypt([]byte(sk), pk)
if err != nil {
return n, errors.Wrap(err, "failed to encrypt private key")
}
pubSubnets, err := n.getEndPointAddrs(pkg.StrIdentifier(nodeID))
if err != nil {
return n, errors.Wrap(err, "failed to get node public endpoints")
}
var endpoints []net.IP
if !forceHidden {
for _, sn := range pubSubnets {
endpoints = append(endpoints, sn.IP)
}
}
nr := NetResource{
NetworkNetResource: workloads.NetworkNetResource{
NodeId: nodeID,
Iprange: schema.IPRange{ipnet.IPNet},
WireguardListenPort: int64(port),
WireguardPublicKey: privateKey.PublicKey().String(),
WireguardPrivateKeyEncrypted: hex.EncodeToString(encrypted),
},
PubEndpoints: endpoints,
}
n.NetResources = append(n.NetResources, nr)
if err = n.generatePeers(); err != nil {
return n, errors.Wrap(err, "failed to generate peers")
}
return n, nil
}
// AddAccess adds access to a node in the network
// the subnet will be routed through the accesspoint of the node
func (n *NetworkBuilder) AddAccess(nodeID string, subnet schema.IPRange, wgPubKey string, ip4 bool) (*NetworkBuilder, string, error) {
if nodeID == "" {
return n, "", fmt.Errorf("nodeID cannot be empty")
}
var nodeExists bool
var node NetResource
for _, nr := range n.NetResources {
if nr.NodeId == nodeID {
node = nr
nodeExists = true
break
}
}
if !nodeExists {
return n, "", errors.New("can not add access through a node which is not in the network")
}
if len(node.PubEndpoints) == 0 {
return n, "", errors.New("access node must have at least 1 public endpoint")
}
var endpoint string
for _, ep := range node.PubEndpoints {
if ep.To4() != nil {
// ipv4 address
if ip4 {
endpoint = fmt.Sprintf("%s:%d", ep.String(), node.WireguardListenPort)
break
}
// we want ipv6 so use the next address
continue
}
if ep.To16() != nil {
// due to the previous branch this can now only be an ipv6 address
if !ip4 {
endpoint = fmt.Sprintf("[%s]:%d", node.PubEndpoints[0].String(), node.WireguardListenPort)
break
}
// we want ipv4 so use next address
continue
}
}
if endpoint == "" {
return n, "", errors.New("access node has no public endpoint of the requested type")
}
var privateKey wgtypes.Key
if wgPubKey == "" {
privateKey, err := wgtypes.GeneratePrivateKey()
if err != nil {
return n, "", errors.Wrap(err, "error during wireguard key generation")
}
wgPubKey = privateKey.PublicKey().String()
}
ap := AccessPoint{
NodeID: nodeID,
Subnet: subnet,
WGPublicKey: wgPubKey,
IP4: ip4,
}
n.AccessPoints = append(n.AccessPoints, ap)
if err := n.generatePeers(); err != nil {
return n, "", errors.Wrap(err, "failed to generate peers")
}
wgConf, err := genWGQuick(privateKey.String(), subnet, node.WireguardPublicKey, n.Network.Iprange, endpoint)
if err != nil {
return n, "", err
}
return n, wgConf, nil
}
// RemoveNode removes a node
func (n *NetworkBuilder) RemoveNode(schema string, nodeID string) error {
for i, nr := range n.NetResources {
if nr.NodeId == nodeID {
n.NetResources = append(n.NetResources[:i], n.NetResources[i+1:]...)
break
}
}
f, err := os.Open(schema)
if err != nil {
return errors.Wrap(err, "failed to open network schema")
}
return n.Save(f)
}
func (n *NetworkBuilder) setPubEndpoints() error {
for i := range n.NetResources {
pep, err := n.getEndPointAddrs(pkg.StrIdentifier(n.NetResources[i].NodeId))
if err != nil {
return err
}
var endpoints []net.IP
for _, sn := range pep {
endpoints = append(endpoints, sn.IP)
}
n.NetResources[i].PubEndpoints = endpoints
}
// remove the pub endpoints from nodes which we assume have been marked
// as force hidden
hiddenNodes := make(map[string]struct{})
for _, nr := range n.NetResources {
if len(nr.PubEndpoints) > 0 {
for _, peer := range nr.Peers {
if peer.Endpoint == "" {
hiddenNodes[peer.PublicKey] = struct{}{}
}
}
}
}
for i := range n.NetResources {
if _, exists := hiddenNodes[n.NetResources[i].WireguardPublicKey]; exists {
n.NetResources[i].PubEndpoints = nil
}
}
return nil
}
func (n *NetworkBuilder) pickPort() (uint, error) {
node, err := n.explorer.Directory.NodeGet(n.NodeID, false)
if err != nil {
return 0, err
}
p := uint(rand.Intn(6000) + 2000)
for isIn(node.WgPorts, p) {
p = uint(rand.Intn(6000) + 2000)
}
return p, nil
}
func isIn(l []int64, i uint) bool {
for _, x := range l {
if int64(i) == x {
return true
}
}
return false
}
func hasIPv4(n NetResource) bool {
for _, pep := range n.PubEndpoints {
if pep.To4() != nil {
return true
}
}
return false
}
// This function assumes:
// - that a hidden node has functioning IPv4
// - that a public node ALWAYS has public IPv6, and OPTIONALLY public IPv4
// - that any public endpoint on any node is actually reachable (i.e. no firewall
// blocking incoming traffic)
func (n *NetworkBuilder) generatePeers() error {
// Find public node, which will be used to connect all hidden nodes.
// In case there are hidden nodes, the public node needs IPv4 support as well.
var hasHiddenNodes bool
for _, nr := range n.NetResources {
if len(nr.PubEndpoints) == 0 {
hasHiddenNodes = true
break
}
}
// Look for a public node to connect hidden nodes. This is only needed
// in case there are hidden nodes.
var pubNr string
if hasHiddenNodes {
for _, nr := range n.NetResources {
if hasIPv4(nr) {
pubNr = n.NodeID
break
}
}
if pubNr == "" {
return errors.New("Network has hidden nodes but no public IPv4 node exists")
}
}
// We also need to inform nodes how to route the external access subnets.
// Working with the knowledge that these external subnets come in through
// the network through a single access point, which is part of the network
// and thus already routed, we can map the external subnets to the subnet
// of the access point, and add these external subnets to all peers who also
// have |
// WithStatsAggregator sets the stats aggregators to the network | random_line_split |
|
networkBuilder.go | need to add allowedIPs
// for the hidden nodes
if onr.NodeId == pubNr {
for _, subnet := range hiddenSubnets {
allowedIPs = append(allowedIPs, subnet)
allowedIPs = append(allowedIPs, *wgIP(&schema.IPRange{subnet.IPNet}))
}
}
// Since the node is not hidden, we know that it MUST have at least
// 1 IPv6 address
for _, pep := range onr.PubEndpoints {
if pep.To4() == nil && pep.To16() != nil {
endpoint = fmt.Sprintf("[%s]:%d", pep.String(), onr.WireguardListenPort)
break
}
}
// as a fallback assign IPv4
if endpoint == "" {
for _, pep := range onr.PubEndpoints {
if pep.To4() != nil {
endpoint = fmt.Sprintf("%s:%d", pep.String(), onr.WireguardListenPort)
break
}
}
}
}
// Add subnets for external access
for i := 0; i < len(allowedIPs); i++ {
for _, subnet := range externalSubnets[allowedIPs[i].String()] {
allowedIPs = append(allowedIPs, schema.IPRange{subnet.IPNet})
allowedIPs = append(allowedIPs, *wgIP(&schema.IPRange{subnet.IPNet}))
}
}
nr.Peers = append(nr.Peers, workloads.WireguardPeer{
PublicKey: onr.WireguardPublicKey,
Iprange: onr.Iprange,
AllowedIprange: allowedIPs,
Endpoint: endpoint,
})
}
// Add configured external access peers
for _, ea := range accessPoints[nr.NodeId] {
allowedIPs := make([]schema.IPRange, 2)
allowedIPs[0] = schema.IPRange{ea.Subnet.IPNet}
allowedIPs[1] = *wgIP(&schema.IPRange{ea.Subnet.IPNet})
nr.Peers = append(nr.Peers, workloads.WireguardPeer{
PublicKey: ea.WGPublicKey,
Iprange: schema.IPRange{ea.Subnet.IPNet},
AllowedIprange: allowedIPs,
Endpoint: "",
})
}
}
return nil
}
func isIPv4Subnet(n schema.IPRange) bool {
ones, bits := n.IPNet.Mask.Size()
if bits != 32 {
return false
}
return ones <= 30
}
func genWGQuick(wgPrivateKey string, localSubnet schema.IPRange, peerWgPubKey string, allowedSubnet schema.IPRange, peerEndpoint string) (string, error) {
type data struct {
PrivateKey string
Address string
PeerWgPubKey string
AllowedSubnet string
PeerEndpoint string
}
if !isIPv4Subnet(localSubnet) {
return "", errors.New("local subnet is not a valid IPv4 subnet")
}
tmpl, err := template.New("wg").Parse(wgTmpl)
if err != nil {
return "", err
}
buf := &bytes.Buffer{}
if err := tmpl.Execute(buf, data{
PrivateKey: wgPrivateKey,
Address: wgIP(&schema.IPRange{localSubnet.IPNet}).String(),
PeerWgPubKey: peerWgPubKey,
AllowedSubnet: strings.Join([]string{allowedSubnet.String(), types.NewIPNet(wgSubnet(&allowedSubnet.IPNet)).String()}, ","),
PeerEndpoint: peerEndpoint,
}); err != nil {
return "", err
}
return buf.String(), nil
}
var wgTmpl = `
[Interface]
PrivateKey = {{.PrivateKey}}
Address = {{.Address}}
[Peer]
PublicKey = {{.PeerWgPubKey}}
AllowedIPs = {{.AllowedSubnet}}
PersistentKeepalive = 20
{{if .PeerEndpoint}}Endpoint = {{.PeerEndpoint}}{{end}}
`
// NetworkGraph creates a networkgraph for a network
func (n *NetworkBuilder) NetworkGraph(w io.Writer) error {
nodes := make(map[string]dot.Node)
nodesByID := make(map[string]dot.Node)
graph := dot.NewGraph(dot.Directed)
for _, nr := range n.NetResources {
node := graph.Node(strings.Join([]string{nr.NodeId, nr.Iprange.String()}, "\n")).Box()
// set special style for "hidden" nodes
if len(nr.PubEndpoints) == 0 {
node.Attr("style", "dashed")
node.Attr("color", "blue")
graph.AddToSameRank("hidden nodes", node)
}
nodes[nr.WireguardPublicKey] = node
nodesByID[nr.NodeId] = node
}
// add external access
for _, ea := range n.AccessPoints {
node := graph.Node(strings.Join([]string{"External network", ea.Subnet.String()}, "\n")).Box()
// set style for hidden nodes
node.Attr("style", "dashed")
node.Attr("color", "green")
graph.AddToSameRank("external access", node)
// add link to access point
edge := graph.Edge(node, nodesByID[ea.NodeID], n.Iprange.String())
if ea.IP4 {
edge.Attr("color", "blue")
}
nodes[ea.WGPublicKey] = node
}
for _, nr := range n.NetResources {
for _, peer := range nr.Peers {
allowedIPs := make([]string, 0, len(peer.AllowedIprange)/2)
for _, aip := range peer.AllowedIprange {
if !isCGN(aip) {
allowedIPs = append(allowedIPs, aip.String())
}
}
edge := graph.Edge(nodes[nr.WireguardPublicKey], nodes[peer.PublicKey], strings.Join(allowedIPs, "\n"))
if peer.Endpoint == "" {
// connections to this peer are IPv4 -> blue, and can not be initiated by this node -> dashed
edge.Attr("color", "blue").Attr("style", "dashed")
continue
}
if net.ParseIP(peer.Endpoint[:strings.LastIndex(peer.Endpoint, ":")]).To4() != nil {
// IPv4 connection -> blue
edge.Attr("color", "blue")
}
}
}
graph.Write(w)
return nil
}
func wgIP(subnet *schema.IPRange) *schema.IPRange {
// example: 10.3.1.0 -> 100.64.3.1
a := subnet.IP[len(subnet.IP)-3]
b := subnet.IP[len(subnet.IP)-2]
return &schema.IPRange{net.IPNet{
IP: net.IPv4(0x64, 0x40, a, b),
Mask: net.CIDRMask(32, 32),
}}
}
func wgSubnet(subnet *net.IPNet) *net.IPNet {
// example: 10.3.1.0 -> 100.64.3.1
a := subnet.IP[len(subnet.IP)-3]
b := subnet.IP[len(subnet.IP)-2]
ones, _ := subnet.Mask.Size()
return &net.IPNet{
IP: net.IPv4(0x64, 0x40, a, b),
Mask: net.CIDRMask(ones+8, 32),
}
}
func isPrivateIP(ip net.IP) bool {
privateIPBlocks := []*net.IPNet{}
for _, cidr := range []string{
"127.0.0.0/8", // IPv4 loopback
"10.0.0.0/8", // RFC1918
"172.16.0.0/12", // RFC1918
"192.168.0.0/16", // RFC1918
"169.254.0.0/16", // RFC3927 link-local
"::1/128", // IPv6 loopback
"fe80::/10", // IPv6 link-local
"fc00::/7", // IPv6 unique local addr
} {
_, block, err := net.ParseCIDR(cidr)
if err != nil {
panic(fmt.Errorf("parse error on %q: %v", cidr, err))
}
privateIPBlocks = append(privateIPBlocks, block)
}
if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
return true
}
for _, block := range privateIPBlocks {
if block.Contains(ip) {
return true
}
}
return false
}
func | isCGN | identifier_name |
|
networkBuilder.go | (n schema.IPRange) bool {
ones, bits := n.IPNet.Mask.Size()
if bits != 32 {
return false
}
return ones <= 30
}
func genWGQuick(wgPrivateKey string, localSubnet schema.IPRange, peerWgPubKey string, allowedSubnet schema.IPRange, peerEndpoint string) (string, error) {
type data struct {
PrivateKey string
Address string
PeerWgPubKey string
AllowedSubnet string
PeerEndpoint string
}
if !isIPv4Subnet(localSubnet) {
return "", errors.New("local subnet is not a valid IPv4 subnet")
}
tmpl, err := template.New("wg").Parse(wgTmpl)
if err != nil {
return "", err
}
buf := &bytes.Buffer{}
if err := tmpl.Execute(buf, data{
PrivateKey: wgPrivateKey,
Address: wgIP(&schema.IPRange{localSubnet.IPNet}).String(),
PeerWgPubKey: peerWgPubKey,
AllowedSubnet: strings.Join([]string{allowedSubnet.String(), types.NewIPNet(wgSubnet(&allowedSubnet.IPNet)).String()}, ","),
PeerEndpoint: peerEndpoint,
}); err != nil {
return "", err
}
return buf.String(), nil
}
var wgTmpl = `
[Interface]
PrivateKey = {{.PrivateKey}}
Address = {{.Address}}
[Peer]
PublicKey = {{.PeerWgPubKey}}
AllowedIPs = {{.AllowedSubnet}}
PersistentKeepalive = 20
{{if .PeerEndpoint}}Endpoint = {{.PeerEndpoint}}{{end}}
`
// NetworkGraph creates a networkgraph for a network
func (n *NetworkBuilder) NetworkGraph(w io.Writer) error {
nodes := make(map[string]dot.Node)
nodesByID := make(map[string]dot.Node)
graph := dot.NewGraph(dot.Directed)
for _, nr := range n.NetResources {
node := graph.Node(strings.Join([]string{nr.NodeId, nr.Iprange.String()}, "\n")).Box()
// set special style for "hidden" nodes
if len(nr.PubEndpoints) == 0 {
node.Attr("style", "dashed")
node.Attr("color", "blue")
graph.AddToSameRank("hidden nodes", node)
}
nodes[nr.WireguardPublicKey] = node
nodesByID[nr.NodeId] = node
}
// add external access
for _, ea := range n.AccessPoints {
node := graph.Node(strings.Join([]string{"External network", ea.Subnet.String()}, "\n")).Box()
// set style for hidden nodes
node.Attr("style", "dashed")
node.Attr("color", "green")
graph.AddToSameRank("external access", node)
// add link to access point
edge := graph.Edge(node, nodesByID[ea.NodeID], n.Iprange.String())
if ea.IP4 {
edge.Attr("color", "blue")
}
nodes[ea.WGPublicKey] = node
}
for _, nr := range n.NetResources {
for _, peer := range nr.Peers {
allowedIPs := make([]string, 0, len(peer.AllowedIprange)/2)
for _, aip := range peer.AllowedIprange {
if !isCGN(aip) {
allowedIPs = append(allowedIPs, aip.String())
}
}
edge := graph.Edge(nodes[nr.WireguardPublicKey], nodes[peer.PublicKey], strings.Join(allowedIPs, "\n"))
if peer.Endpoint == "" {
// connections to this peer are IPv4 -> blue, and can not be initiated by this node -> dashed
edge.Attr("color", "blue").Attr("style", "dashed")
continue
}
if net.ParseIP(peer.Endpoint[:strings.LastIndex(peer.Endpoint, ":")]).To4() != nil {
// IPv4 connection -> blue
edge.Attr("color", "blue")
}
}
}
graph.Write(w)
return nil
}
func wgIP(subnet *schema.IPRange) *schema.IPRange {
// example: 10.3.1.0 -> 100.64.3.1
a := subnet.IP[len(subnet.IP)-3]
b := subnet.IP[len(subnet.IP)-2]
return &schema.IPRange{net.IPNet{
IP: net.IPv4(0x64, 0x40, a, b),
Mask: net.CIDRMask(32, 32),
}}
}
func wgSubnet(subnet *net.IPNet) *net.IPNet {
// example: 10.3.1.0 -> 100.64.3.1
a := subnet.IP[len(subnet.IP)-3]
b := subnet.IP[len(subnet.IP)-2]
ones, _ := subnet.Mask.Size()
return &net.IPNet{
IP: net.IPv4(0x64, 0x40, a, b),
Mask: net.CIDRMask(ones+8, 32),
}
}
func isPrivateIP(ip net.IP) bool {
privateIPBlocks := []*net.IPNet{}
for _, cidr := range []string{
"127.0.0.0/8", // IPv4 loopback
"10.0.0.0/8", // RFC1918
"172.16.0.0/12", // RFC1918
"192.168.0.0/16", // RFC1918
"169.254.0.0/16", // RFC3927 link-local
"::1/128", // IPv6 loopback
"fe80::/10", // IPv6 link-local
"fc00::/7", // IPv6 unique local addr
} {
_, block, err := net.ParseCIDR(cidr)
if err != nil {
panic(fmt.Errorf("parse error on %q: %v", cidr, err))
}
privateIPBlocks = append(privateIPBlocks, block)
}
if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() {
return true
}
for _, block := range privateIPBlocks {
if block.Contains(ip) {
return true
}
}
return false
}
func isCGN(subnet schema.IPRange) bool {
_, block, err := net.ParseCIDR("100.64.0.0/10")
if err != nil {
panic(err)
}
return block.Contains(subnet.IP)
}
func (n *NetworkBuilder) extractAccessPoints() {
// gather all actual nodes, using their wg pubkey as key in the map (NodeID
// can't be seen in the actual peer struct)
actualNodes := make(map[string]struct{})
for _, nr := range n.NetResources {
actualNodes[nr.WireguardPublicKey] = struct{}{}
}
aps := []AccessPoint{}
for _, nr := range n.NetResources {
for _, peer := range nr.Peers {
if _, exists := actualNodes[peer.PublicKey]; !exists {
// peer is not a node so it must be external
aps = append(aps, AccessPoint{
NodeID: nr.NodeId,
Subnet: peer.Iprange,
WGPublicKey: peer.PublicKey,
// we can't infer if we use IPv6 or IPv4
})
}
}
}
n.AccessPoints = aps
}
// a node has either a public namespace with []ipv4 or/and []ipv6 -or-
// some interface has received a SLAAC addr
// which has been registered in BCDB
func (n *NetworkBuilder) getEndPointAddrs(nodeID pkg.Identifier) ([]types.IPNet, error) {
schemaNode, err := n.explorer.Directory.NodeGet(nodeID.Identity(), false)
if err != nil {
return nil, err
}
node := types.NewNodeFromSchema(schemaNode)
var endpoints []types.IPNet
if node.PublicConfig != nil {
if node.PublicConfig.IPv4.IP != nil {
ip := node.PublicConfig.IPv4.IP
if ip.IsGlobalUnicast() && !isPrivateIP(ip) {
endpoints = append(endpoints, node.PublicConfig.IPv4)
}
}
if node.PublicConfig.IPv6.IP != nil {
ip := node.PublicConfig.IPv6.IP
if ip.IsGlobalUnicast() && !isPrivateIP(ip) {
endpoints = append(endpoints, node.PublicConfig.IPv6)
}
}
} else {
for _, iface := range node.Ifaces | {
for _, ip := range iface.Addrs {
if !ip.IP.IsGlobalUnicast() || isPrivateIP(ip.IP) {
continue
}
endpoints = append(endpoints, ip)
}
} | conditional_block |
|
mf6_data_tutorial06.py | # format_version: "1.5"
# jupytext_version: 1.5.1
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# metadata:
# section: mf6
# ---
# # MODFLOW 6: Working with MODFLOW List Data.
#
# This tutorial shows how to view, access, and change the underlying data
# variables for MODFLOW 6 objects in FloPy. Interaction with a FloPy
# MODFLOW 6 model is different from other models, such as MODFLOW-2005,
# MT3D, and SEAWAT, for example.
#
# FloPy stores model data in data objects (`MFDataArray`, `MFDataList`,
# `MFDataScalar` objects) that are accessible from packages. Data can be
# added to a package by using the appropriate parameters when the package is
# constructed and through package attributes.
#
# The MODFLOW 6 simulation structure is arranged in the following
# generalized way:
#
# > Simulation --> Package --> DATA
# >
# > Simulation --> Model --> Package (--> Package) --> DATA
#
#
# This tutorial focuses on MODFLOW Data from the `PackageData`,
# `ConnectionData`, `StressPeriodData`, and other similar blocks. These
# blocks contain data with columns, data that fits into a numpy recarray,
# pandas data frame, or a spreadsheet with column headers. These data are
# stored by FloPy in a `MFList` or `MFTransientList` object and a referred to
# as MODFLOW list data.
# ## Introduction to MODFLOW List Data
#
# MODFLOW contains list data that can be conveniently stored in a numpy
# recarray or a pandas dataframe. These data are either a single or multiple
# row of data, with each column containing the same data type.
#
# Some MODFLOW list data only contains a single row, like the `OC` package's
# `head print_format` option and the `NPF` package's `rewet_record`. Other
# MODFLOW list data can contain multiple rows, like the `MAW` package's
# `packagedata` and `connectiondata`. FloPy stores both single row and
# multiple row list data in `MFList` objects.
#
# MODFLOW stress period data can contain lists of data for one or more stress
# periods. FloPy stores stress period list data in `MFTransientList` objects.
# Note that not all MODFLOW stress period data is "list" data that fits neatly
# in a recarray or a panda's dataframe. Some packages including `RCH` and
# `EVT` have a `READASARRAYS` option that allows stress period data to be
# inputted as an array. When `READASARRAYS` is selected FloPy stores stress
# period array data in an `MFTransientArray` object (see tutorial 8).
#
# Examples of using FloPy to store, update, and retrieve different types of
# MODFLOW list data are given below. The examples start by first creating a
# simulation (`MFSimulation`) and a model (`MFModel`) object in FloPy.
# package import
import os
from pathlib import Path
from tempfile import TemporaryDirectory
import numpy as np
import flopy
# set up where simulation workspace will be stored
temp_dir = TemporaryDirectory()
workspace = temp_dir.name
name = "tutorial06_mf6_data"
# create the Flopy simulation and tdis objects
sim = flopy.mf6.MFSimulation(
sim_name=name, exe_name="mf6", version="mf6", sim_ws=workspace
)
tdis = flopy.mf6.modflow.mftdis.ModflowTdis(
sim,
pname="tdis",
time_units="DAYS",
nper=2,
perioddata=[(1.0, 1, 1.0), (1.0, 1, 1.0)],
)
# create the Flopy groundwater flow (gwf) model object
model_nam_file = f"{name}.nam"
gwf = flopy.mf6.ModflowGwf(sim, modelname=name, model_nam_file=model_nam_file)
# create the flopy iterative model solver (ims) package object
ims = flopy.mf6.modflow.mfims.ModflowIms(sim, pname="ims", complexity="SIMPLE")
# create the discretization package
bot = np.linspace(-50.0 / 3.0, -3.0, 3)
delrow = delcol = 4.0
dis = flopy.mf6.modflow.mfgwfdis.ModflowGwfdis(
gwf,
pname="dis",
nogrb=True,
nlay=3,
nrow=10,
ncol=10,
delr=delrow,
delc=delcol,
top=0.0,
botm=bot,
)
# ## Adding MODFLOW Package Data, Connection Data, and Option Lists
#
# MODFLOW Package data, connection data, and option lists are stored by FloPy
# as numpy recarrays. FloPy does accept numpy recarrays as input, but does
# has other supported formats discussed below.
#
# MODFLOW option lists that only contain a single row or data can be either
# specified by:
#
# 1. Specifying a string containing the entire line as it would be displayed
# in the package file (`rewet_record="REWET WETFCT 1.0 IWETIT 1 IHDWET 0"`)
# 2. Specifying the data in a tuple within a list
# (`rewet_record=[("WETFCT", 1.0, "IWETIT", 1, "IHDWET", 0)]`)
#
# In the example below the npf package is created setting the `rewet_record`
# option to a string of text as would be typed into the package file.
npf = flopy.mf6.modflow.mfgwfnpf.ModflowGwfnpf(
gwf,
rewet_record="REWET WETFCT 1.0 IWETIT 1 IHDWET 0",
pname="npf",
icelltype=1,
k=1.0,
save_flows=True,
xt3doptions="xt3d rhs",
)
# `rewet_record` is then set using the npf package's `rewet_record` property.
# This time 'rewet_record' is defined using a tuple within a list.
npf.rewet_record = [("WETFCT", 1.1, "IWETIT", 0, "IHDWET", 1)]
# MODFLOW multirow lists, like package data and connection data, can be
# specified:
#
# 1. As a list of tuples where each tuple represents a row in the list
# (stress_period_data = [((1, 2, 3), 20.0), ((1, 7, 3), 25.0)])
# 2. As a numpy recarray. Building a numpy recarray is more complicated and
# is beyond the scope of this guide.
#
# In the example below the chd package is created, setting `stress_period_data`
# as a list of tuples.
# We build the chd package using an array of tuples for stress_period_data
# stress_period_data = [(first_chd_cell, head), (second_chd_cell, head), ...]
# Note that the cellid information (layer, row, column) is encapsulated in
# a tuple.
stress_period_data = [((1, 10, 10), 100.0), ((1, 10, 11), 105.0)]
# build chd package
chd = flopy.mf6.modflow.mfgwfchd.ModflowGwfchd(
gwf,
pname="chd",
maxbound=len(stress_period_data),
stress_period_data=stress_period_data,
save_flows=True,
)
# ## Adding Stress Period List Data
#
# MODFLOW stress period data is stored by FloPy as a dictionary of numpy
# recarrays, where each dictionary key is a zero-based stress period and each
# dictionary value is a recarray containing the stress period data for that
# stress period. FloPy keeps this stress period data in a `MFTransientList`
# object and this data type is referred to as a transient list.
#
# FloPy accepts stress period data as a dictionary of numpy recarrays, but also
# supports replacing the recarrays with lists of tuples discussed above.
# Stress period data spanning multiple stress periods must be specified as a
# dictionary of lists where the dictionary key is the stress period expressed
# as a zero-based integer.
#
# The example below creates `stress_period_data` for the wel package with the
# first stress period containing a single well and the second stress period
# empty. When empty stress period data is entered FloPy writes an empty
# stress period block to the package file.
# First we create wel package with stress_period_data dictionary
# keys as zero-based integers so key "0" is stress period 1
stress_period_data = {
0: [((2, 3 | # extension: .py
# format_name: light | random_line_split |
|
business-export-import.component.ts | (element => element.ma_nganh_nghe.length > 3 ? this.categories.push(element.ten_kem_ma) : 0);
});
this.filteredCareerList = this.control.valueChanges.pipe(
startWith(''),
map(value => this._filter(value))
);
}
public getAllCompanyImport() {
console.log("+ Function: getAllCompanyImport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
valueOfYear = this.selectedYear;
console.log(valueOfPeriod, valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyImport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSourceImport = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSourceImport.data.length) {
this.dataSourceImport.paginator = this.paginator1;
this.paginator1._intl.itemsPerPageLabel = "Số hàng";
this.paginator1._intl.firstPageLabel = "Trang Đầu";
this.paginator1._intl.lastPageLabel = "Trang Cuối";
this.paginator1._intl.previousPageLabel = "Trang Trước";
this.paginator1._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllCompanyExport() {
console.log("+ Function: getAllCompanyExport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
valueOfYear = this.selectedYear;
console.log(valueOfPeriod, valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyExport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSource = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSource.data.length) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllProduct(allrecords) {
console.log("+ Function: GetAllProduct");
this.productList = allrecords.data as Array<ProductModel>;
if (this.typeShow == 1) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
//Function for EVENT HTML -------------------------------------------------------------------------------
public timKiem() {
this.getAllCompanyExport();
this.getAllCompanyImport();
}
//Xuất excel
public exportToExcel(filename: string, sheetname: string, is_export: boolean) {
let excelFileName: string;
let newArray: any[] = [];
//Format name of Excel will be export
sheetname = sheetname.replace('/', '_');
excelFileName = filename + '.xlsx';
//Alias column name
let data;
if (is_export)
data = Object.values(this.dataSource.data);
else
data = Object.values(this.dataSourceImport.data);
Object.keys(data).forEach((key, index) => {
newArray.push({
'Tên doanh nghiệp': this.formatString(data[key].ten_doanh_nghiep),
// 'Điện thoại': this.formatString(data[key].dien_thoai),
'Mã số thuế': data[key].mst,
'Sản lượng': data[key].tong_san_luong,
'Trị giá': data[key].tong_tri_gia
});
});
const ws: XLSX.WorkSheet = XLSX.utils.json_to_sheet(newArray);
const wb: XLSX.WorkBook = XLSX.utils.book_new();
/* save to file */
XLSX.utils.book_append_sheet(wb, ws, sheetname);
XLSX.writeFile(wb, excelFileName);
}
public _filter(value: string): CareerModel[] {
const filterValue = this._normalizeValue(value);
return this.careerList.filter(career => this._normalizeValue(career.ten_kem_ma).includes(filterValue));
}
public openDetailCompany(mst: string) {
let url = this.router.serializeUrl(
this.router.createUrlTree([encodeURI('#') + 'manager/business/search/' + mst]));
window.open(url.replace('%23', '#'), "_blank");
}
public changeType() {
if (this.selectedType == this.types[0]) {
this.typeShow = 0;
}
else {
this.typeShow = 1;
//this.ngAfterViewInit();
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
public filter() {
this.filterEntity = { ...this.tempFilter }
}
public cancel() {
this.tempFilter = new filterModel();
this.filterEntity = { ...filterModel };
}
changePeriod() {
switch (this.selectedPeriod) {
case "Tháng":
this.selectedMonth = this.getCurrentMonth();
this.selectedYear = this.getCurrentYear();
break;
case "Quý":
this.selectedQuarter = this.getCurrentQuarter();
this.selectedYear = this.getCurrentYear();
break;
case "Năm":
this.selectedYear = this.getCurrentYear();
break;
case "6 Tháng":
this.selectedYear = this.getCurrentYear();
this.selectedHalf = 1;
break;
default:
break;
}
}
//Function for EXTENTION -------------------------------------------------------------------------------
public loadLessonsPage() {
// this.dataSource;
// this.setPage(1);
}
public unicodeToAZ(str: string) {
str = str.replace(/à|á|ạ|ả|ã|â|ầ|ấ|ậ|ẩ|ẫ|ă|ằ|ắ|ặ|ẳ|ẵ/g, "a");
str = str.replace(/è|é|ẹ|ẻ|ẽ|ê|ề|ế|ệ|ể|ễ/g, "e");
str = str.replace(/ì|í|ị|ỉ|ĩ/g, "i");
str = str.replace(/ò|ó|ọ|ỏ|õ|ô|ồ|ố|ộ|ổ|ỗ|ơ|ờ|ớ|ợ|ở|ỡ/g, "o");
str = str.replace(/ù|ú|ụ|ủ|ũ|ư|ừ|ứ|ự|ử|ữ/g, "u");
str = str.replace(/ỳ|ý|ỵ|ỷ|ỹ/g, "y");
str = str.replace(/đ/g, "d");
return str;
}
public _normalizeValue(value: string): string {
return value.toLowerCase().replace(/\s/g, '');
}
public formatDateFromString(date: string) {
if (!date) {
return '';
}
return formatDate(date, this.FORMAT, this.LOCALE);
}
public formatString(value: string) {
if (!value) {
return '';
}
else if (value.trim().toLowerCase() === 'null') {
retu | rn '';
}
else {
return value.trim();
}
}
public getCurrentMonth() {
var c | identifier_body |
|
business-export-import.component.ts | [null];
public loading: boolean = false;
public types = ['Dạng thẻ', 'Dạng bảng'];
public page: number = 1;
public pager: any = {};
public selectedPeriod: string = "";
public periods = ["Tháng", "Quý", "6 Tháng", "Năm"];
public months: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
public quarters: any[] = [
{ ma_so: 1, ma_chu: "I" },
{ ma_so: 2, ma_chu: "II" },
{ ma_so: 3, ma_chu: "III" },
{ ma_so: 4, ma_chu: "IV" },
];
public selectedHalf: number = 1;
public selectedMonth: number = 1;
public selectedQuarter: number = 0;
public selectedYear: number = 2020;
public years: Array<number> = [];
public halfs: number[] = [1];
//Declare variable for ONLU TS
public control = new FormControl();
public _marketService: MarketService;
public errorMessage: any;
public careerList: Array<CareerModel> = new Array<CareerModel>();
public districtList: Array<DistrictModel> = new Array<DistrictModel>();
public categories = [null];//['Tất cả', 'Hạt điều', 'Hạt tiêu', 'Hạt cà phê', 'Cao su'];
public pagedItems: any[];
public productList: any;
public isSCT: boolean = false;
//Viewchild
@ViewChild('TABLE1', { static: false }) table: ElementRef;
@ViewChild('scheduledOrdersPaginator', { static: true }) paginator: MatPaginator;
@ViewChild('scheduledOrdersPaginator1', { static: true }) paginator1: MatPaginator;
@ViewChild('selected_Career', { static: false }) careerEle: ElementRef;
constructor(
public marketService: MarketService,
public paginationService: PaginationService,
public _loginService: LoginService,
public router: Router,
) {
this._marketService = marketService;
}
ngOnInit(): void {
this.filterEntity = new CompanyDetailModel();
this.tempFilter = new CompanyDetailModel();
this.filterType = MatTableFilter.ANYWHERE;
this.selectedPeriod = this.DEFAULT_PERIOD;
this.selectedYear = this.getCurrentYear();
this.selectedMonth = this.getCurrentMonth();
this.years = this.initialYears();
this.isSCT = this._loginService.userValue.user_role < 3;
console.log(this._loginService.userValue);
this.getAllCompanyExport();
this.getAllCompanyImport();
this.getAllDistrict();
}
// ngAfterViewInit(): void {
// if (this.typeShow == 1)
// this.paginator.page
// .pipe(
// tap(() => this.loadLessonsPage())
// )
// .subscribe();
// }
//Function for PROCESS-FLOW -------------------------------------------------------------------------------
public getAllDistrict() {
console.log("+ Function: GetAllDistrict()");
this._marketService.GetAllDistrict().subscribe(
allrecords => {
this.districtList = allrecords.data as DistrictModel[];
this.districtList.forEach(element => this.addresses.push(element.ten_quan_huyen));
});
}
public getAllNganhNghe() {
console.log("+ Function: GetAllNganhNghe()");
this._marketService.GetAllCareer().subscribe(
allrecords => {
this.careerList = allrecords.data as CareerModel[];
this.careerList.forEach(element => element.ma_nganh_nghe.length > 3 ? this.categories.push(element.ten_kem_ma) : 0);
});
this.filteredCareerList = this.control.valueChanges.pipe(
startWith(''),
map(value => this._filter(value))
);
}
public getAllCompanyImport() {
console.log("+ Function: getAllCompanyImport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
valueOfYear = this.selectedYear;
console.log(valueOfPeriod, valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyImport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSourceImport = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSourceImport.data.length) {
this.dataSourceImport.paginator = this.paginator1;
this.paginator1._intl.itemsPerPageLabel = "Số hàng";
this.paginator1._intl.firstPageLabel = "Trang Đầu";
this.paginator1._intl.lastPageLabel = "Trang Cuối";
this.paginator1._intl.previousPageLabel = "Trang Trước";
this.paginator1._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllCompanyExport() {
console.log("+ Function: getAllCompanyExport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
| valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyExport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSource = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSource.data.length) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllProduct(allrecords) {
console.log("+ Function: GetAllProduct");
this.productList = allrecords.data as Array<ProductModel>;
if (this.typeShow == 1) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
//Function for EVENT HTML -------------------------------------------------------------------------------
public timKiem() {
this.getAllCompanyExport();
this.getAllCompanyImport();
}
//Xuất excel
public exportToExcel(filename: string, sheetname: string, is_export: boolean) {
let excelFileName: string;
let newArray: any[] = [];
//Format name of Excel will be export
sheetname = sheetname.replace('/', '_');
excelFileName = filename + '.xlsx';
//Alias column name
let data;
if (is_export)
data = Object.values(this.dataSource.data);
else
data = Object.values(this.dataSourceImport.data);
Object.keys(data).forEach((key, index) => {
newArray.push({
'Tên doanh nghiệp': this.formatString(data[key].ten_doanh_nghiep),
// 'Điện thoại': this.formatString(data[key].dien_thoai),
'Mã số thuế': data[key].mst,
'Sản lượng': data[key].tong_san_luong,
'Trị giá': data[key].tong_tri_gia
});
});
const ws: XLSX.WorkSheet = XLSX.utils.json_to_sheet(newArray);
const wb: XLSX.WorkBook = XLSX.utils.book_new();
/* save | valueOfYear = this.selectedYear;
console.log(valueOfPeriod, | conditional_block |
business-export-import.component.ts | null];
public loading: boolean = false;
public types = ['Dạng thẻ', 'Dạng bảng'];
public page: number = 1;
public pager: any = {};
public selectedPeriod: string = "";
public periods = ["Tháng", "Quý", "6 Tháng", "Năm"];
public months: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
public quarters: any[] = [
{ ma_so: 1, ma_chu: "I" },
{ ma_so: 2, ma_chu: "II" },
{ ma_so: 3, ma_chu: "III" },
{ ma_so: 4, ma_chu: "IV" },
];
public selectedHalf: number = 1;
public selectedMonth: number = 1;
public selectedQuarter: number = 0;
public selectedYear: number = 2020;
public years: Array<number> = [];
public halfs: number[] = [1];
//Declare variable for ONLU TS
public control = new FormControl();
public _marketService: MarketService;
public errorMessage: any;
public careerList: Array<CareerModel> = new Array<CareerModel>();
public districtList: Array<DistrictModel> = new Array<DistrictModel>();
public categories = [null];//['Tất cả', 'Hạt điều', 'Hạt tiêu', 'Hạt cà phê', 'Cao su'];
public pagedItems: any[];
public productList: any;
public isSCT: boolean = false;
//Viewchild
@ViewChild('TABLE1', { static: false }) table: ElementRef;
@ViewChild('scheduledOrdersPaginator', { static: true }) paginator: MatPaginator;
@ViewChild('scheduledOrdersPaginator1', { static: true }) paginator1: MatPaginator;
@ViewChild('selected_Career', { static: false }) careerEle: ElementRef;
constructor(
public marketService: MarketService,
public paginationService: PaginationService,
public _loginService: LoginService,
public router: Router,
) {
this._marketService = marketService;
}
ngOnInit(): void {
this.filterEntity = new CompanyDetailModel();
this.tempFilter = new CompanyDetailModel();
this.filterType = MatTableFilter.ANYWHERE;
this.selectedPeriod = this.DEFAULT_PERIOD;
this.selectedYear = this.getCurrentYear();
this.selectedMonth = this.getCurrentMonth();
this.years = this.initialYears();
this.isSCT = this._loginService.userValue.user_role < 3;
console.log(this._loginService.userValue);
this.getAllCompanyExport();
this.getAllCompanyImport();
this.getAllDistrict();
}
// ngAfterViewInit(): void {
// if (this.typeShow == 1)
// this.paginator.page
// .pipe(
// tap(() => this.loadLessonsPage())
// )
// .subscribe();
// }
//Function for PROCESS-FLOW -------------------------------------------------------------------------------
public getAllDistrict() {
console.log("+ Fun | istrict()");
this._marketService.GetAllDistrict().subscribe(
allrecords => {
this.districtList = allrecords.data as DistrictModel[];
this.districtList.forEach(element => this.addresses.push(element.ten_quan_huyen));
});
}
public getAllNganhNghe() {
console.log("+ Function: GetAllNganhNghe()");
this._marketService.GetAllCareer().subscribe(
allrecords => {
this.careerList = allrecords.data as CareerModel[];
this.careerList.forEach(element => element.ma_nganh_nghe.length > 3 ? this.categories.push(element.ten_kem_ma) : 0);
});
this.filteredCareerList = this.control.valueChanges.pipe(
startWith(''),
map(value => this._filter(value))
);
}
public getAllCompanyImport() {
console.log("+ Function: getAllCompanyImport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
valueOfYear = this.selectedYear;
console.log(valueOfPeriod, valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyImport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSourceImport = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSourceImport.data.length) {
this.dataSourceImport.paginator = this.paginator1;
this.paginator1._intl.itemsPerPageLabel = "Số hàng";
this.paginator1._intl.firstPageLabel = "Trang Đầu";
this.paginator1._intl.lastPageLabel = "Trang Cuối";
this.paginator1._intl.previousPageLabel = "Trang Trước";
this.paginator1._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllCompanyExport() {
console.log("+ Function: getAllCompanyExport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
valueOfYear = this.selectedYear;
console.log(valueOfPeriod, valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyExport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSource = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSource.data.length) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllProduct(allrecords) {
console.log("+ Function: GetAllProduct");
this.productList = allrecords.data as Array<ProductModel>;
if (this.typeShow == 1) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
//Function for EVENT HTML -------------------------------------------------------------------------------
public timKiem() {
this.getAllCompanyExport();
this.getAllCompanyImport();
}
//Xuất excel
public exportToExcel(filename: string, sheetname: string, is_export: boolean) {
let excelFileName: string;
let newArray: any[] = [];
//Format name of Excel will be export
sheetname = sheetname.replace('/', '_');
excelFileName = filename + '.xlsx';
//Alias column name
let data;
if (is_export)
data = Object.values(this.dataSource.data);
else
data = Object.values(this.dataSourceImport.data);
Object.keys(data).forEach((key, index) => {
newArray.push({
'Tên doanh nghiệp': this.formatString(data[key].ten_doanh_nghiep),
// 'Điện thoại': this.formatString(data[key].dien_thoai),
'Mã số thuế': data[key].mst,
'Sản lượng': data[key].tong_san_luong,
'Trị giá': data[key].tong_tri_gia
});
});
const ws: XLSX.WorkSheet = XLSX.utils.json_to_sheet(newArray);
const wb: XLSX.WorkBook = XLSX.utils.book_new();
/* | ction: GetAllD | identifier_name |
business-export-import.component.ts | = false;
//Viewchild
@ViewChild('TABLE1', { static: false }) table: ElementRef;
@ViewChild('scheduledOrdersPaginator', { static: true }) paginator: MatPaginator;
@ViewChild('scheduledOrdersPaginator1', { static: true }) paginator1: MatPaginator;
@ViewChild('selected_Career', { static: false }) careerEle: ElementRef;
constructor(
public marketService: MarketService,
public paginationService: PaginationService,
public _loginService: LoginService,
public router: Router,
) {
this._marketService = marketService;
}
ngOnInit(): void {
this.filterEntity = new CompanyDetailModel();
this.tempFilter = new CompanyDetailModel();
this.filterType = MatTableFilter.ANYWHERE;
this.selectedPeriod = this.DEFAULT_PERIOD;
this.selectedYear = this.getCurrentYear();
this.selectedMonth = this.getCurrentMonth();
this.years = this.initialYears();
this.isSCT = this._loginService.userValue.user_role < 3;
console.log(this._loginService.userValue);
this.getAllCompanyExport();
this.getAllCompanyImport();
this.getAllDistrict();
}
// ngAfterViewInit(): void {
// if (this.typeShow == 1)
// this.paginator.page
// .pipe(
// tap(() => this.loadLessonsPage())
// )
// .subscribe();
// }
//Function for PROCESS-FLOW -------------------------------------------------------------------------------
public getAllDistrict() {
console.log("+ Function: GetAllDistrict()");
this._marketService.GetAllDistrict().subscribe(
allrecords => {
this.districtList = allrecords.data as DistrictModel[];
this.districtList.forEach(element => this.addresses.push(element.ten_quan_huyen));
});
}
public getAllNganhNghe() {
console.log("+ Function: GetAllNganhNghe()");
this._marketService.GetAllCareer().subscribe(
allrecords => {
this.careerList = allrecords.data as CareerModel[];
this.careerList.forEach(element => element.ma_nganh_nghe.length > 3 ? this.categories.push(element.ten_kem_ma) : 0);
});
this.filteredCareerList = this.control.valueChanges.pipe(
startWith(''),
map(value => this._filter(value))
);
}
public getAllCompanyImport() {
console.log("+ Function: getAllCompanyImport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
valueOfYear = this.selectedYear;
console.log(valueOfPeriod, valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyImport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSourceImport = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSourceImport.data.length) {
this.dataSourceImport.paginator = this.paginator1;
this.paginator1._intl.itemsPerPageLabel = "Số hàng";
this.paginator1._intl.firstPageLabel = "Trang Đầu";
this.paginator1._intl.lastPageLabel = "Trang Cuối";
this.paginator1._intl.previousPageLabel = "Trang Trước";
this.paginator1._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllCompanyExport() {
console.log("+ Function: getAllCompanyExport()");
let valueOfPeriod: number = 0;
let valueOfYear: number = 0;
let valueOfPeriodDetail: number = 0;
//
if (this.selectedPeriod == "Tháng") {//"Tháng", "Quý", "6 Tháng", "Năm"{
valueOfPeriod = 1;
valueOfPeriodDetail = this.selectedMonth;
} else if (this.selectedPeriod == 'Quý') {
valueOfPeriod = 2;
valueOfPeriodDetail = this.selectedQuarter;
} else if (this.selectedPeriod == '6 Tháng') {
valueOfPeriod = 3;
valueOfPeriodDetail = this.selectedHalf;
} else {
valueOfPeriod = 4;
valueOfPeriodDetail = 1;
}
valueOfYear = this.selectedYear;
console.log(valueOfPeriod, valueOfYear, valueOfPeriodDetail);
this._marketService.GetAllCompanyExport(valueOfPeriod, valueOfYear, valueOfPeriodDetail, this.isSCT).subscribe(
allrecords => {
if (allrecords.data.length > 0) {
this.dataSource = new MatTableDataSource<CompanyDetailModel>(allrecords.data[0]);
if (this.dataSource.data.length) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
},
error => this.errorMessage = <any>error
);
}
public getAllProduct(allrecords) {
console.log("+ Function: GetAllProduct");
this.productList = allrecords.data as Array<ProductModel>;
if (this.typeShow == 1) {
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
//Function for EVENT HTML -------------------------------------------------------------------------------
public timKiem() {
this.getAllCompanyExport();
this.getAllCompanyImport();
}
//Xuất excel
public exportToExcel(filename: string, sheetname: string, is_export: boolean) {
let excelFileName: string;
let newArray: any[] = [];
//Format name of Excel will be export
sheetname = sheetname.replace('/', '_');
excelFileName = filename + '.xlsx';
//Alias column name
let data;
if (is_export)
data = Object.values(this.dataSource.data);
else
data = Object.values(this.dataSourceImport.data);
Object.keys(data).forEach((key, index) => {
newArray.push({
'Tên doanh nghiệp': this.formatString(data[key].ten_doanh_nghiep),
// 'Điện thoại': this.formatString(data[key].dien_thoai),
'Mã số thuế': data[key].mst,
'Sản lượng': data[key].tong_san_luong,
'Trị giá': data[key].tong_tri_gia
});
});
const ws: XLSX.WorkSheet = XLSX.utils.json_to_sheet(newArray);
const wb: XLSX.WorkBook = XLSX.utils.book_new();
/* save to file */
XLSX.utils.book_append_sheet(wb, ws, sheetname);
XLSX.writeFile(wb, excelFileName);
}
public _filter(value: string): CareerModel[] {
const filterValue = this._normalizeValue(value);
return this.careerList.filter(career => this._normalizeValue(career.ten_kem_ma).includes(filterValue));
}
public openDetailCompany(mst: string) {
let url = this.router.serializeUrl(
this.router.createUrlTree([encodeURI('#') + 'manager/business/search/' + mst]));
window.open(url.replace('%23', '#'), "_blank");
}
public changeType() {
if (this.selectedType == this.types[0]) {
this.typeShow = 0;
}
else {
this.typeShow = 1;
//this.ngAfterViewInit();
this.dataSource.paginator = this.paginator;
this.paginator._intl.itemsPerPageLabel = "Số hàng";
this.paginator._intl.firstPageLabel = "Trang Đầu";
this.paginator._intl.lastPageLabel = "Trang Cuối";
this.paginator._intl.previousPageLabel = "Trang Trước";
this.paginator._intl.nextPageLabel = "Trang Tiếp";
}
}
public filter() {
this.filterEntity = { ...this.tempFilter }
}
public cancel() {
this.tempFilter = new filterModel();
this.filterEntity = { ...filterModel };
}
changePeriod() {
switch (this.selectedPeriod) {
case "Tháng":
this.selectedMonth = this.getCurrentMonth();
this.selectedYear = this.getCurrentYear();
break;
case "Quý":
this.selectedQuarter = this.getCurrentQuarter(); | random_line_split |
||
merge_queryable.go | }
// ensure the name of a retained tenant id label gets handled under the
// original label name
if name == originalDefaultTenantLabel {
name = defaultTenantLabel
}
return m.mergeDistinctStringSlice(func(ctx context.Context, q storage.Querier) ([]string, storage.Warnings, error) {
return q.LabelValues(name, matchers...)
})
}
// LabelNames returns all the unique label names present in the underlying
// queriers. It also adds the defaultTenantLabel and if present in the original
// results the originalDefaultTenantLabel
func (m *mergeQuerier) LabelNames() ([]string, storage.Warnings, error) {
labelNames, warnings, err := m.mergeDistinctStringSlice(func(ctx context.Context, q storage.Querier) ([]string, storage.Warnings, error) {
return q.LabelNames()
})
if err != nil {
return nil, nil, err
}
// check if the tenant label exists in the original result
var tenantLabelExists bool
labelPos := sort.SearchStrings(labelNames, defaultTenantLabel)
if labelPos < len(labelNames) && labelNames[labelPos] == defaultTenantLabel {
tenantLabelExists = true
}
labelToAdd := defaultTenantLabel
// if defaultTenantLabel already exists, we need to add the
// originalDefaultTenantLabel
if tenantLabelExists {
labelToAdd = originalDefaultTenantLabel
labelPos = sort.SearchStrings(labelNames, labelToAdd)
}
// insert label at the correct position
labelNames = append(labelNames, "")
copy(labelNames[labelPos+1:], labelNames[labelPos:])
labelNames[labelPos] = labelToAdd
return labelNames, warnings, nil
}
type stringSliceFunc func(context.Context, storage.Querier) ([]string, storage.Warnings, error)
type stringSliceFuncJob struct {
querier storage.Querier
tenantID string
result []string
warnings storage.Warnings
}
// mergeDistinctStringSlice is aggregating results from stringSliceFunc calls
// on per querier in parallel. It removes duplicates and sorts the result. It
// doesn't require the output of the stringSliceFunc to be sorted, as results
// of LabelValues are not sorted.
func (m *mergeQuerier) mergeDistinctStringSlice(f stringSliceFunc) ([]string, storage.Warnings, error) {
var jobs = make([]interface{}, len(m.tenantIDs))
for pos := range m.tenantIDs {
jobs[pos] = &stringSliceFuncJob{
querier: m.queriers[pos],
tenantID: m.tenantIDs[pos],
}
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
var err error
job.result, job.warnings, err = f(ctx, job.querier)
if err != nil {
return errors.Wrapf(err, "error querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID)
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return nil, nil, err
}
// aggregate warnings and deduplicate string results
var warnings storage.Warnings
resultMap := make(map[string]struct{})
for _, jobIntf := range jobs {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return nil, nil, fmt.Errorf("unexpected type %T", jobIntf)
}
for _, e := range job.result {
resultMap[e] = struct{}{}
}
for _, w := range job.warnings {
warnings = append(warnings, errors.Wrapf(w, "warning querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID))
}
}
var result = make([]string, 0, len(resultMap))
for e := range resultMap {
result = append(result, e)
}
sort.Strings(result)
return result, warnings, nil
}
// Close releases the resources of the Querier.
func (m *mergeQuerier) Close() error {
errs := tsdb_errors.NewMulti()
for pos, tenantID := range m.tenantIDs {
errs.Add(errors.Wrapf(m.queriers[pos].Close(), "failed to close querier for %s %s", rewriteLabelName(defaultTenantLabel), tenantID))
}
return errs.Err()
}
type selectJob struct {
pos int
querier storage.Querier
tenantID string
}
// Select returns a set of series that matches the given label matchers. If the
// tenantLabelName is matched on it only considers those queriers matching. The
// forwarded labelSelector is not containing those that operate on
// tenantLabelName.
func (m *mergeQuerier) Select(sortSeries bool, hints *storage.SelectHints, matchers ...*labels.Matcher) storage.SeriesSet {
matchedTenants, filteredMatchers := filterValuesByMatchers(defaultTenantLabel, m.tenantIDs, matchers...)
var jobs = make([]interface{}, len(matchedTenants))
var seriesSets = make([]storage.SeriesSet, len(matchedTenants))
var jobPos int
for tenantPos := range m.tenantIDs {
if _, matched := matchedTenants[m.tenantIDs[tenantPos]]; !matched {
continue
}
jobs[jobPos] = &selectJob{
pos: jobPos,
querier: m.queriers[tenantPos],
tenantID: m.tenantIDs[tenantPos],
}
jobPos++
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*selectJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
seriesSets[job.pos] = &addLabelsSeriesSet{
upstream: job.querier.Select(sortSeries, hints, filteredMatchers...),
labels: labels.Labels{
{
Name: defaultTenantLabel,
Value: job.tenantID,
},
},
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return storage.ErrSeriesSet(err)
}
return storage.NewMergeSeriesSet(seriesSets, storage.ChainedSeriesMerge)
}
// filterValuesByMatchers applies matchers to inputed labelName and
// labelValues. A map of matched values is returned and also all label matchers
// not matching the labelName.
// In case a label matcher is set on a label conflicting with tenantLabelName,
// we need to rename this labelMatcher's name to its original name. This is
// used to as part of Select in the mergeQueryable, to ensure only relevant
// queries are considered and the forwarded matchers do not contain matchers on
// the tenantLabelName.
func filterValuesByMatchers(labelName string, labelValues []string, matchers ...*labels.Matcher) (matchedValues map[string]struct{}, unrelatedMatchers []*labels.Matcher) {
// this contains the matchers which are not related to labelName
unrelatedMatchers = make([]*labels.Matcher, 0, len(matchers))
// build map of values to consider for the matchers
matchedValues = make(map[string]struct{}, len(labelValues))
for _, value := range labelValues {
matchedValues[value] = struct{}{}
}
for _, m := range matchers {
if m.Name != labelName {
// check if has the retained label name
if m.Name == originalDefaultTenantLabel {
// rewrite label to the original name, by copying matcher and
// replacing the label name
rewrittenM := *m
rewrittenM.Name = labelName
unrelatedMatchers = append(unrelatedMatchers, &rewrittenM)
} else {
unrelatedMatchers = append(unrelatedMatchers, m)
}
continue
}
for value := range matchedValues {
if !m.Matches(value) {
delete(matchedValues, value)
}
}
}
return matchedValues, unrelatedMatchers
}
type addLabelsSeriesSet struct {
upstream storage.SeriesSet
labels labels.Labels
}
func (m *addLabelsSeriesSet) Next() bool {
return m.upstream.Next()
}
// At returns full series. Returned series should be iteratable even after Next is called.
func (m *addLabelsSeriesSet) At() storage.Series {
return &addLabelsSeries{
upstream: m.upstream.At(),
labels: m.labels,
}
}
// The error that iteration as failed with.
// When an error occurs, set cannot continue to iterate.
func (m *addLabelsSeriesSet) Err() error {
return errors.Wrapf(m.upstream.Err(), "error querying %s", labelsToString(m.labels))
}
// A collection of warnings for the whole set.
// Warnings could be return even iteration has not failed with error.
func (m *addLabelsSeriesSet) Warnings() storage.Warnings | {
upstream := m.upstream.Warnings()
warnings := make(storage.Warnings, len(upstream))
for pos := range upstream {
warnings[pos] = errors.Wrapf(upstream[pos], "warning querying %s", labelsToString(m.labels))
}
return warnings
} | identifier_body |
|
merge_queryable.go | Names) && labelNames[labelPos] == defaultTenantLabel {
tenantLabelExists = true
}
labelToAdd := defaultTenantLabel
// if defaultTenantLabel already exists, we need to add the
// originalDefaultTenantLabel
if tenantLabelExists {
labelToAdd = originalDefaultTenantLabel
labelPos = sort.SearchStrings(labelNames, labelToAdd)
}
// insert label at the correct position
labelNames = append(labelNames, "")
copy(labelNames[labelPos+1:], labelNames[labelPos:])
labelNames[labelPos] = labelToAdd
return labelNames, warnings, nil
}
type stringSliceFunc func(context.Context, storage.Querier) ([]string, storage.Warnings, error)
type stringSliceFuncJob struct {
querier storage.Querier
tenantID string
result []string
warnings storage.Warnings
}
// mergeDistinctStringSlice is aggregating results from stringSliceFunc calls
// on per querier in parallel. It removes duplicates and sorts the result. It
// doesn't require the output of the stringSliceFunc to be sorted, as results
// of LabelValues are not sorted.
func (m *mergeQuerier) mergeDistinctStringSlice(f stringSliceFunc) ([]string, storage.Warnings, error) {
var jobs = make([]interface{}, len(m.tenantIDs))
for pos := range m.tenantIDs {
jobs[pos] = &stringSliceFuncJob{
querier: m.queriers[pos],
tenantID: m.tenantIDs[pos],
}
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
var err error
job.result, job.warnings, err = f(ctx, job.querier)
if err != nil {
return errors.Wrapf(err, "error querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID)
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return nil, nil, err
}
// aggregate warnings and deduplicate string results
var warnings storage.Warnings
resultMap := make(map[string]struct{})
for _, jobIntf := range jobs {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return nil, nil, fmt.Errorf("unexpected type %T", jobIntf)
}
for _, e := range job.result {
resultMap[e] = struct{}{}
}
for _, w := range job.warnings {
warnings = append(warnings, errors.Wrapf(w, "warning querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID))
}
}
var result = make([]string, 0, len(resultMap))
for e := range resultMap {
result = append(result, e)
}
sort.Strings(result)
return result, warnings, nil
}
// Close releases the resources of the Querier.
func (m *mergeQuerier) Close() error {
errs := tsdb_errors.NewMulti()
for pos, tenantID := range m.tenantIDs {
errs.Add(errors.Wrapf(m.queriers[pos].Close(), "failed to close querier for %s %s", rewriteLabelName(defaultTenantLabel), tenantID))
}
return errs.Err()
}
type selectJob struct {
pos int
querier storage.Querier
tenantID string
}
// Select returns a set of series that matches the given label matchers. If the
// tenantLabelName is matched on it only considers those queriers matching. The
// forwarded labelSelector is not containing those that operate on
// tenantLabelName.
func (m *mergeQuerier) Select(sortSeries bool, hints *storage.SelectHints, matchers ...*labels.Matcher) storage.SeriesSet {
matchedTenants, filteredMatchers := filterValuesByMatchers(defaultTenantLabel, m.tenantIDs, matchers...)
var jobs = make([]interface{}, len(matchedTenants))
var seriesSets = make([]storage.SeriesSet, len(matchedTenants))
var jobPos int
for tenantPos := range m.tenantIDs {
if _, matched := matchedTenants[m.tenantIDs[tenantPos]]; !matched {
continue
}
jobs[jobPos] = &selectJob{
pos: jobPos,
querier: m.queriers[tenantPos],
tenantID: m.tenantIDs[tenantPos],
}
jobPos++
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*selectJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
seriesSets[job.pos] = &addLabelsSeriesSet{
upstream: job.querier.Select(sortSeries, hints, filteredMatchers...),
labels: labels.Labels{
{
Name: defaultTenantLabel,
Value: job.tenantID,
},
},
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return storage.ErrSeriesSet(err)
}
return storage.NewMergeSeriesSet(seriesSets, storage.ChainedSeriesMerge)
}
// filterValuesByMatchers applies matchers to inputed labelName and
// labelValues. A map of matched values is returned and also all label matchers
// not matching the labelName.
// In case a label matcher is set on a label conflicting with tenantLabelName,
// we need to rename this labelMatcher's name to its original name. This is
// used to as part of Select in the mergeQueryable, to ensure only relevant
// queries are considered and the forwarded matchers do not contain matchers on
// the tenantLabelName.
func filterValuesByMatchers(labelName string, labelValues []string, matchers ...*labels.Matcher) (matchedValues map[string]struct{}, unrelatedMatchers []*labels.Matcher) {
// this contains the matchers which are not related to labelName
unrelatedMatchers = make([]*labels.Matcher, 0, len(matchers))
// build map of values to consider for the matchers
matchedValues = make(map[string]struct{}, len(labelValues))
for _, value := range labelValues {
matchedValues[value] = struct{}{}
}
for _, m := range matchers {
if m.Name != labelName {
// check if has the retained label name
if m.Name == originalDefaultTenantLabel {
// rewrite label to the original name, by copying matcher and
// replacing the label name
rewrittenM := *m
rewrittenM.Name = labelName
unrelatedMatchers = append(unrelatedMatchers, &rewrittenM)
} else {
unrelatedMatchers = append(unrelatedMatchers, m)
}
continue
}
for value := range matchedValues {
if !m.Matches(value) {
delete(matchedValues, value)
}
}
}
return matchedValues, unrelatedMatchers
}
type addLabelsSeriesSet struct {
upstream storage.SeriesSet
labels labels.Labels
}
func (m *addLabelsSeriesSet) Next() bool {
return m.upstream.Next()
}
// At returns full series. Returned series should be iteratable even after Next is called.
func (m *addLabelsSeriesSet) At() storage.Series {
return &addLabelsSeries{
upstream: m.upstream.At(),
labels: m.labels,
}
}
// The error that iteration as failed with.
// When an error occurs, set cannot continue to iterate.
func (m *addLabelsSeriesSet) Err() error {
return errors.Wrapf(m.upstream.Err(), "error querying %s", labelsToString(m.labels))
}
// A collection of warnings for the whole set.
// Warnings could be return even iteration has not failed with error.
func (m *addLabelsSeriesSet) Warnings() storage.Warnings {
upstream := m.upstream.Warnings()
warnings := make(storage.Warnings, len(upstream))
for pos := range upstream {
warnings[pos] = errors.Wrapf(upstream[pos], "warning querying %s", labelsToString(m.labels))
}
return warnings
}
// rewrite label name to be more readable in error output
func rewriteLabelName(s string) string {
return strings.TrimRight(strings.TrimLeft(s, "_"), "_")
}
// this outputs a more readable error format
func labelsToString(labels labels.Labels) string {
parts := make([]string, len(labels))
for pos, l := range labels {
parts[pos] = rewriteLabelName(l.Name) + " " + l.Value
}
return strings.Join(parts, ", ")
}
type addLabelsSeries struct {
upstream storage.Series
labels labels.Labels
}
// Labels returns the complete set of labels. For series it means all labels identifying the series.
func (a *addLabelsSeries) Labels() labels.Labels {
return setLabelsRetainExisting(a.upstream.Labels(), a.labels...)
}
// Iterator returns a new, independent iterator of the data of the series.
func (a *addLabelsSeries) Iterator() chunkenc.Iterator {
return a.upstream.Iterator()
}
// this sets a label and preserves an existing value a new label prefixed with
// original_. It doesn't do this recursively.
func | setLabelsRetainExisting | identifier_name |
|
merge_queryable.go | nil
}
// ensure the name of a retained tenant id label gets handled under the
// original label name
if name == originalDefaultTenantLabel {
name = defaultTenantLabel
}
return m.mergeDistinctStringSlice(func(ctx context.Context, q storage.Querier) ([]string, storage.Warnings, error) {
return q.LabelValues(name, matchers...)
})
}
// LabelNames returns all the unique label names present in the underlying
// queriers. It also adds the defaultTenantLabel and if present in the original
// results the originalDefaultTenantLabel
func (m *mergeQuerier) LabelNames() ([]string, storage.Warnings, error) {
labelNames, warnings, err := m.mergeDistinctStringSlice(func(ctx context.Context, q storage.Querier) ([]string, storage.Warnings, error) {
return q.LabelNames()
})
if err != nil {
return nil, nil, err
}
// check if the tenant label exists in the original result
var tenantLabelExists bool
labelPos := sort.SearchStrings(labelNames, defaultTenantLabel)
if labelPos < len(labelNames) && labelNames[labelPos] == defaultTenantLabel {
tenantLabelExists = true
}
labelToAdd := defaultTenantLabel
// if defaultTenantLabel already exists, we need to add the
// originalDefaultTenantLabel
if tenantLabelExists {
labelToAdd = originalDefaultTenantLabel
labelPos = sort.SearchStrings(labelNames, labelToAdd)
}
// insert label at the correct position
labelNames = append(labelNames, "")
copy(labelNames[labelPos+1:], labelNames[labelPos:])
labelNames[labelPos] = labelToAdd
return labelNames, warnings, nil
}
type stringSliceFunc func(context.Context, storage.Querier) ([]string, storage.Warnings, error)
type stringSliceFuncJob struct {
querier storage.Querier
tenantID string
result []string
warnings storage.Warnings
}
// mergeDistinctStringSlice is aggregating results from stringSliceFunc calls
// on per querier in parallel. It removes duplicates and sorts the result. It
// doesn't require the output of the stringSliceFunc to be sorted, as results
// of LabelValues are not sorted.
func (m *mergeQuerier) mergeDistinctStringSlice(f stringSliceFunc) ([]string, storage.Warnings, error) {
var jobs = make([]interface{}, len(m.tenantIDs))
for pos := range m.tenantIDs {
jobs[pos] = &stringSliceFuncJob{
querier: m.queriers[pos],
tenantID: m.tenantIDs[pos],
}
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
var err error
job.result, job.warnings, err = f(ctx, job.querier)
if err != nil {
return errors.Wrapf(err, "error querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID)
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return nil, nil, err
}
// aggregate warnings and deduplicate string results
var warnings storage.Warnings
resultMap := make(map[string]struct{})
for _, jobIntf := range jobs {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return nil, nil, fmt.Errorf("unexpected type %T", jobIntf)
}
for _, e := range job.result {
resultMap[e] = struct{}{}
}
for _, w := range job.warnings {
warnings = append(warnings, errors.Wrapf(w, "warning querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID))
}
}
var result = make([]string, 0, len(resultMap))
for e := range resultMap {
result = append(result, e)
}
sort.Strings(result)
return result, warnings, nil
}
// Close releases the resources of the Querier.
func (m *mergeQuerier) Close() error {
errs := tsdb_errors.NewMulti()
for pos, tenantID := range m.tenantIDs {
errs.Add(errors.Wrapf(m.queriers[pos].Close(), "failed to close querier for %s %s", rewriteLabelName(defaultTenantLabel), tenantID))
}
return errs.Err()
}
type selectJob struct {
pos int
querier storage.Querier
tenantID string
}
// Select returns a set of series that matches the given label matchers. If the
// tenantLabelName is matched on it only considers those queriers matching. The
// forwarded labelSelector is not containing those that operate on
// tenantLabelName.
func (m *mergeQuerier) Select(sortSeries bool, hints *storage.SelectHints, matchers ...*labels.Matcher) storage.SeriesSet {
matchedTenants, filteredMatchers := filterValuesByMatchers(defaultTenantLabel, m.tenantIDs, matchers...)
var jobs = make([]interface{}, len(matchedTenants))
var seriesSets = make([]storage.SeriesSet, len(matchedTenants))
var jobPos int
for tenantPos := range m.tenantIDs {
if _, matched := matchedTenants[m.tenantIDs[tenantPos]]; !matched {
continue
}
jobs[jobPos] = &selectJob{
pos: jobPos,
querier: m.queriers[tenantPos],
tenantID: m.tenantIDs[tenantPos],
}
jobPos++
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*selectJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
seriesSets[job.pos] = &addLabelsSeriesSet{
upstream: job.querier.Select(sortSeries, hints, filteredMatchers...),
labels: labels.Labels{
{
Name: defaultTenantLabel,
Value: job.tenantID,
},
},
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return storage.ErrSeriesSet(err)
}
return storage.NewMergeSeriesSet(seriesSets, storage.ChainedSeriesMerge)
}
// filterValuesByMatchers applies matchers to inputed labelName and
// labelValues. A map of matched values is returned and also all label matchers
// not matching the labelName.
// In case a label matcher is set on a label conflicting with tenantLabelName,
// we need to rename this labelMatcher's name to its original name. This is
// used to as part of Select in the mergeQueryable, to ensure only relevant
// queries are considered and the forwarded matchers do not contain matchers on
// the tenantLabelName.
func filterValuesByMatchers(labelName string, labelValues []string, matchers ...*labels.Matcher) (matchedValues map[string]struct{}, unrelatedMatchers []*labels.Matcher) {
// this contains the matchers which are not related to labelName
unrelatedMatchers = make([]*labels.Matcher, 0, len(matchers))
// build map of values to consider for the matchers
matchedValues = make(map[string]struct{}, len(labelValues))
for _, value := range labelValues {
matchedValues[value] = struct{}{}
}
for _, m := range matchers {
if m.Name != labelName {
// check if has the retained label name
if m.Name == originalDefaultTenantLabel {
// rewrite label to the original name, by copying matcher and
// replacing the label name
rewrittenM := *m
rewrittenM.Name = labelName
unrelatedMatchers = append(unrelatedMatchers, &rewrittenM)
} else {
unrelatedMatchers = append(unrelatedMatchers, m)
}
continue
}
for value := range matchedValues {
if !m.Matches(value) {
delete(matchedValues, value)
}
}
}
return matchedValues, unrelatedMatchers
}
type addLabelsSeriesSet struct {
upstream storage.SeriesSet
labels labels.Labels
}
func (m *addLabelsSeriesSet) Next() bool {
return m.upstream.Next()
}
// At returns full series. Returned series should be iteratable even after Next is called.
func (m *addLabelsSeriesSet) At() storage.Series {
return &addLabelsSeries{
upstream: m.upstream.At(),
labels: m.labels,
}
}
// The error that iteration as failed with.
// When an error occurs, set cannot continue to iterate.
func (m *addLabelsSeriesSet) Err() error {
return errors.Wrapf(m.upstream.Err(), "error querying %s", labelsToString(m.labels))
}
// A collection of warnings for the whole set.
// Warnings could be return even iteration has not failed with error.
func (m *addLabelsSeriesSet) Warnings() storage.Warnings {
upstream := m.upstream.Warnings()
warnings := make(storage.Warnings, len(upstream))
for pos := range upstream {
warnings[pos] = errors.Wrapf(upstream[pos], "warning querying %s", labelsToString(m.labels)) | }
return warnings | random_line_split |
|
merge_queryable.go | m *mergeQueryable) Querier(ctx context.Context, mint int64, maxt int64) (storage.Querier, error) {
tenantIDs, err := tenant.TenantIDs(ctx)
if err != nil {
return nil, err
}
if len(tenantIDs) <= 1 {
return m.upstream.Querier(ctx, mint, maxt)
}
var queriers = make([]storage.Querier, len(tenantIDs))
for pos, tenantID := range tenantIDs {
q, err := m.upstream.Querier(
user.InjectOrgID(ctx, tenantID),
mint,
maxt,
)
if err != nil {
return nil, err
}
queriers[pos] = q
}
return &mergeQuerier{
ctx: ctx,
queriers: queriers,
tenantIDs: tenantIDs,
}, nil
}
// mergeQuerier aggregates the results from underlying queriers and adds a
// label tenantLabelName to identify the tenant ID that the metric resulted
// from.
// If the label tenantLabelName is already existing, its value is
// overwritten by the tenant ID and the previous value is exposed through a new
// label prefixed with "original_". This behaviour is not implemented recursively
type mergeQuerier struct {
ctx context.Context
queriers []storage.Querier
tenantIDs []string
}
// LabelValues returns all potential values for a label name.
// It is not safe to use the strings beyond the lifefime of the querier.
// For the label "tenantLabelName" it will return all the tenant IDs available.
// For the label "original_" + tenantLabelName it will return all the values
// of the underlying queriers for tenantLabelName.
func (m *mergeQuerier) LabelValues(name string, matchers ...*labels.Matcher) ([]string, storage.Warnings, error) {
if name == defaultTenantLabel {
return m.tenantIDs, nil, nil
}
// ensure the name of a retained tenant id label gets handled under the
// original label name
if name == originalDefaultTenantLabel {
name = defaultTenantLabel
}
return m.mergeDistinctStringSlice(func(ctx context.Context, q storage.Querier) ([]string, storage.Warnings, error) {
return q.LabelValues(name, matchers...)
})
}
// LabelNames returns all the unique label names present in the underlying
// queriers. It also adds the defaultTenantLabel and if present in the original
// results the originalDefaultTenantLabel
func (m *mergeQuerier) LabelNames() ([]string, storage.Warnings, error) {
labelNames, warnings, err := m.mergeDistinctStringSlice(func(ctx context.Context, q storage.Querier) ([]string, storage.Warnings, error) {
return q.LabelNames()
})
if err != nil {
return nil, nil, err
}
// check if the tenant label exists in the original result
var tenantLabelExists bool
labelPos := sort.SearchStrings(labelNames, defaultTenantLabel)
if labelPos < len(labelNames) && labelNames[labelPos] == defaultTenantLabel {
tenantLabelExists = true
}
labelToAdd := defaultTenantLabel
// if defaultTenantLabel already exists, we need to add the
// originalDefaultTenantLabel
if tenantLabelExists {
labelToAdd = originalDefaultTenantLabel
labelPos = sort.SearchStrings(labelNames, labelToAdd)
}
// insert label at the correct position
labelNames = append(labelNames, "")
copy(labelNames[labelPos+1:], labelNames[labelPos:])
labelNames[labelPos] = labelToAdd
return labelNames, warnings, nil
}
type stringSliceFunc func(context.Context, storage.Querier) ([]string, storage.Warnings, error)
type stringSliceFuncJob struct {
querier storage.Querier
tenantID string
result []string
warnings storage.Warnings
}
// mergeDistinctStringSlice is aggregating results from stringSliceFunc calls
// on per querier in parallel. It removes duplicates and sorts the result. It
// doesn't require the output of the stringSliceFunc to be sorted, as results
// of LabelValues are not sorted.
func (m *mergeQuerier) mergeDistinctStringSlice(f stringSliceFunc) ([]string, storage.Warnings, error) {
var jobs = make([]interface{}, len(m.tenantIDs))
for pos := range m.tenantIDs {
jobs[pos] = &stringSliceFuncJob{
querier: m.queriers[pos],
tenantID: m.tenantIDs[pos],
}
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
var err error
job.result, job.warnings, err = f(ctx, job.querier)
if err != nil {
return errors.Wrapf(err, "error querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID)
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return nil, nil, err
}
// aggregate warnings and deduplicate string results
var warnings storage.Warnings
resultMap := make(map[string]struct{})
for _, jobIntf := range jobs {
job, ok := jobIntf.(*stringSliceFuncJob)
if !ok {
return nil, nil, fmt.Errorf("unexpected type %T", jobIntf)
}
for _, e := range job.result {
resultMap[e] = struct{}{}
}
for _, w := range job.warnings {
warnings = append(warnings, errors.Wrapf(w, "warning querying %s %s", rewriteLabelName(defaultTenantLabel), job.tenantID))
}
}
var result = make([]string, 0, len(resultMap))
for e := range resultMap {
result = append(result, e)
}
sort.Strings(result)
return result, warnings, nil
}
// Close releases the resources of the Querier.
func (m *mergeQuerier) Close() error {
errs := tsdb_errors.NewMulti()
for pos, tenantID := range m.tenantIDs |
return errs.Err()
}
type selectJob struct {
pos int
querier storage.Querier
tenantID string
}
// Select returns a set of series that matches the given label matchers. If the
// tenantLabelName is matched on it only considers those queriers matching. The
// forwarded labelSelector is not containing those that operate on
// tenantLabelName.
func (m *mergeQuerier) Select(sortSeries bool, hints *storage.SelectHints, matchers ...*labels.Matcher) storage.SeriesSet {
matchedTenants, filteredMatchers := filterValuesByMatchers(defaultTenantLabel, m.tenantIDs, matchers...)
var jobs = make([]interface{}, len(matchedTenants))
var seriesSets = make([]storage.SeriesSet, len(matchedTenants))
var jobPos int
for tenantPos := range m.tenantIDs {
if _, matched := matchedTenants[m.tenantIDs[tenantPos]]; !matched {
continue
}
jobs[jobPos] = &selectJob{
pos: jobPos,
querier: m.queriers[tenantPos],
tenantID: m.tenantIDs[tenantPos],
}
jobPos++
}
run := func(ctx context.Context, jobIntf interface{}) error {
job, ok := jobIntf.(*selectJob)
if !ok {
return fmt.Errorf("unexpected type %T", jobIntf)
}
seriesSets[job.pos] = &addLabelsSeriesSet{
upstream: job.querier.Select(sortSeries, hints, filteredMatchers...),
labels: labels.Labels{
{
Name: defaultTenantLabel,
Value: job.tenantID,
},
},
}
return nil
}
err := concurrency.ForEach(m.ctx, jobs, maxConcurrency, run)
if err != nil {
return storage.ErrSeriesSet(err)
}
return storage.NewMergeSeriesSet(seriesSets, storage.ChainedSeriesMerge)
}
// filterValuesByMatchers applies matchers to inputed labelName and
// labelValues. A map of matched values is returned and also all label matchers
// not matching the labelName.
// In case a label matcher is set on a label conflicting with tenantLabelName,
// we need to rename this labelMatcher's name to its original name. This is
// used to as part of Select in the mergeQueryable, to ensure only relevant
// queries are considered and the forwarded matchers do not contain matchers on
// the tenantLabelName.
func filterValuesByMatchers(labelName string, labelValues []string, matchers ...*labels.Matcher) (matchedValues map[string]struct{}, unrelatedMatchers []*labels.Matcher) {
// this contains the matchers which are not related to labelName
unrelatedMatchers = make([]*labels.Matcher, 0, len(matchers))
// build map of values to consider for the matchers
matched | {
errs.Add(errors.Wrapf(m.queriers[pos].Close(), "failed to close querier for %s %s", rewriteLabelName(defaultTenantLabel), tenantID))
} | conditional_block |
model.py | # Model class constructor
def __init__(self, gpu):
''' Initialise model object
'''
# Set device
if (gpu):
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
else:
self.device = "cpu"
# Function to build model
def | (self, arch, learning_rate, hidden_units):
''' Function to build model
'''
print('Building model...')
# Select & load pre-trained model
try:
arch = arch.lower()
self.model = models.__dict__[arch](pretrained=True)
self.arch = arch
except:
print("Model " + arch + " not recognised: please refer to documentation for valid model names in pytorch ie vgg16 https://pytorch.org/docs/stable/torchvision/models.html")
sys.exit()
self.hidden_units = hidden_units
self.learning_rate = learning_rate
# Freeze parameters of pre-trained model part by removing gradients
for param in self.model.parameters():
param.requires_grad = False
# Determine classifier input units for selected model
if hasattr(self.model, "classifier"):
try:
classifier_input_neurons = self.model.classifier[0].in_features
except TypeError:
classifier_input_neurons = self.model.classifier.in_features
elif hasattr(self.model, "fc"):
classifier_input_neurons = self.model.fc.in_features
else:
print("Unable to determine classifier input units number - unable to create model")
return
# Classifier architecture parameters
classifier_output_neurons = 102
classifier_dropout = 0.2
# Build new classifier for recognising flowers to work with model
self.model.classifier = nn.Sequential(OrderedDict([
('fc1', nn.Linear(classifier_input_neurons, hidden_units)),
('relu', nn.ReLU()),
('dropout', nn.Dropout(classifier_dropout)),
('fc2', nn.Linear(hidden_units, classifier_output_neurons)),
('output', nn.LogSoftmax(dim=1))]))
# Define model loss function
self.criterion = nn.NLLLoss()
# Define training function: only train the classifier parameters, feature parameters are frozen
self.optimizer = optim.Adam(self.model.classifier.parameters(), lr=learning_rate)
# Move model to current device
self.model.to(self.device)
# Function to train model
def train(self, epochs, trainloader, validloader, class_to_idx):
''' Function to train model
'''
print('Training model...')
# Set variables
self.epochs = epochs
self.training_steps = 0
training_loss = 0
print_every = 20
self.model.class_to_idx = class_to_idx
# Train network
# Ensure notebook session stays active through long runs
with active_session():
# For each training pass of whole dataset/epoch
for epoch in range(epochs):
print(f"Epoch {epoch+1}")
print("-------")
# For each training batch/step of images & labels
for inputs, labels in trainloader:
# Increment training steps count
self.training_steps += 1
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Clear gradients
self.optimizer.zero_grad()
# Do forward pass through network
logps = self.model(inputs)
# Calculate loss for whole network
loss = self.criterion(logps, labels)
# Calculate gradients for each element to be trained by network (weights & biases)
loss.backward()
# Do back-propogation step: apply negative gradients to weights & biases
self.optimizer.step()
# Accumulate training loss
training_loss += loss.item()
# Every 20 training steps, validation check & output stats
if self.training_steps % print_every == 0:
valid_loss = 0
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal validation/prediction
with torch.no_grad():
# For each validation batch of images & labels
for inputs, labels in validloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate loss for network
batch_loss = self.criterion(logps, labels)
# Accumulate validation loss
valid_loss += batch_loss.item()
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
# Output stats for current training step
print(f"Training step {self.training_steps}")
print(f"Training loss: {training_loss/print_every:.3f} - "
f"Validation loss: {valid_loss/len(validloader):.3f} - "
f"Validation accuracy: {accuracy/len(validloader):.3f}")
# Validation end - reset training loss & set model back to training mode
training_loss = 0
self.model.train()
# Function to test model
def test(self, testloader):
''' Function to test model
'''
print('Testing model...')
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal testing/prediction
with torch.no_grad():
# For each test batch of images & labels
for inputs, labels in testloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
else:
# Output accuracy for entire test dataset
print(f"Test accuracy: {accuracy/len(testloader):.3f}")
# Function to save model
def save(self, save_dir):
''' Function to save model
'''
print('Saving model...')
# If save dir set
if (save_dir):
save_dir = save_dir + '/'
# If it does not exist
if (not os.path.isdir(save_dir)):
# Make dir
try:
os.mkdir(save_dir)
except OSError:
print ("Creation of the directory %s failed" % save_dir)
print ("Model was not saved")
sys.exit()
# Define checkpoint parameters
checkpoint = {'class_to_idx': self.model.class_to_idx,
'model_state_dict': self.model.state_dict(),
'arch': self.arch,
'learning_rate': self.learning_rate,
'hidden_units': self.hidden_units,
'epochs': self.epochs,
'training_steps': self.training_steps}
# Save it
torch.save(checkpoint, save_dir + 'checkpoint.pth')
# Function to save model
def load(self, save_dir):
''' Function to load model
'''
print('Loading model...')
# Load checkpoint
if torch.cuda.is_available():
checkpoint = torch.load(save_dir + 'checkpoint.pth')
else:
checkpoint = torch.load(save_dir + 'checkpoint.pth', map_location=lambda storage, loc: storage)
# Create model
self.build(checkpoint['arch'], checkpoint['learning_rate'], checkpoint['hidden_units'])
# Load classifier state values from checkpoint
self.model.load_state_dict(checkpoint['model_state_dict'])
self.model.class_to_idx = checkpoint['class_to_idx']
def predict(self, np_image, topk):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
print('Model predicting...')
# Convert image to tensor
image_tensor = torch.from_numpy(np_image)
# Add batch dimension to tensor
image_tensor = image_tensor.unsqueeze_(0)
# Convert to float tensor
image_tensor = image_tensor.float()
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for model prediction
with torch.no_grad():
# Do forward pass through network
logps = self.model.forward(image_tensor)
# Get actual probabilties output from network for this image
ps = torch.exp(logps)
# Get topk probability/prediction for this image
top_p, top_class = ps.topk(topk, dim=1)
top_p = top_p.numpy()
top_class = top_class.numpy()
# Invert class map
idx_to_class = {j: i for i, j in self.model.class_to_idx.items()}
# Map indexes to get true class indexes
top_classes = [idx_to_class[index | build | identifier_name |
model.py | # Model class constructor
| self.model = models.__dict__[arch](pretrained=True)
self.arch = arch
except:
print("Model " + arch + " not recognised: please refer to documentation for valid model names in pytorch ie vgg16 https://pytorch.org/docs/stable/torchvision/models.html")
sys.exit()
self.hidden_units = hidden_units
self.learning_rate = learning_rate
# Freeze parameters of pre-trained model part by removing gradients
for param in self.model.parameters():
param.requires_grad = False
# Determine classifier input units for selected model
if hasattr(self.model, "classifier"):
try:
classifier_input_neurons = self.model.classifier[0].in_features
except TypeError:
classifier_input_neurons = self.model.classifier.in_features
elif hasattr(self.model, "fc"):
classifier_input_neurons = self.model.fc.in_features
else:
print("Unable to determine classifier input units number - unable to create model")
return
# Classifier architecture parameters
classifier_output_neurons = 102
classifier_dropout = 0.2
# Build new classifier for recognising flowers to work with model
self.model.classifier = nn.Sequential(OrderedDict([
('fc1', nn.Linear(classifier_input_neurons, hidden_units)),
('relu', nn.ReLU()),
('dropout', nn.Dropout(classifier_dropout)),
('fc2', nn.Linear(hidden_units, classifier_output_neurons)),
('output', nn.LogSoftmax(dim=1))]))
# Define model loss function
self.criterion = nn.NLLLoss()
# Define training function: only train the classifier parameters, feature parameters are frozen
self.optimizer = optim.Adam(self.model.classifier.parameters(), lr=learning_rate)
# Move model to current device
self.model.to(self.device)
# Function to train model
def train(self, epochs, trainloader, validloader, class_to_idx):
''' Function to train model
'''
print('Training model...')
# Set variables
self.epochs = epochs
self.training_steps = 0
training_loss = 0
print_every = 20
self.model.class_to_idx = class_to_idx
# Train network
# Ensure notebook session stays active through long runs
with active_session():
# For each training pass of whole dataset/epoch
for epoch in range(epochs):
print(f"Epoch {epoch+1}")
print("-------")
# For each training batch/step of images & labels
for inputs, labels in trainloader:
# Increment training steps count
self.training_steps += 1
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Clear gradients
self.optimizer.zero_grad()
# Do forward pass through network
logps = self.model(inputs)
# Calculate loss for whole network
loss = self.criterion(logps, labels)
# Calculate gradients for each element to be trained by network (weights & biases)
loss.backward()
# Do back-propogation step: apply negative gradients to weights & biases
self.optimizer.step()
# Accumulate training loss
training_loss += loss.item()
# Every 20 training steps, validation check & output stats
if self.training_steps % print_every == 0:
valid_loss = 0
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal validation/prediction
with torch.no_grad():
# For each validation batch of images & labels
for inputs, labels in validloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate loss for network
batch_loss = self.criterion(logps, labels)
# Accumulate validation loss
valid_loss += batch_loss.item()
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
# Output stats for current training step
print(f"Training step {self.training_steps}")
print(f"Training loss: {training_loss/print_every:.3f} - "
f"Validation loss: {valid_loss/len(validloader):.3f} - "
f"Validation accuracy: {accuracy/len(validloader):.3f}")
# Validation end - reset training loss & set model back to training mode
training_loss = 0
self.model.train()
# Function to test model
def test(self, testloader):
''' Function to test model
'''
print('Testing model...')
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal testing/prediction
with torch.no_grad():
# For each test batch of images & labels
for inputs, labels in testloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
else:
# Output accuracy for entire test dataset
print(f"Test accuracy: {accuracy/len(testloader):.3f}")
# Function to save model
def save(self, save_dir):
''' Function to save model
'''
print('Saving model...')
# If save dir set
if (save_dir):
save_dir = save_dir + '/'
# If it does not exist
if (not os.path.isdir(save_dir)):
# Make dir
try:
os.mkdir(save_dir)
except OSError:
print ("Creation of the directory %s failed" % save_dir)
print ("Model was not saved")
sys.exit()
# Define checkpoint parameters
checkpoint = {'class_to_idx': self.model.class_to_idx,
'model_state_dict': self.model.state_dict(),
'arch': self.arch,
'learning_rate': self.learning_rate,
'hidden_units': self.hidden_units,
'epochs': self.epochs,
'training_steps': self.training_steps}
# Save it
torch.save(checkpoint, save_dir + 'checkpoint.pth')
# Function to save model
def load(self, save_dir):
''' Function to load model
'''
print('Loading model...')
# Load checkpoint
if torch.cuda.is_available():
checkpoint = torch.load(save_dir + 'checkpoint.pth')
else:
checkpoint = torch.load(save_dir + 'checkpoint.pth', map_location=lambda storage, loc: storage)
# Create model
self.build(checkpoint['arch'], checkpoint['learning_rate'], checkpoint['hidden_units'])
# Load classifier state values from checkpoint
self.model.load_state_dict(checkpoint['model_state_dict'])
self.model.class_to_idx = checkpoint['class_to_idx']
def predict(self, np_image, topk):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
print('Model predicting...')
# Convert image to tensor
image_tensor = torch.from_numpy(np_image)
# Add batch dimension to tensor
image_tensor = image_tensor.unsqueeze_(0)
# Convert to float tensor
image_tensor = image_tensor.float()
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for model prediction
with torch.no_grad():
# Do forward pass through network
logps = self.model.forward(image_tensor)
# Get actual probabilties output from network for this image
ps = torch.exp(logps)
# Get topk probability/prediction for this image
top_p, top_class = ps.topk(topk, dim=1)
top_p = top_p.numpy()
top_class = top_class.numpy()
# Invert class map
idx_to_class = {j: i for i, j in self.model.class_to_idx.items()}
# Map indexes to get true class indexes
top_classes = [idx_to_class[index] | def __init__(self, gpu):
''' Initialise model object
'''
# Set device
if (gpu):
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
else:
self.device = "cpu"
# Function to build model
def build(self, arch, learning_rate, hidden_units):
''' Function to build model
'''
print('Building model...')
# Select & load pre-trained model
try:
arch = arch.lower() | identifier_body |
model.py | # Model class constructor
def __init__(self, gpu):
''' Initialise model object
'''
# Set device
if (gpu):
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
else:
self.device = "cpu"
# Function to build model
def build(self, arch, learning_rate, hidden_units):
''' Function to build model
'''
print('Building model...')
# Select & load pre-trained model
try:
arch = arch.lower()
self.model = models.__dict__[arch](pretrained=True)
self.arch = arch
except:
print("Model " + arch + " not recognised: please refer to documentation for valid model names in pytorch ie vgg16 https://pytorch.org/docs/stable/torchvision/models.html")
sys.exit()
self.hidden_units = hidden_units
self.learning_rate = learning_rate
# Freeze parameters of pre-trained model part by removing gradients
for param in self.model.parameters():
param.requires_grad = False
# Determine classifier input units for selected model
if hasattr(self.model, "classifier"):
try:
classifier_input_neurons = self.model.classifier[0].in_features
except TypeError:
classifier_input_neurons = self.model.classifier.in_features
elif hasattr(self.model, "fc"):
classifier_input_neurons = self.model.fc.in_features
else:
print("Unable to determine classifier input units number - unable to create model")
return
# Classifier architecture parameters
classifier_output_neurons = 102
classifier_dropout = 0.2
# Build new classifier for recognising flowers to work with model
self.model.classifier = nn.Sequential(OrderedDict([
('fc1', nn.Linear(classifier_input_neurons, hidden_units)),
('relu', nn.ReLU()),
('dropout', nn.Dropout(classifier_dropout)),
('fc2', nn.Linear(hidden_units, classifier_output_neurons)),
('output', nn.LogSoftmax(dim=1))]))
# Define model loss function
self.criterion = nn.NLLLoss()
# Define training function: only train the classifier parameters, feature parameters are frozen
self.optimizer = optim.Adam(self.model.classifier.parameters(), lr=learning_rate)
# Move model to current device
self.model.to(self.device)
# Function to train model
def train(self, epochs, trainloader, validloader, class_to_idx):
''' Function to train model
'''
print('Training model...')
# Set variables
self.epochs = epochs
self.training_steps = 0
training_loss = 0
print_every = 20
self.model.class_to_idx = class_to_idx
# Train network
# Ensure notebook session stays active through long runs
with active_session():
# For each training pass of whole dataset/epoch
for epoch in range(epochs):
print(f"Epoch {epoch+1}")
print("-------")
# For each training batch/step of images & labels
for inputs, labels in trainloader:
# Increment training steps count
self.training_steps += 1
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Clear gradients
self.optimizer.zero_grad()
# Do forward pass through network
logps = self.model(inputs)
# Calculate loss for whole network
loss = self.criterion(logps, labels)
# Calculate gradients for each element to be trained by network (weights & biases)
loss.backward()
# Do back-propogation step: apply negative gradients to weights & biases
self.optimizer.step()
# Accumulate training loss
training_loss += loss.item()
# Every 20 training steps, validation check & output stats
if self.training_steps % print_every == 0:
valid_loss = 0
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal validation/prediction
with torch.no_grad():
# For each validation batch of images & labels
for inputs, labels in validloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate loss for network
batch_loss = self.criterion(logps, labels)
# Accumulate validation loss
valid_loss += batch_loss.item()
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
# Output stats for current training step
print(f"Training step {self.training_steps}")
print(f"Training loss: {training_loss/print_every:.3f} - "
f"Validation loss: {valid_loss/len(validloader):.3f} - "
f"Validation accuracy: {accuracy/len(validloader):.3f}")
# Validation end - reset training loss & set model back to training mode
training_loss = 0
self.model.train()
# Function to test model
def test(self, testloader):
''' Function to test model
'''
print('Testing model...')
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal testing/prediction
with torch.no_grad():
# For each test batch of images & labels
for inputs, labels in testloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
else:
# Output accuracy for entire test dataset
print(f"Test accuracy: {accuracy/len(testloader):.3f}")
# Function to save model
def save(self, save_dir):
''' Function to save model
'''
print('Saving model...')
# If save dir set
if (save_dir):
save_dir = save_dir + '/'
# If it does not exist
if (not os.path.isdir(save_dir)):
# Make dir
try:
os.mkdir(save_dir)
except OSError:
print ("Creation of the directory %s failed" % save_dir)
print ("Model was not saved")
sys.exit()
# Define checkpoint parameters
checkpoint = {'class_to_idx': self.model.class_to_idx,
'model_state_dict': self.model.state_dict(),
'arch': self.arch,
'learning_rate': self.learning_rate,
'hidden_units': self.hidden_units,
'epochs': self.epochs,
'training_steps': self.training_steps}
# Save it
torch.save(checkpoint, save_dir + 'checkpoint.pth')
# Function to save model
def load(self, save_dir):
''' Function to load model
'''
print('Loading model...')
# Load checkpoint
if torch.cuda.is_available():
checkpoint = torch.load(save_dir + 'checkpoint.pth')
else:
checkpoint = torch.load(save_dir + 'checkpoint.pth', map_location=lambda storage, loc: storage)
# Create model
self.build(checkpoint['arch'], checkpoint['learning_rate'], checkpoint['hidden_units'])
# Load classifier state values from checkpoint
self.model.load_state_dict(checkpoint['model_state_dict'])
self.model.class_to_idx = checkpoint['class_to_idx']
def predict(self, np_image, topk):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
print('Model predicting...')
# Convert image to tensor
image_tensor = torch.from_numpy(np_image)
# Add batch dimension to tensor
image_tensor = image_tensor.unsqueeze_(0) |
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for model prediction
with torch.no_grad():
# Do forward pass through network
logps = self.model.forward(image_tensor)
# Get actual probabilties output from network for this image
ps = torch.exp(logps)
# Get topk probability/prediction for this image
top_p, top_class = ps.topk(topk, dim=1)
top_p = top_p.numpy()
top_class = top_class.numpy()
# Invert class map
idx_to_class = {j: i for i, j in self.model.class_to_idx.items()}
# Map indexes to get true class indexes
top_classes = [idx_to_class[index | # Convert to float tensor
image_tensor = image_tensor.float() | random_line_split |
model.py | # Model class constructor
def __init__(self, gpu):
''' Initialise model object
'''
# Set device
if (gpu):
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
else:
self.device = "cpu"
# Function to build model
def build(self, arch, learning_rate, hidden_units):
''' Function to build model
'''
print('Building model...')
# Select & load pre-trained model
try:
arch = arch.lower()
self.model = models.__dict__[arch](pretrained=True)
self.arch = arch
except:
print("Model " + arch + " not recognised: please refer to documentation for valid model names in pytorch ie vgg16 https://pytorch.org/docs/stable/torchvision/models.html")
sys.exit()
self.hidden_units = hidden_units
self.learning_rate = learning_rate
# Freeze parameters of pre-trained model part by removing gradients
for param in self.model.parameters():
param.requires_grad = False
# Determine classifier input units for selected model
if hasattr(self.model, "classifier"):
try:
classifier_input_neurons = self.model.classifier[0].in_features
except TypeError:
classifier_input_neurons = self.model.classifier.in_features
elif hasattr(self.model, "fc"):
classifier_input_neurons = self.model.fc.in_features
else:
|
# Classifier architecture parameters
classifier_output_neurons = 102
classifier_dropout = 0.2
# Build new classifier for recognising flowers to work with model
self.model.classifier = nn.Sequential(OrderedDict([
('fc1', nn.Linear(classifier_input_neurons, hidden_units)),
('relu', nn.ReLU()),
('dropout', nn.Dropout(classifier_dropout)),
('fc2', nn.Linear(hidden_units, classifier_output_neurons)),
('output', nn.LogSoftmax(dim=1))]))
# Define model loss function
self.criterion = nn.NLLLoss()
# Define training function: only train the classifier parameters, feature parameters are frozen
self.optimizer = optim.Adam(self.model.classifier.parameters(), lr=learning_rate)
# Move model to current device
self.model.to(self.device)
# Function to train model
def train(self, epochs, trainloader, validloader, class_to_idx):
''' Function to train model
'''
print('Training model...')
# Set variables
self.epochs = epochs
self.training_steps = 0
training_loss = 0
print_every = 20
self.model.class_to_idx = class_to_idx
# Train network
# Ensure notebook session stays active through long runs
with active_session():
# For each training pass of whole dataset/epoch
for epoch in range(epochs):
print(f"Epoch {epoch+1}")
print("-------")
# For each training batch/step of images & labels
for inputs, labels in trainloader:
# Increment training steps count
self.training_steps += 1
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Clear gradients
self.optimizer.zero_grad()
# Do forward pass through network
logps = self.model(inputs)
# Calculate loss for whole network
loss = self.criterion(logps, labels)
# Calculate gradients for each element to be trained by network (weights & biases)
loss.backward()
# Do back-propogation step: apply negative gradients to weights & biases
self.optimizer.step()
# Accumulate training loss
training_loss += loss.item()
# Every 20 training steps, validation check & output stats
if self.training_steps % print_every == 0:
valid_loss = 0
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal validation/prediction
with torch.no_grad():
# For each validation batch of images & labels
for inputs, labels in validloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate loss for network
batch_loss = self.criterion(logps, labels)
# Accumulate validation loss
valid_loss += batch_loss.item()
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
# Output stats for current training step
print(f"Training step {self.training_steps}")
print(f"Training loss: {training_loss/print_every:.3f} - "
f"Validation loss: {valid_loss/len(validloader):.3f} - "
f"Validation accuracy: {accuracy/len(validloader):.3f}")
# Validation end - reset training loss & set model back to training mode
training_loss = 0
self.model.train()
# Function to test model
def test(self, testloader):
''' Function to test model
'''
print('Testing model...')
accuracy = 0
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for modal testing/prediction
with torch.no_grad():
# For each test batch of images & labels
for inputs, labels in testloader:
# Move data and label tensors to device
inputs, labels = inputs.to(self.device), labels.to(self.device)
# Do forward pass through network
logps = self.model.forward(inputs)
# Calculate stats
# Get actual probabilties output from network for this batch
ps = torch.exp(logps)
# Get top probability/prediction for each image in batch
top_p, top_class = ps.topk(1, dim=1)
# Check each prediction against label (accuracy)
equals = top_class == labels.view(*top_class.shape)
# Calculate mean accuracy for this batch
accuracy += torch.mean(equals.type(torch.FloatTensor)).item()
else:
# Output accuracy for entire test dataset
print(f"Test accuracy: {accuracy/len(testloader):.3f}")
# Function to save model
def save(self, save_dir):
''' Function to save model
'''
print('Saving model...')
# If save dir set
if (save_dir):
save_dir = save_dir + '/'
# If it does not exist
if (not os.path.isdir(save_dir)):
# Make dir
try:
os.mkdir(save_dir)
except OSError:
print ("Creation of the directory %s failed" % save_dir)
print ("Model was not saved")
sys.exit()
# Define checkpoint parameters
checkpoint = {'class_to_idx': self.model.class_to_idx,
'model_state_dict': self.model.state_dict(),
'arch': self.arch,
'learning_rate': self.learning_rate,
'hidden_units': self.hidden_units,
'epochs': self.epochs,
'training_steps': self.training_steps}
# Save it
torch.save(checkpoint, save_dir + 'checkpoint.pth')
# Function to save model
def load(self, save_dir):
''' Function to load model
'''
print('Loading model...')
# Load checkpoint
if torch.cuda.is_available():
checkpoint = torch.load(save_dir + 'checkpoint.pth')
else:
checkpoint = torch.load(save_dir + 'checkpoint.pth', map_location=lambda storage, loc: storage)
# Create model
self.build(checkpoint['arch'], checkpoint['learning_rate'], checkpoint['hidden_units'])
# Load classifier state values from checkpoint
self.model.load_state_dict(checkpoint['model_state_dict'])
self.model.class_to_idx = checkpoint['class_to_idx']
def predict(self, np_image, topk):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
print('Model predicting...')
# Convert image to tensor
image_tensor = torch.from_numpy(np_image)
# Add batch dimension to tensor
image_tensor = image_tensor.unsqueeze_(0)
# Convert to float tensor
image_tensor = image_tensor.float()
# Switch to evaluation mode - dropout inactive
self.model.eval()
# Disable gradients - not needed for model prediction
with torch.no_grad():
# Do forward pass through network
logps = self.model.forward(image_tensor)
# Get actual probabilties output from network for this image
ps = torch.exp(logps)
# Get topk probability/prediction for this image
top_p, top_class = ps.topk(topk, dim=1)
top_p = top_p.numpy()
top_class = top_class.numpy()
# Invert class map
idx_to_class = {j: i for i, j in self.model.class_to_idx.items()}
# Map indexes to get true class indexes
top_classes = [idx_to_class[index] | print("Unable to determine classifier input units number - unable to create model")
return | conditional_block |
longfruit.py | prog = 'clang'
opts = [
'-Wno-literal-conversion',
'-Wno-implicit-int-float-conversion'
]
if arch == 'rv64gc':
opts.append('--target=riscv64')
elif arch == 'rv32gc':
opts.append('--target=riscv32')
else:
assert False, 'unsupported arch'
else:
assert False, 'unsupported compiler'
opts = opts + [
'-Werror=implicit-int',
'-Wno-tautological-compare',
'-Wno-overflow',
'-Wno-constant-conversion',
'-Wno-unsequenced',
f'-march={arch}',
f'-mabi={abi}',
'-O2', '-S', '-o', '-', filename
]
r = subprocess.check_output([prog] + opts).decode('utf-8')
return r
def get_cost(asm):
cost_total = 0
for line in filter_asm(asm):
cost = instr_cost(line)
cost_total = cost_total + cost
return cost_total
class Context:
def __init__(self):
self.var_counter = 0
self.vars = []
def gen_var(self, loop_counter = False):
if not loop_counter:
v = f'v{self.var_counter}'
else:
v = f'i{self.var_counter}'
self.var_counter = self.var_counter + 1
self.vars.append(v)
return v
def gen_vars(self, num):
return [self.gen_var() for i in range(randint(1, num))]
def rand_var(self):
return choice(self.vars)
def copy(self):
ctx = Context()
ctx.var_counter = self.var_counter
ctx.vars = self.vars.copy()
return ctx
def gen_type():
return choice([
'char', 'short', 'int', 'long', 'long long',
'float', 'double'
])
def gen_type_integer():
signed = choice(['signed', 'unsigned'])
ty = choice(['char', 'short', 'int', 'long', 'long long'])
return f'{signed} {ty}'
def gen_cast_integer():
return f'({gen_type_integer()})'
def gen_expr_literal_int_zero():
return 0
def gen_expr_literal_int_12_bit():
return randrange(-2048, 2048)
def gen_expr_literal_int_20_bit_up():
return randrange(0, 2**20) << 12
def gen_expr_literal_int_32_bit():
return randrange(-2**31, 2**31)
def gen_expr_literal_int_64_bit():
return randrange(-2**63, 2**63)
def gen_expr_literal_float():
return uniform(-1_000_000, 1_000_000)
def gen_expr_literal(ctx = None):
v = choice([
gen_expr_literal_int_zero,
gen_expr_literal_int_12_bit,
gen_expr_literal_int_20_bit_up,
gen_expr_literal_int_32_bit,
gen_expr_literal_int_64_bit,
gen_expr_literal_float,
])()
return v
def gen_expr_var(ctx):
return ctx.rand_var()
def gen_expr_unary(ctx):
a = ctx.rand_var()
op = choice(['-', '~', '!', '++', '--'])
cast = ''
if op == '~':
# must be applied to an integer operand
cast = gen_cast_integer()
return f'{op}{cast}{a}'
def gen_expr_binary(ctx):
a = ctx.rand_var()
b = ctx.rand_var()
ops = [
'^', '&', '|', '<<', '>>',
'+', '-',
'*', '/', '%',
'==', '!=',
'<', '<=', '>', '>=',
'&&', '||'
]
op = choice(ops)
cast1 = ''
cast2 = ''
if op in ['^', '&', '|', '%', '<<', '>>']:
# must be applied to integer operands
cast1 = gen_cast_integer()
cast2 = gen_cast_integer()
return f'{cast1}{a} {op} {cast2}{b}'
def gen_expr_ternary(ctx):
a = ctx.rand_var()
b = ctx.rand_var()
c = ctx.rand_var()
return f'{a} ? {b} : {c}'
def gen_expr(ctx):
return choice([
gen_expr_var,
gen_expr_literal,
gen_expr_unary,
gen_expr_binary,
gen_expr_ternary,
])(ctx)
def gen_stmt_decl(ctx):
t = gen_type()
e = gen_expr(ctx)
v = ctx.gen_var()
s = f'{t} {v} = {e};'
return s
def gen_stmt_assign(ctx):
# avoid assigning to loop counters
while True:
v = ctx.rand_var()
if v[0] != 'i':
break
e = gen_expr(ctx)
return f'{v} = {e};'
def gen_stmt_loop(ctx):
loop_ctx = ctx.copy()
t = gen_type_integer()
i = loop_ctx.gen_var(loop_counter = True)
end = randrange(1, 127)
return (
f'for({t} {i} = 0; {i} < {end}; ++{i}) {{\n'
f'{gen_block(loop_ctx)}'
f'}}'
)
def gen_stmt(ctx):
stmt = choice([
gen_stmt_decl,
gen_stmt_assign,
gen_stmt_loop,
])(ctx)
return f'{stmt}\n'
def gen_block(ctx):
block = ''
for i in range(georand(0.5)):
block = block + gen_stmt(ctx)
return block
def gen_func_args(ctx):
n = georand(0.2) + 1
args = [f'{gen_type()} {v}' for v in ctx.gen_vars(n)]
return ', '.join(args)
def gen_func(ctx):
return (
f'{gen_type()} test({gen_func_args(ctx)}) {{\n'
f'{gen_block(ctx)}'
f'return {ctx.rand_var()};\n'
f'}}'
)
def gen_global(ctx):
g = ctx.gen_var()
return f'{gen_type()} {g} = {gen_expr_literal()};'
def gen_globals(ctx):
globals = ''
for i in range(georand(1.0)):
g = gen_global(ctx)
globals = f'{globals}{g}\n'
return globals
def gen_unit(ctx):
# for now, one function with some parameter and access to some globals
unit = gen_globals(ctx)
unit = f'{unit}{gen_func(ctx)}\n'
return unit
def gen_test(filename):
with open(filename, 'w') as f:
ctx = Context()
print(gen_unit(ctx), file=f)
def test_file(filename, arch, abi):
asm_gcc = compile('gcc', arch, abi, filename)
c1 = get_cost(asm_gcc)
asm_clang = compile('clang', arch, abi, filename)
c2 = get_cost(asm_clang)
return c1, c2, asm_gcc, asm_clang
def read_file(fn):
with open(fn) as f:
return f.read()
def write_config(filename, arch, abi, cost1, cost2):
config = configparser.ConfigParser()
config.add_section('scenario')
config['scenario']['filename'] = filename
config['scenario']['arch'] = str(arch)
config['scenario']['abi'] = str(abi)
config['scenario']['cost1'] = str(cost1)
config['scenario']['cost2'] = str(cost2)
with open('scenario.ini', 'w') as f:
config.write(f)
return config
def write_result(f, config, asm1, asm2):
config.write(f)
filename = config['scenario']['filename']
print(f'### Source:\n{read_file(filename)}', file=f)
print(f'### GCC:\n{asm1}', file=f)
print(f'### Clang:\n{asm2}', file=f)
def run_test(filename, arch, abi):
asm1 = compile('gcc', arch, abi, filename)
c1 = get_cost(asm1)
asm2 = compile('clang', arch, abi, filename)
c2 = get_cost(asm2)
return c1, c2, asm1, asm2
def reduce_case(filename):
subprocess.check_output(['creduce', 'test.py', filename])
def main():
while True:
id = random_id()
source_file = f'case-{id}.c'
case_file = f'case-{id}.txt'
gen_test(source_file)
scenarios = [
['rv32gc', 'ilp32d'],
['rv64gc', 'lp64d'],
]
shuffle(scenarios) | passed = False
for arch, abi in scenarios:
c1, c2, asm1, asm2 = run_test(source_file, arch, abi)
print(c1, c2) | random_line_split |
|
longfruit.py | z': cost_branch,
'blt': cost_branch,
'bltu': cost_branch,
'bltz': cost_branch,
'bne': cost_branch,
'bnez': cost_branch,
'call': cost_call,
'div': cost_div,
'divu': cost_div,
'divuw': cost_div,
'divw': cost_div,
'ebreak': cost_ebreak,
'fadd.d': cost_fpu,
'fadd.s': cost_fpu,
'fcvt.d.l': cost_fpu,
'fcvt.d.lu': cost_fpu,
'fcvt.d.s': cost_fpu,
'fcvt.d.w': cost_fpu,
'fcvt.d.wu': cost_fpu,
'fcvt.l.d': cost_fpu,
'fcvt.l.s': cost_fpu,
'fcvt.lu.d': cost_fpu,
'fcvt.lu.s': cost_fpu,
'fcvt.s.d': cost_fpu,
'fcvt.s.l': cost_fpu,
'fcvt.s.lu': cost_fpu,
'fcvt.s.w': cost_fpu,
'fcvt.s.wu': cost_fpu,
'fcvt.w.d': cost_fpu,
'fcvt.w.s': cost_fpu,
'fcvt.wu.d': cost_fpu,
'fcvt.wu.s': cost_fpu,
'fdiv.d': cost_fpu,
'fdiv.s': cost_fpu,
'feq.d': cost_fpu,
'feq.s': cost_fpu,
'fge.d': cost_fpu,
'fge.s': cost_fpu,
'fgt.d': cost_fpu,
'fgt.s': cost_fpu,
'fld': cost_fpu_load_store,
'fle.d': cost_fpu,
'fle.s': cost_fpu,
'flt.d': cost_fpu,
'flt.s': cost_fpu,
'flw': cost_fpu_load_store,
'fmadd.d': cost_fpu,
'fmadd.s': cost_fpu,
'fmul.d': cost_fpu,
'fmul.s': cost_fpu,
'fmv.d': cost_fpu,
'fmv.d.x': cost_fpu,
'fmv.s': cost_fpu,
'fmv.s.x': cost_fpu,
'fmv.w.x': cost_fpu,
'fmv.x.s': cost_fpu,
'fneg.d': cost_fpu,
'fneg.s': cost_fpu,
#'fnmsub.s': cost_fpu, # not found yet
'fnmsub.d': cost_fpu,
'fsd': cost_fpu_load_store,
'fsub.d': cost_fpu,
'fsub.s': cost_fpu,
'fsw': cost_fpu_load_store,
'j': cost_branch,
'jr': cost_branch,
'lb': cost_load_store,
'lbu': cost_load_store,
'ld': cost_load_store,
'lh': cost_load_store,
'lhu': cost_load_store,
'lui': cost_alu,
'lw': cost_load_store,
'lwu': cost_load_store,
'mul': cost_mul,
'mulh': cost_mul,
'mulhu': cost_mul,
'mulw': cost_mul,
'mv': cost_alu,
'neg': cost_alu,
'negw': cost_alu,
'nop': cost_alu,
'not': cost_alu,
'or': cost_alu,
'ori': cost_alu,
'rem': cost_div,
'remu': cost_div,
'remuw': cost_div,
'remw': cost_div,
'ret': cost_ret,
'sb': cost_load_store,
'sd': cost_load_store,
'seqz': cost_alu,
'sext': cost_alu,
'sext.w': cost_alu,
'sgt': cost_alu,
'sgtu': cost_alu,
'sgtz': cost_alu,
'sh': cost_load_store,
'sll': cost_alu,
'slli': cost_alu,
'slliw': cost_alu,
'sllw': cost_alu,
'slt': cost_alu,
'slti': cost_alu,
'sltiu': cost_alu,
'sltu': cost_alu,
'snez': cost_alu,
'sra': cost_alu,
'srai': cost_alu,
'sraiw': cost_alu,
'sraw': cost_alu,
'srl': cost_alu,
'srli': cost_alu,
'srliw': cost_alu,
'srlw': cost_alu,
'sub': cost_alu,
'subw': cost_alu,
'sw': cost_load_store,
'xor': cost_alu,
'xori': cost_alu,
}[instr]
def compile(compiler, arch, abi, filename):
if compiler.endswith('gcc'):
prog = 'riscv64-unknown-linux-gnu-gcc'
opts = []
elif compiler.endswith('clang'):
prog = 'clang'
opts = [
'-Wno-literal-conversion',
'-Wno-implicit-int-float-conversion'
]
if arch == 'rv64gc':
opts.append('--target=riscv64')
elif arch == 'rv32gc':
opts.append('--target=riscv32')
else:
assert False, 'unsupported arch'
else:
assert False, 'unsupported compiler'
opts = opts + [
'-Werror=implicit-int',
'-Wno-tautological-compare',
'-Wno-overflow',
'-Wno-constant-conversion',
'-Wno-unsequenced',
f'-march={arch}',
f'-mabi={abi}',
'-O2', '-S', '-o', '-', filename
]
r = subprocess.check_output([prog] + opts).decode('utf-8')
return r
def get_cost(asm):
cost_total = 0
for line in filter_asm(asm):
cost = instr_cost(line)
cost_total = cost_total + cost
return cost_total
class Context:
def __init__(self):
self.var_counter = 0
self.vars = []
def gen_var(self, loop_counter = False):
if not loop_counter:
|
else:
v = f'i{self.var_counter}'
self.var_counter = self.var_counter + 1
self.vars.append(v)
return v
def gen_vars(self, num):
return [self.gen_var() for i in range(randint(1, num))]
def rand_var(self):
return choice(self.vars)
def copy(self):
ctx = Context()
ctx.var_counter = self.var_counter
ctx.vars = self.vars.copy()
return ctx
def gen_type():
return choice([
'char', 'short', 'int', 'long', 'long long',
'float', 'double'
])
def gen_type_integer():
signed = choice(['signed', 'unsigned'])
ty = choice(['char', 'short', 'int', 'long', 'long long'])
return f'{signed} {ty}'
def gen_cast_integer():
return f'({gen_type_integer()})'
def gen_expr_literal_int_zero():
return 0
def gen_expr_literal_int_12_bit():
return randrange(-2048, 2048)
def gen_expr_literal_int_20_bit_up():
return randrange(0, 2**20) << 12
def gen_expr_literal_int_32_bit():
return randrange(-2**31, 2**31)
def gen_expr_literal_int_64_bit():
return randrange(-2**63, 2**63)
def gen_expr_literal_float():
return uniform(-1_000_000, 1_000_000)
def gen_expr_literal(ctx = None):
v = choice([
gen_expr_literal_int_zero,
gen_expr_literal_int_12_bit,
gen_expr_literal_int_20_bit_up,
gen_expr_literal_int_32_bit,
gen_expr_literal_int_64_bit,
gen_expr_literal_float,
])()
return v
def gen_expr_var(ctx):
return ctx.rand_var()
def gen_expr_unary(ctx):
a = ctx.rand_var()
op = choice(['-', '~', '!', '++', '--'])
cast = ''
if op == '~':
# must be applied to an integer operand
cast = gen_cast_integer()
return f'{op}{cast}{a}'
def gen_expr_binary(ctx):
a = ctx.rand_var()
b = ctx.rand_var()
ops = [
'^', '&', '|', '<<', '>>',
'+', '-',
'*', '/', '%',
'==', '!=',
'<', '<=', '>', '>=',
'&&', | v = f'v{self.var_counter}' | conditional_block |
longfruit.py | cost_branch,
'lb': cost_load_store,
'lbu': cost_load_store,
'ld': cost_load_store,
'lh': cost_load_store,
'lhu': cost_load_store,
'lui': cost_alu,
'lw': cost_load_store,
'lwu': cost_load_store,
'mul': cost_mul,
'mulh': cost_mul,
'mulhu': cost_mul,
'mulw': cost_mul,
'mv': cost_alu,
'neg': cost_alu,
'negw': cost_alu,
'nop': cost_alu,
'not': cost_alu,
'or': cost_alu,
'ori': cost_alu,
'rem': cost_div,
'remu': cost_div,
'remuw': cost_div,
'remw': cost_div,
'ret': cost_ret,
'sb': cost_load_store,
'sd': cost_load_store,
'seqz': cost_alu,
'sext': cost_alu,
'sext.w': cost_alu,
'sgt': cost_alu,
'sgtu': cost_alu,
'sgtz': cost_alu,
'sh': cost_load_store,
'sll': cost_alu,
'slli': cost_alu,
'slliw': cost_alu,
'sllw': cost_alu,
'slt': cost_alu,
'slti': cost_alu,
'sltiu': cost_alu,
'sltu': cost_alu,
'snez': cost_alu,
'sra': cost_alu,
'srai': cost_alu,
'sraiw': cost_alu,
'sraw': cost_alu,
'srl': cost_alu,
'srli': cost_alu,
'srliw': cost_alu,
'srlw': cost_alu,
'sub': cost_alu,
'subw': cost_alu,
'sw': cost_load_store,
'xor': cost_alu,
'xori': cost_alu,
}[instr]
def compile(compiler, arch, abi, filename):
if compiler.endswith('gcc'):
prog = 'riscv64-unknown-linux-gnu-gcc'
opts = []
elif compiler.endswith('clang'):
prog = 'clang'
opts = [
'-Wno-literal-conversion',
'-Wno-implicit-int-float-conversion'
]
if arch == 'rv64gc':
opts.append('--target=riscv64')
elif arch == 'rv32gc':
opts.append('--target=riscv32')
else:
assert False, 'unsupported arch'
else:
assert False, 'unsupported compiler'
opts = opts + [
'-Werror=implicit-int',
'-Wno-tautological-compare',
'-Wno-overflow',
'-Wno-constant-conversion',
'-Wno-unsequenced',
f'-march={arch}',
f'-mabi={abi}',
'-O2', '-S', '-o', '-', filename
]
r = subprocess.check_output([prog] + opts).decode('utf-8')
return r
def get_cost(asm):
cost_total = 0
for line in filter_asm(asm):
cost = instr_cost(line)
cost_total = cost_total + cost
return cost_total
class Context:
def __init__(self):
self.var_counter = 0
self.vars = []
def gen_var(self, loop_counter = False):
if not loop_counter:
v = f'v{self.var_counter}'
else:
v = f'i{self.var_counter}'
self.var_counter = self.var_counter + 1
self.vars.append(v)
return v
def gen_vars(self, num):
return [self.gen_var() for i in range(randint(1, num))]
def rand_var(self):
return choice(self.vars)
def copy(self):
ctx = Context()
ctx.var_counter = self.var_counter
ctx.vars = self.vars.copy()
return ctx
def gen_type():
return choice([
'char', 'short', 'int', 'long', 'long long',
'float', 'double'
])
def gen_type_integer():
signed = choice(['signed', 'unsigned'])
ty = choice(['char', 'short', 'int', 'long', 'long long'])
return f'{signed} {ty}'
def gen_cast_integer():
return f'({gen_type_integer()})'
def gen_expr_literal_int_zero():
return 0
def gen_expr_literal_int_12_bit():
return randrange(-2048, 2048)
def gen_expr_literal_int_20_bit_up():
return randrange(0, 2**20) << 12
def gen_expr_literal_int_32_bit():
return randrange(-2**31, 2**31)
def gen_expr_literal_int_64_bit():
return randrange(-2**63, 2**63)
def gen_expr_literal_float():
return uniform(-1_000_000, 1_000_000)
def gen_expr_literal(ctx = None):
v = choice([
gen_expr_literal_int_zero,
gen_expr_literal_int_12_bit,
gen_expr_literal_int_20_bit_up,
gen_expr_literal_int_32_bit,
gen_expr_literal_int_64_bit,
gen_expr_literal_float,
])()
return v
def gen_expr_var(ctx):
return ctx.rand_var()
def gen_expr_unary(ctx):
a = ctx.rand_var()
op = choice(['-', '~', '!', '++', '--'])
cast = ''
if op == '~':
# must be applied to an integer operand
cast = gen_cast_integer()
return f'{op}{cast}{a}'
def gen_expr_binary(ctx):
a = ctx.rand_var()
b = ctx.rand_var()
ops = [
'^', '&', '|', '<<', '>>',
'+', '-',
'*', '/', '%',
'==', '!=',
'<', '<=', '>', '>=',
'&&', '||'
]
op = choice(ops)
cast1 = ''
cast2 = ''
if op in ['^', '&', '|', '%', '<<', '>>']:
# must be applied to integer operands
cast1 = gen_cast_integer()
cast2 = gen_cast_integer()
return f'{cast1}{a} {op} {cast2}{b}'
def gen_expr_ternary(ctx):
a = ctx.rand_var()
b = ctx.rand_var()
c = ctx.rand_var()
return f'{a} ? {b} : {c}'
def gen_expr(ctx):
return choice([
gen_expr_var,
gen_expr_literal,
gen_expr_unary,
gen_expr_binary,
gen_expr_ternary,
])(ctx)
def gen_stmt_decl(ctx):
t = gen_type()
e = gen_expr(ctx)
v = ctx.gen_var()
s = f'{t} {v} = {e};'
return s
def gen_stmt_assign(ctx):
# avoid assigning to loop counters
while True:
v = ctx.rand_var()
if v[0] != 'i':
break
e = gen_expr(ctx)
return f'{v} = {e};'
def gen_stmt_loop(ctx):
loop_ctx = ctx.copy()
t = gen_type_integer()
i = loop_ctx.gen_var(loop_counter = True)
end = randrange(1, 127)
return (
f'for({t} {i} = 0; {i} < {end}; ++{i}) {{\n'
f'{gen_block(loop_ctx)}'
f'}}'
)
def gen_stmt(ctx):
stmt = choice([
gen_stmt_decl,
gen_stmt_assign,
gen_stmt_loop,
])(ctx)
return f'{stmt}\n'
def gen_block(ctx):
block = ''
for i in range(georand(0.5)):
block = block + gen_stmt(ctx)
return block
def gen_func_args(ctx):
n = georand(0.2) + 1
args = [f'{gen_type()} {v}' for v in ctx.gen_vars(n)]
return ', '.join(args)
def gen_func(ctx):
return (
f'{gen_type()} test({gen_func_args(ctx)}) {{\n'
f'{gen_block(ctx)}'
f'return {ctx.rand_var()};\n'
f'}}'
)
def gen_global(ctx):
g = ctx.gen_var()
return f'{gen_type()} {g} = {gen_expr_literal()};'
def gen_globals(ctx):
globals = ''
for i in range(georand(1.0)):
g = gen_global(ctx)
globals = f'{globals}{g}\n'
return globals
def gen_unit(ctx):
# for now, one function with some parameter and access to some globals
| unit = gen_globals(ctx)
unit = f'{unit}{gen_func(ctx)}\n'
return unit | identifier_body |
|
longfruit.py | ': cost_alu,
'not': cost_alu,
'or': cost_alu,
'ori': cost_alu,
'rem': cost_div,
'remu': cost_div,
'remuw': cost_div,
'remw': cost_div,
'ret': cost_ret,
'sb': cost_load_store,
'sd': cost_load_store,
'seqz': cost_alu,
'sext': cost_alu,
'sext.w': cost_alu,
'sgt': cost_alu,
'sgtu': cost_alu,
'sgtz': cost_alu,
'sh': cost_load_store,
'sll': cost_alu,
'slli': cost_alu,
'slliw': cost_alu,
'sllw': cost_alu,
'slt': cost_alu,
'slti': cost_alu,
'sltiu': cost_alu,
'sltu': cost_alu,
'snez': cost_alu,
'sra': cost_alu,
'srai': cost_alu,
'sraiw': cost_alu,
'sraw': cost_alu,
'srl': cost_alu,
'srli': cost_alu,
'srliw': cost_alu,
'srlw': cost_alu,
'sub': cost_alu,
'subw': cost_alu,
'sw': cost_load_store,
'xor': cost_alu,
'xori': cost_alu,
}[instr]
def compile(compiler, arch, abi, filename):
if compiler.endswith('gcc'):
prog = 'riscv64-unknown-linux-gnu-gcc'
opts = []
elif compiler.endswith('clang'):
prog = 'clang'
opts = [
'-Wno-literal-conversion',
'-Wno-implicit-int-float-conversion'
]
if arch == 'rv64gc':
opts.append('--target=riscv64')
elif arch == 'rv32gc':
opts.append('--target=riscv32')
else:
assert False, 'unsupported arch'
else:
assert False, 'unsupported compiler'
opts = opts + [
'-Werror=implicit-int',
'-Wno-tautological-compare',
'-Wno-overflow',
'-Wno-constant-conversion',
'-Wno-unsequenced',
f'-march={arch}',
f'-mabi={abi}',
'-O2', '-S', '-o', '-', filename
]
r = subprocess.check_output([prog] + opts).decode('utf-8')
return r
def get_cost(asm):
cost_total = 0
for line in filter_asm(asm):
cost = instr_cost(line)
cost_total = cost_total + cost
return cost_total
class Context:
def __init__(self):
self.var_counter = 0
self.vars = []
def gen_var(self, loop_counter = False):
if not loop_counter:
v = f'v{self.var_counter}'
else:
v = f'i{self.var_counter}'
self.var_counter = self.var_counter + 1
self.vars.append(v)
return v
def gen_vars(self, num):
return [self.gen_var() for i in range(randint(1, num))]
def rand_var(self):
return choice(self.vars)
def copy(self):
ctx = Context()
ctx.var_counter = self.var_counter
ctx.vars = self.vars.copy()
return ctx
def gen_type():
return choice([
'char', 'short', 'int', 'long', 'long long',
'float', 'double'
])
def gen_type_integer():
signed = choice(['signed', 'unsigned'])
ty = choice(['char', 'short', 'int', 'long', 'long long'])
return f'{signed} {ty}'
def gen_cast_integer():
return f'({gen_type_integer()})'
def gen_expr_literal_int_zero():
return 0
def gen_expr_literal_int_12_bit():
return randrange(-2048, 2048)
def gen_expr_literal_int_20_bit_up():
return randrange(0, 2**20) << 12
def gen_expr_literal_int_32_bit():
return randrange(-2**31, 2**31)
def gen_expr_literal_int_64_bit():
return randrange(-2**63, 2**63)
def gen_expr_literal_float():
return uniform(-1_000_000, 1_000_000)
def gen_expr_literal(ctx = None):
v = choice([
gen_expr_literal_int_zero,
gen_expr_literal_int_12_bit,
gen_expr_literal_int_20_bit_up,
gen_expr_literal_int_32_bit,
gen_expr_literal_int_64_bit,
gen_expr_literal_float,
])()
return v
def gen_expr_var(ctx):
return ctx.rand_var()
def gen_expr_unary(ctx):
a = ctx.rand_var()
op = choice(['-', '~', '!', '++', '--'])
cast = ''
if op == '~':
# must be applied to an integer operand
cast = gen_cast_integer()
return f'{op}{cast}{a}'
def gen_expr_binary(ctx):
a = ctx.rand_var()
b = ctx.rand_var()
ops = [
'^', '&', '|', '<<', '>>',
'+', '-',
'*', '/', '%',
'==', '!=',
'<', '<=', '>', '>=',
'&&', '||'
]
op = choice(ops)
cast1 = ''
cast2 = ''
if op in ['^', '&', '|', '%', '<<', '>>']:
# must be applied to integer operands
cast1 = gen_cast_integer()
cast2 = gen_cast_integer()
return f'{cast1}{a} {op} {cast2}{b}'
def gen_expr_ternary(ctx):
a = ctx.rand_var()
b = ctx.rand_var()
c = ctx.rand_var()
return f'{a} ? {b} : {c}'
def gen_expr(ctx):
return choice([
gen_expr_var,
gen_expr_literal,
gen_expr_unary,
gen_expr_binary,
gen_expr_ternary,
])(ctx)
def gen_stmt_decl(ctx):
t = gen_type()
e = gen_expr(ctx)
v = ctx.gen_var()
s = f'{t} {v} = {e};'
return s
def gen_stmt_assign(ctx):
# avoid assigning to loop counters
while True:
v = ctx.rand_var()
if v[0] != 'i':
break
e = gen_expr(ctx)
return f'{v} = {e};'
def gen_stmt_loop(ctx):
loop_ctx = ctx.copy()
t = gen_type_integer()
i = loop_ctx.gen_var(loop_counter = True)
end = randrange(1, 127)
return (
f'for({t} {i} = 0; {i} < {end}; ++{i}) {{\n'
f'{gen_block(loop_ctx)}'
f'}}'
)
def gen_stmt(ctx):
stmt = choice([
gen_stmt_decl,
gen_stmt_assign,
gen_stmt_loop,
])(ctx)
return f'{stmt}\n'
def gen_block(ctx):
block = ''
for i in range(georand(0.5)):
block = block + gen_stmt(ctx)
return block
def gen_func_args(ctx):
n = georand(0.2) + 1
args = [f'{gen_type()} {v}' for v in ctx.gen_vars(n)]
return ', '.join(args)
def gen_func(ctx):
return (
f'{gen_type()} test({gen_func_args(ctx)}) {{\n'
f'{gen_block(ctx)}'
f'return {ctx.rand_var()};\n'
f'}}'
)
def gen_global(ctx):
g = ctx.gen_var()
return f'{gen_type()} {g} = {gen_expr_literal()};'
def gen_globals(ctx):
globals = ''
for i in range(georand(1.0)):
g = gen_global(ctx)
globals = f'{globals}{g}\n'
return globals
def gen_unit(ctx):
# for now, one function with some parameter and access to some globals
unit = gen_globals(ctx)
unit = f'{unit}{gen_func(ctx)}\n'
return unit
def gen_test(filename):
with open(filename, 'w') as f:
ctx = Context()
print(gen_unit(ctx), file=f)
def test_file(filename, arch, abi):
asm_gcc = compile('gcc', arch, abi, filename)
c1 = get_cost(asm_gcc)
asm_clang = compile('clang', arch, abi, filename)
c2 = get_cost(asm_clang)
return c1, c2, asm_gcc, asm_clang
def read_file(fn):
with open(fn) as f:
return f.read()
def | write_config | identifier_name |
|
main.rs | in sync.items {
tasks.push(item.into());
}
Self {
tasks,
}
}
}
#[derive(Debug)]
struct Task {
item: Item,
}
impl From<Item> for Task {
fn from(item: Item) -> Self {
Self { item }
}
}
#[derive(Debug, Deserialize)]
struct Sync {
/// A new synchronization token.
sync_token: String,
/// If this contains all data.
full_sync: bool,
/// A [`UserData`].
user: UserData,
/// An array of [`Project`]s.
projects: Vec<Project>,
/// An array of [`Item`]s.
items: Vec<Item>,
/// An array of [`Note`]s.
notes: Vec<Note>,
/// An array of [`ProjectNote`]s.
project_notes: Vec<ProjectNote>,
/// An array of [`Section`]s.
sections: Vec<Section>,
/// An array of [`Label`]s.
labels: Vec<Label>,
/// An array of [`Filter`]s.
filters: Vec<Filter>,
/// Maps items to their order in the daily agenda.
day_orders: BTreeMap<ItemId, Order>,
/// An array of [`Reminder`]s.
reminders: Vec<Reminder>,
/// The collaborators for all shared projects.
collaborators: Vec<Collaborator>,
/// An array of [`CollaboratorState`]s.
#[serde(default)]
collaborators_states: Vec<CollaboratorState>,
/// An array of [`LiveNotification`]s.
live_notifications: Vec<LiveNotification>,
/// The id of the last [`LiveNotification`] seen by the user.
live_notifications_last_read_id: LiveNotificationId,
/// The [`UserSettings`].
user_settings: UserSettings,
}
#[derive(Debug, Deserialize)]
struct Order(i64);
#[derive(Debug, Deserialize)]
/// A Todoist user.
struct UserData {
/// The default number of minutes for set automatic reminders.
auto_reminder: u64,
/// Link to a 195x195 image of the user's avatar.
avatar_big: String,
/// Link to a 60x60 image of the user's avatar.
avatar_medium: String,
/// Link to a 640x640 image of the user's avatar.
avatar_s640: String,
/// Link to a 35x35 image of the user's avatar.
avatar_small: String,
/// The user's [`BusinessAccountId`].
#[serde(default)]
business_account_id: Option<BusinessAccountId>,
/// The number of tasks set as the user's daily goal.
daily_goal: u64,
/// The user's desired date format.
date_format: DateFormat,
/// If smart date recognition has been disabled.
dateist_inline_disabled: bool,
/// The language expected for the date recognition.
dateist_lang: Option<Language>,
/// The days that the user is off.
days_off: Vec<Day>,
/// The default reminder for the user.
default_reminder: Reminder,
/// The user's email.
email: String,
/// Special internal features that apply to the user.
features: Features,
full_name: String,
id: UserId,
#[serde(default)]
image_id: Option<String>,
inbox_project: ProjectId,
is_biz_admin: bool,
is_premium: bool,
join_date: String,
karma: f64,
karma_trend: KarmaTrend,
lang: Language,
mobile_host: Option<String>,
mobile_number: Option<String>,
next_week: Day,
premium_until: Option<String>,
sort_order: SortOrder,
start_day: Day,
start_page: Page,
#[serde(default)]
team_inbox: Option<ProjectId>,
theme: Theme,
time_format: TimeFormat,
token: String,
tz_info: TimezoneInfo,
weekly_goal: u64,
}
#[derive(Debug, Deserialize)]
struct UserId(u64);
#[derive(Debug, Deserialize)]
struct BusinessAccountId(u64);
#[derive(Debug, Deserialize)]
struct Project {
id: ProjectId,
name: String,
color: Color,
parent_id: Option<ProjectId>,
child_order: Order,
collapsed: Flag,
shared: bool,
is_deleted: Flag,
is_archived: Flag,
is_favorite: Flag,
sync_id: Option<ProjectSyncId>,
#[serde(default)]
inbox_project: bool,
#[serde(default)]
team_inbox: bool,
}
#[derive(Debug, Deserialize)]
struct ProjectId(u64);
#[derive(Debug, Deserialize)]
struct ProjectSyncId(u64);
#[derive(Debug, Deserialize)]
struct Item {
id: ItemId,
user_id: UserId,
project_id: ProjectId,
content: String,
due: Option<Date>,
priority: Priority,
parent_id: Option<ItemId>,
child_order: Order,
section_id: Option<SectionId>,
day_order: Order,
collapsed: Flag,
labels: Vec<LabelId>,
added_by_uid: Option<UserId>,
assigned_by_uid: Option<UserId>,
responsible_uid: Option<UserId>,
checked: Flag,
in_history: Flag,
is_deleted: Flag,
sync_id: Option<ItemSyncId>,
date_completed: Option<String>,
date_added: String,
}
#[derive(Debug, Deserialize)]
struct ItemSyncId(u64);
#[derive(Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd)]
struct ItemId(u64);
#[derive(Debug, Deserialize)]
struct Note {
id: NoteId,
posted_uid: UserId,
item_id: ItemId,
project_id: ProjectId,
content: String,
file_attachment: FileAttachment,
uids_to_notify: Vec<UserId>,
is_deleted: Flag,
posted: String,
reactions: BTreeMap<String, Vec<UserId>>,
}
#[derive(Debug, Deserialize)]
struct NoteId(u64);
#[derive(Debug, Deserialize)]
struct ProjectNote {
id: ProjectNoteId,
posted_uid: UserId,
project_id: ProjectId,
content: String,
file_attachment: FileAttachment,
uids_to_notify: Vec<UserId>,
is_deleted: Flag,
posted: String,
reactions: BTreeMap<String, Vec<UserId>>,
}
#[derive(Debug, Deserialize)]
struct ProjectNoteId(u64);
#[derive(Debug, Deserialize)]
struct Section {
id: SectionId,
name: String,
project_id: ProjectId,
section_order: Order,
collapsed: bool,
sync_id: Option<SectionSyncId>,
is_deleted: bool,
is_archived: bool,
date_archived: Option<String>,
date_added: String,
}
#[derive(Debug, Deserialize)]
struct SectionId(u64);
#[derive(Debug, Deserialize)]
struct SectionSyncId(u64);
#[derive(Debug, Deserialize)]
struct Label {
id: LabelId,
name: String,
color: Color,
item_order: Order,
is_deleted: Flag,
is_favorite: Flag,
}
#[derive(Debug, Deserialize)]
struct | (u64);
#[derive(Debug, Deserialize)]
struct Filter {
id: FilterId,
name: String,
query: String,
color: Color,
item_order: Order,
is_deleted: Flag,
is_favorite: Flag,
}
#[derive(Debug, Deserialize)]
struct FilterId(u64);
#[derive(Debug, Deserialize)]
struct Collaborator {
id: CollaboratorId,
email: String,
full_name: String,
timezone: String,
#[serde(default)]
image_id: Option<String>,
}
#[derive(Debug, Deserialize)]
struct CollaboratorId(u64);
#[derive(Debug, Deserialize)]
struct CollaboratorState {
project_id: ProjectId,
user_id: UserId,
state: CollaboratorStatus,
is_deleted: bool,
}
#[derive(Debug, Deserialize)]
// Note: v8 api says there should be a `seq_no` field that holds an integer.
struct LiveNotification {
id: LiveNotificationId,
// Note: v8 api says that created should be an integer that is the epoch timestamp.
created: String,
// Note: v8 api does not say from_uid is optional.
#[serde(default)]
from_uid: Option<UserId>,
notification_key: String,
notification_type: String,
is_unread: Flag,
}
#[derive(Debug, Deserialize)]
struct LiveNotificationId(u64);
#[derive(Debug, Deserialize)]
struct UserSettings {
reminder_push: bool,
#[serde(default)]
reminder_sms: bool,
reminder_desktop: bool,
reminder_email: bool,
}
#[derive(Debug, Deserialize_repr)]
#[repr(u8)]
enum Color {
Crimson = 30,
Red = 31,
Orange = 32,
Yellow = 33,
Olive = 34,
LightGreen = 35,
DarkGreen = 36,
SeaGreen = 37,
SteelBlue = 38,
SkyBlue = 39,
BabyBlue = 40,
Blue = 41,
RoyalPurple = 42,
Violet = 43,
Pink = 44,
Mulberry = 45,
Salmon = 46,
Gray = 47,
LightGray = 48,
Tan = 49,
}
#[derive(Debug, Deserialize)]
enum CollaboratorStatus {
| LabelId | identifier_name |
main.rs | std::{collections::BTreeMap, io::Read, fs::File, process::Command},
};
fn main() -> Result<(), Failure> {
let mut file = File::open("token")?;
let mut token = String::new();
file.read_to_string(&mut token)?;
token.insert_str(0, "token=");
let output = &Command::new("curl").args(&["https://api.todoist.com/sync/v8/sync", "-d", &token, "-d", "sync_token=*", "-d", "resource_types=[\"all\"]"]).output()?.stdout;
let sync: Sync = serde_json::from_slice(&output)?;
let user = User::from(sync);
for task in user.tasks {
println!("- {:?}", task);
}
Ok(())
}
#[derive(Debug)]
enum Failure {
Io(std::io::Error),
Serde(serde_json::Error),
Utf8(std::str::Utf8Error),
}
impl From<std::io::Error> for Failure {
fn from(error: std::io::Error) -> Self {
Self::Io(error)
}
}
impl From<serde_json::Error> for Failure {
fn from(error: serde_json::Error) -> Self {
Self::Serde(error)
}
}
impl From<std::str::Utf8Error> for Failure {
fn from(error: std::str::Utf8Error) -> Self {
Self::Utf8(error)
}
}
struct User {
tasks: Vec<Task>,
}
impl From<Sync> for User {
fn from(sync: Sync) -> Self {
let mut tasks = Vec::new();
for item in sync.items {
tasks.push(item.into());
}
Self {
tasks,
}
}
}
#[derive(Debug)]
struct Task {
item: Item,
}
impl From<Item> for Task {
fn from(item: Item) -> Self {
Self { item }
}
}
#[derive(Debug, Deserialize)]
struct Sync {
/// A new synchronization token.
sync_token: String,
/// If this contains all data.
full_sync: bool,
/// A [`UserData`].
user: UserData,
/// An array of [`Project`]s.
projects: Vec<Project>,
/// An array of [`Item`]s.
items: Vec<Item>,
/// An array of [`Note`]s.
notes: Vec<Note>,
/// An array of [`ProjectNote`]s.
project_notes: Vec<ProjectNote>,
/// An array of [`Section`]s.
sections: Vec<Section>,
/// An array of [`Label`]s.
labels: Vec<Label>,
/// An array of [`Filter`]s.
filters: Vec<Filter>,
/// Maps items to their order in the daily agenda.
day_orders: BTreeMap<ItemId, Order>,
/// An array of [`Reminder`]s.
reminders: Vec<Reminder>,
/// The collaborators for all shared projects.
collaborators: Vec<Collaborator>,
/// An array of [`CollaboratorState`]s.
#[serde(default)]
collaborators_states: Vec<CollaboratorState>,
/// An array of [`LiveNotification`]s.
live_notifications: Vec<LiveNotification>,
/// The id of the last [`LiveNotification`] seen by the user.
live_notifications_last_read_id: LiveNotificationId,
/// The [`UserSettings`].
user_settings: UserSettings,
}
#[derive(Debug, Deserialize)]
struct Order(i64);
#[derive(Debug, Deserialize)]
/// A Todoist user.
struct UserData {
/// The default number of minutes for set automatic reminders.
auto_reminder: u64,
/// Link to a 195x195 image of the user's avatar.
avatar_big: String,
/// Link to a 60x60 image of the user's avatar.
avatar_medium: String,
/// Link to a 640x640 image of the user's avatar.
avatar_s640: String,
/// Link to a 35x35 image of the user's avatar.
avatar_small: String,
/// The user's [`BusinessAccountId`].
#[serde(default)]
business_account_id: Option<BusinessAccountId>,
/// The number of tasks set as the user's daily goal.
daily_goal: u64,
/// The user's desired date format.
date_format: DateFormat,
/// If smart date recognition has been disabled.
dateist_inline_disabled: bool,
/// The language expected for the date recognition.
dateist_lang: Option<Language>,
/// The days that the user is off.
days_off: Vec<Day>,
/// The default reminder for the user.
default_reminder: Reminder,
/// The user's email.
email: String,
/// Special internal features that apply to the user.
features: Features,
full_name: String,
id: UserId,
#[serde(default)]
image_id: Option<String>,
inbox_project: ProjectId,
is_biz_admin: bool,
is_premium: bool,
join_date: String,
karma: f64,
karma_trend: KarmaTrend,
lang: Language,
mobile_host: Option<String>,
mobile_number: Option<String>,
next_week: Day,
premium_until: Option<String>,
sort_order: SortOrder,
start_day: Day,
start_page: Page,
#[serde(default)]
team_inbox: Option<ProjectId>,
theme: Theme,
time_format: TimeFormat,
token: String,
tz_info: TimezoneInfo,
weekly_goal: u64,
}
#[derive(Debug, Deserialize)]
struct UserId(u64);
#[derive(Debug, Deserialize)]
struct BusinessAccountId(u64);
#[derive(Debug, Deserialize)]
struct Project {
id: ProjectId,
name: String,
color: Color,
parent_id: Option<ProjectId>,
child_order: Order,
collapsed: Flag,
shared: bool,
is_deleted: Flag,
is_archived: Flag,
is_favorite: Flag,
sync_id: Option<ProjectSyncId>,
#[serde(default)]
inbox_project: bool,
#[serde(default)]
team_inbox: bool,
}
#[derive(Debug, Deserialize)]
struct ProjectId(u64);
#[derive(Debug, Deserialize)]
struct ProjectSyncId(u64);
#[derive(Debug, Deserialize)]
struct Item {
id: ItemId,
user_id: UserId,
project_id: ProjectId,
content: String,
due: Option<Date>,
priority: Priority,
parent_id: Option<ItemId>,
child_order: Order,
section_id: Option<SectionId>,
day_order: Order,
collapsed: Flag,
labels: Vec<LabelId>,
added_by_uid: Option<UserId>,
assigned_by_uid: Option<UserId>,
responsible_uid: Option<UserId>,
checked: Flag,
in_history: Flag,
is_deleted: Flag,
sync_id: Option<ItemSyncId>,
date_completed: Option<String>,
date_added: String,
}
#[derive(Debug, Deserialize)]
struct ItemSyncId(u64);
#[derive(Clone, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd)]
struct ItemId(u64);
#[derive(Debug, Deserialize)]
struct Note {
id: NoteId,
posted_uid: UserId,
item_id: ItemId,
project_id: ProjectId,
content: String,
file_attachment: FileAttachment,
uids_to_notify: Vec<UserId>,
is_deleted: Flag,
posted: String,
reactions: BTreeMap<String, Vec<UserId>>,
}
#[derive(Debug, Deserialize)]
struct NoteId(u64);
#[derive(Debug, Deserialize)]
struct ProjectNote {
id: ProjectNoteId,
posted_uid: UserId,
project_id: ProjectId,
content: String,
file_attachment: FileAttachment,
uids_to_notify: Vec<UserId>,
is_deleted: Flag,
posted: String,
reactions: BTreeMap<String, Vec<UserId>>,
}
#[derive(Debug, Deserialize)]
struct ProjectNoteId(u64);
#[derive(Debug, Deserialize)]
struct Section {
id: SectionId,
name: String,
project_id: ProjectId,
section_order: Order,
collapsed: bool,
sync_id: Option<SectionSyncId>,
is_deleted: bool,
is_archived: bool,
date_archived: Option<String>,
date_added: String,
}
#[derive(Debug, Deserialize)]
struct SectionId(u64);
#[derive(Debug, Deserialize)]
struct SectionSyncId(u64);
#[derive(Debug, Deserialize)]
struct Label {
id: LabelId,
name: String,
color: Color,
item_order: Order,
is_deleted: Flag,
is_favorite: Flag,
}
#[derive(Debug, Deserialize)]
struct LabelId(u64);
#[derive(Debug, Deserialize)]
struct Filter {
id: FilterId,
name: String,
query: String,
color: Color,
item_order: Order,
is_deleted: Flag,
is_favorite: Flag,
}
#[derive(Debug, Deserialize)]
struct FilterId(u64);
#[derive(Debug, Deserialize)]
struct Collaborator {
id: CollaboratorId,
email: String,
full_name: String,
timezone: String,
#[serde(default)]
image_id: Option<String>,
}
#[derive(Debug, Deserialize)]
struct CollaboratorId(u64);
#[derive(Debug, Deserialize)]
struct CollaboratorState {
project | serde::Deserialize,
serde_json,
serde_repr::Deserialize_repr, | random_line_split |
|
secrets.go | DeleteReplicatedResource: repl.DeleteReplicatedResource,
}
return &repl
}
// ReplicateDataFrom takes a source object and copies over data to target object
func (r *Replicator) ReplicateDataFrom(sourceObj interface{}, targetObj interface{}) error {
source := sourceObj.(*v1.Secret)
target := targetObj.(*v1.Secret)
// make sure replication is allowed
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", common.MustGetKey(target))
if ok, err := r.IsReplicationPermitted(&target.ObjectMeta, &source.ObjectMeta); !ok {
return errors.Wrapf(err, "replication of target %s is not permitted", common.MustGetKey(source))
}
targetVersion, ok := target.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("target %s is already up-to-date", common.MustGetKey(target))
return nil
}
targetCopy := target.DeepCopy()
if targetCopy.Data == nil {
targetCopy.Data = make(map[string][]byte)
}
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&targetCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value)
targetCopy.Data[key] = newValue
replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source any more", k)
delete(targetCopy.Data, k)
}
}
sort.Strings(replicatedKeys)
logger.Infof("updating target %s", common.MustGetKey(target))
targetCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
targetCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
targetCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
s, err := r.Client.CoreV1().Secrets(target.Namespace).Update(context.TODO(), targetCopy, metav1.UpdateOptions{})
if err != nil {
err = errors.Wrapf(err, "Failed updating target %s/%s", target.Namespace, targetCopy.Name)
} else if err = r.Store.Update(s); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s: %v", target.Namespace, targetCopy, err)
}
return err
}
// ReplicateObjectTo copies the whole object to target namespace
func (r *Replicator) ReplicateObjectTo(sourceObj interface{}, target *v1.Namespace) error {
source := sourceObj.(*v1.Secret)
targetLocation := fmt.Sprintf("%s/%s", target.Name, source.Name)
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
targetResourceType := source.Type
targetResource, exists, err := r.Store.GetByKey(targetLocation)
if err != nil {
return errors.Wrapf(err, "Could not get %s from cache!", targetLocation)
}
logger.Infof("Checking if %s exists? %v", targetLocation, exists)
var resourceCopy *v1.Secret
if exists {
targetObject := targetResource.(*v1.Secret)
targetVersion, ok := targetObject.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("Secret %s is already up-to-date", common.MustGetKey(targetObject))
return nil
}
targetResourceType = targetObject.Type
resourceCopy = targetObject.DeepCopy()
} else {
resourceCopy = new(v1.Secret)
}
keepOwnerReferences, ok := source.Annotations[common.KeepOwnerReferences]
if ok && keepOwnerReferences == "true" {
resourceCopy.OwnerReferences = source.OwnerReferences
}
if resourceCopy.Data == nil {
resourceCopy.Data = make(map[string][]byte)
}
if resourceCopy.Annotations == nil {
resourceCopy.Annotations = make(map[string]string)
}
replicatedKeys := r.extractReplicatedKeys(source, targetLocation, resourceCopy)
sort.Strings(replicatedKeys)
labelsCopy := make(map[string]string)
stripLabels, ok := source.Annotations[common.StripLabels]
if !ok && stripLabels != "true" {
if source.Labels != nil {
for key, value := range source.Labels {
labelsCopy[key] = value
}
}
}
resourceCopy.Name = source.Name
resourceCopy.Labels = labelsCopy
resourceCopy.Type = targetResourceType
resourceCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
resourceCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
resourceCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
var obj interface{}
if exists {
logger.Debugf("Updating existing secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Update(context.TODO(), resourceCopy, metav1.UpdateOptions{})
} else {
logger.Debugf("Creating a new secret secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Create(context.TODO(), resourceCopy, metav1.CreateOptions{})
}
if err != nil {
err = errors.Wrapf(err, "Failed to update secret %s/%s", target.Name, resourceCopy.Name)
} else if err = r.Store.Update(obj); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s", target.Name, resourceCopy)
}
return err
}
func (r *Replicator) extractReplicatedKeys(source *v1.Secret, targetLocation string, resourceCopy *v1.Secret) []string {
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&resourceCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value)
resourceCopy.Data[key] = newValue
replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source secret any more", k)
delete(resourceCopy.Data, k)
}
}
return replicatedKeys
}
func (r *Replicator) PatchDeleteDependent(sourceKey string, target interface{}) (interface{}, error) {
dependentKey := common.MustGetKey(target)
logger := log.WithFields(log.Fields{
"kind": r.Kind,
"source": sourceKey,
"target": dependentKey,
})
targetObject, ok := target.(*v1.Secret)
if !ok {
err := errors.Errorf("bad type returned from Store: %T", target)
return nil, err
}
patch := []common.JSONPatchOperation{{Operation: "remove", Path: "/data"}}
patchBody, err := json.Marshal(&patch)
if err != nil {
return nil, errors.Wrapf(err, "error while building patch body for secret %s: %v", dependentKey, err)
}
logger.Debugf("clearing dependent %s %s", r.Kind, dependentKey)
logger.Tracef("patch body: %s", string(patchBody))
s, err := r.Client.CoreV1().Secrets(targetObject.Namespace).Patch(context.TODO(), targetObject.Name, types.JSONPatchType, patchBody, metav1.PatchOptions{})
if err != nil {
return nil, errors.Wrapf(err, "error while patching secret %s: %v", dependentKey, err)
}
return s, nil
}
// DeleteReplicatedResource deletes a resource replicated by ReplicateTo annotation
func (r *Replicator) DeleteReplicatedResource(targetResource interface{}) error {
targetLocation := common.MustGetKey(targetResource)
logger := log.WithFields(log.Fields{
"kind": | {
repl := Replicator{
GenericReplicator: common.NewGenericReplicator(common.ReplicatorConfig{
Kind: "Secret",
ObjType: &v1.Secret{},
AllowAll: allowAll,
ResyncPeriod: resyncPeriod,
Client: client,
ListFunc: func(lo metav1.ListOptions) (runtime.Object, error) {
return client.CoreV1().Secrets("").List(context.TODO(), lo)
},
WatchFunc: func(lo metav1.ListOptions) (watch.Interface, error) {
return client.CoreV1().Secrets("").Watch(context.TODO(), lo)
},
}),
}
repl.UpdateFuncs = common.UpdateFuncs{
ReplicateDataFrom: repl.ReplicateDataFrom,
ReplicateObjectTo: repl.ReplicateObjectTo,
PatchDeleteDependent: repl.PatchDeleteDependent, | identifier_body |
|
secrets.go | := Replicator{
GenericReplicator: common.NewGenericReplicator(common.ReplicatorConfig{
Kind: "Secret",
ObjType: &v1.Secret{},
AllowAll: allowAll,
ResyncPeriod: resyncPeriod,
Client: client,
ListFunc: func(lo metav1.ListOptions) (runtime.Object, error) {
return client.CoreV1().Secrets("").List(context.TODO(), lo)
},
WatchFunc: func(lo metav1.ListOptions) (watch.Interface, error) {
return client.CoreV1().Secrets("").Watch(context.TODO(), lo)
},
}),
}
repl.UpdateFuncs = common.UpdateFuncs{
ReplicateDataFrom: repl.ReplicateDataFrom,
ReplicateObjectTo: repl.ReplicateObjectTo,
PatchDeleteDependent: repl.PatchDeleteDependent,
DeleteReplicatedResource: repl.DeleteReplicatedResource,
}
return &repl
}
// ReplicateDataFrom takes a source object and copies over data to target object
func (r *Replicator) ReplicateDataFrom(sourceObj interface{}, targetObj interface{}) error {
source := sourceObj.(*v1.Secret)
target := targetObj.(*v1.Secret)
// make sure replication is allowed
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", common.MustGetKey(target))
if ok, err := r.IsReplicationPermitted(&target.ObjectMeta, &source.ObjectMeta); !ok {
return errors.Wrapf(err, "replication of target %s is not permitted", common.MustGetKey(source))
}
targetVersion, ok := target.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("target %s is already up-to-date", common.MustGetKey(target))
return nil
}
targetCopy := target.DeepCopy()
if targetCopy.Data == nil {
targetCopy.Data = make(map[string][]byte)
}
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&targetCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value)
targetCopy.Data[key] = newValue
replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source any more", k)
delete(targetCopy.Data, k)
}
}
sort.Strings(replicatedKeys)
logger.Infof("updating target %s", common.MustGetKey(target))
targetCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
targetCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
targetCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
s, err := r.Client.CoreV1().Secrets(target.Namespace).Update(context.TODO(), targetCopy, metav1.UpdateOptions{})
if err != nil {
err = errors.Wrapf(err, "Failed updating target %s/%s", target.Namespace, targetCopy.Name)
} else if err = r.Store.Update(s); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s: %v", target.Namespace, targetCopy, err)
}
return err
}
// ReplicateObjectTo copies the whole object to target namespace
func (r *Replicator) ReplicateObjectTo(sourceObj interface{}, target *v1.Namespace) error {
source := sourceObj.(*v1.Secret)
targetLocation := fmt.Sprintf("%s/%s", target.Name, source.Name)
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
targetResourceType := source.Type
targetResource, exists, err := r.Store.GetByKey(targetLocation)
if err != nil {
return errors.Wrapf(err, "Could not get %s from cache!", targetLocation)
}
logger.Infof("Checking if %s exists? %v", targetLocation, exists)
var resourceCopy *v1.Secret
if exists {
targetObject := targetResource.(*v1.Secret)
targetVersion, ok := targetObject.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("Secret %s is already up-to-date", common.MustGetKey(targetObject))
return nil
}
targetResourceType = targetObject.Type
resourceCopy = targetObject.DeepCopy()
} else {
resourceCopy = new(v1.Secret)
}
keepOwnerReferences, ok := source.Annotations[common.KeepOwnerReferences]
if ok && keepOwnerReferences == "true" {
resourceCopy.OwnerReferences = source.OwnerReferences
}
if resourceCopy.Data == nil {
resourceCopy.Data = make(map[string][]byte)
}
if resourceCopy.Annotations == nil {
resourceCopy.Annotations = make(map[string]string)
}
replicatedKeys := r.extractReplicatedKeys(source, targetLocation, resourceCopy)
sort.Strings(replicatedKeys)
labelsCopy := make(map[string]string)
stripLabels, ok := source.Annotations[common.StripLabels]
if !ok && stripLabels != "true" {
if source.Labels != nil {
for key, value := range source.Labels {
labelsCopy[key] = value
}
}
}
resourceCopy.Name = source.Name
resourceCopy.Labels = labelsCopy
resourceCopy.Type = targetResourceType
resourceCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
resourceCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
resourceCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
var obj interface{}
if exists {
logger.Debugf("Updating existing secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Update(context.TODO(), resourceCopy, metav1.UpdateOptions{})
} else {
logger.Debugf("Creating a new secret secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Create(context.TODO(), resourceCopy, metav1.CreateOptions{})
}
if err != nil {
err = errors.Wrapf(err, "Failed to update secret %s/%s", target.Name, resourceCopy.Name)
} else if err = r.Store.Update(obj); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s", target.Name, resourceCopy)
}
return err
}
func (r *Replicator) extractReplicatedKeys(source *v1.Secret, targetLocation string, resourceCopy *v1.Secret) []string {
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&resourceCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value) | replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source secret any more", k)
delete(resourceCopy.Data, k)
}
}
return replicatedKeys
}
func (r *Replicator) PatchDeleteDependent(sourceKey string, target interface{}) (interface{}, error) {
dependentKey := common.MustGetKey(target)
logger := log.WithFields(log.Fields{
"kind": r.Kind,
"source": sourceKey,
"target": dependentKey,
})
targetObject, ok := target.(*v1.Secret)
if !ok {
err := errors.Errorf("bad type returned from Store: %T", target)
return nil, err
}
patch := []common.JSONPatchOperation{{Operation: "remove", Path: "/data"}}
patchBody, err := json.Marshal(&patch)
if err != nil {
return nil, errors.Wrapf(err, "error while building patch body for secret %s: %v", dependentKey, err)
}
logger.Debugf("clearing dependent %s %s", r.Kind, dependentKey)
logger.Tracef("patch body: %s", string(patchBody))
s, err := r.Client.CoreV1().Secrets(targetObject.Namespace).Patch(context.TODO(), targetObject.Name, types.JSONPatchType, patchBody, metav1.PatchOptions{})
if err != nil {
return nil, errors.Wrapf(err, "error while patching secret %s: %v", dependentKey, err)
}
return s, nil
}
// DeleteReplicatedResource deletes a resource replicated by ReplicateTo annotation
func (r *Replicator) DeleteReplicatedResource(targetResource interface{}) error {
targetLocation := common.MustGetKey(targetResource)
logger := log.WithFields(log.Fields{
"kind": r.Kind | resourceCopy.Data[key] = newValue
| random_line_split |
secrets.go | := Replicator{
GenericReplicator: common.NewGenericReplicator(common.ReplicatorConfig{
Kind: "Secret",
ObjType: &v1.Secret{},
AllowAll: allowAll,
ResyncPeriod: resyncPeriod,
Client: client,
ListFunc: func(lo metav1.ListOptions) (runtime.Object, error) {
return client.CoreV1().Secrets("").List(context.TODO(), lo)
},
WatchFunc: func(lo metav1.ListOptions) (watch.Interface, error) {
return client.CoreV1().Secrets("").Watch(context.TODO(), lo)
},
}),
}
repl.UpdateFuncs = common.UpdateFuncs{
ReplicateDataFrom: repl.ReplicateDataFrom,
ReplicateObjectTo: repl.ReplicateObjectTo,
PatchDeleteDependent: repl.PatchDeleteDependent,
DeleteReplicatedResource: repl.DeleteReplicatedResource,
}
return &repl
}
// ReplicateDataFrom takes a source object and copies over data to target object
func (r *Replicator) ReplicateDataFrom(sourceObj interface{}, targetObj interface{}) error {
source := sourceObj.(*v1.Secret)
target := targetObj.(*v1.Secret)
// make sure replication is allowed
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", common.MustGetKey(target))
if ok, err := r.IsReplicationPermitted(&target.ObjectMeta, &source.ObjectMeta); !ok {
return errors.Wrapf(err, "replication of target %s is not permitted", common.MustGetKey(source))
}
targetVersion, ok := target.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("target %s is already up-to-date", common.MustGetKey(target))
return nil
}
targetCopy := target.DeepCopy()
if targetCopy.Data == nil {
targetCopy.Data = make(map[string][]byte)
}
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&targetCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value)
targetCopy.Data[key] = newValue
replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source any more", k)
delete(targetCopy.Data, k)
}
}
sort.Strings(replicatedKeys)
logger.Infof("updating target %s", common.MustGetKey(target))
targetCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
targetCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
targetCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
s, err := r.Client.CoreV1().Secrets(target.Namespace).Update(context.TODO(), targetCopy, metav1.UpdateOptions{})
if err != nil {
err = errors.Wrapf(err, "Failed updating target %s/%s", target.Namespace, targetCopy.Name)
} else if err = r.Store.Update(s); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s: %v", target.Namespace, targetCopy, err)
}
return err
}
// ReplicateObjectTo copies the whole object to target namespace
func (r *Replicator) ReplicateObjectTo(sourceObj interface{}, target *v1.Namespace) error {
source := sourceObj.(*v1.Secret)
targetLocation := fmt.Sprintf("%s/%s", target.Name, source.Name)
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
targetResourceType := source.Type
targetResource, exists, err := r.Store.GetByKey(targetLocation)
if err != nil {
return errors.Wrapf(err, "Could not get %s from cache!", targetLocation)
}
logger.Infof("Checking if %s exists? %v", targetLocation, exists)
var resourceCopy *v1.Secret
if exists {
targetObject := targetResource.(*v1.Secret)
targetVersion, ok := targetObject.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("Secret %s is already up-to-date", common.MustGetKey(targetObject))
return nil
}
targetResourceType = targetObject.Type
resourceCopy = targetObject.DeepCopy()
} else {
resourceCopy = new(v1.Secret)
}
keepOwnerReferences, ok := source.Annotations[common.KeepOwnerReferences]
if ok && keepOwnerReferences == "true" {
resourceCopy.OwnerReferences = source.OwnerReferences
}
if resourceCopy.Data == nil {
resourceCopy.Data = make(map[string][]byte)
}
if resourceCopy.Annotations == nil {
resourceCopy.Annotations = make(map[string]string)
}
replicatedKeys := r.extractReplicatedKeys(source, targetLocation, resourceCopy)
sort.Strings(replicatedKeys)
labelsCopy := make(map[string]string)
stripLabels, ok := source.Annotations[common.StripLabels]
if !ok && stripLabels != "true" {
if source.Labels != nil |
}
resourceCopy.Name = source.Name
resourceCopy.Labels = labelsCopy
resourceCopy.Type = targetResourceType
resourceCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
resourceCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
resourceCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
var obj interface{}
if exists {
logger.Debugf("Updating existing secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Update(context.TODO(), resourceCopy, metav1.UpdateOptions{})
} else {
logger.Debugf("Creating a new secret secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Create(context.TODO(), resourceCopy, metav1.CreateOptions{})
}
if err != nil {
err = errors.Wrapf(err, "Failed to update secret %s/%s", target.Name, resourceCopy.Name)
} else if err = r.Store.Update(obj); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s", target.Name, resourceCopy)
}
return err
}
func (r *Replicator) extractReplicatedKeys(source *v1.Secret, targetLocation string, resourceCopy *v1.Secret) []string {
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&resourceCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value)
resourceCopy.Data[key] = newValue
replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source secret any more", k)
delete(resourceCopy.Data, k)
}
}
return replicatedKeys
}
func (r *Replicator) PatchDeleteDependent(sourceKey string, target interface{}) (interface{}, error) {
dependentKey := common.MustGetKey(target)
logger := log.WithFields(log.Fields{
"kind": r.Kind,
"source": sourceKey,
"target": dependentKey,
})
targetObject, ok := target.(*v1.Secret)
if !ok {
err := errors.Errorf("bad type returned from Store: %T", target)
return nil, err
}
patch := []common.JSONPatchOperation{{Operation: "remove", Path: "/data"}}
patchBody, err := json.Marshal(&patch)
if err != nil {
return nil, errors.Wrapf(err, "error while building patch body for secret %s: %v", dependentKey, err)
}
logger.Debugf("clearing dependent %s %s", r.Kind, dependentKey)
logger.Tracef("patch body: %s", string(patchBody))
s, err := r.Client.CoreV1().Secrets(targetObject.Namespace).Patch(context.TODO(), targetObject.Name, types.JSONPatchType, patchBody, metav1.PatchOptions{})
if err != nil {
return nil, errors.Wrapf(err, "error while patching secret %s: %v", dependentKey, err)
}
return s, nil
}
// DeleteReplicatedResource deletes a resource replicated by ReplicateTo annotation
func (r *Replicator) DeleteReplicatedResource(targetResource interface{}) error {
targetLocation := common.MustGetKey(targetResource)
logger := log.WithFields(log.Fields{
"kind": | {
for key, value := range source.Labels {
labelsCopy[key] = value
}
} | conditional_block |
secrets.go | := Replicator{
GenericReplicator: common.NewGenericReplicator(common.ReplicatorConfig{
Kind: "Secret",
ObjType: &v1.Secret{},
AllowAll: allowAll,
ResyncPeriod: resyncPeriod,
Client: client,
ListFunc: func(lo metav1.ListOptions) (runtime.Object, error) {
return client.CoreV1().Secrets("").List(context.TODO(), lo)
},
WatchFunc: func(lo metav1.ListOptions) (watch.Interface, error) {
return client.CoreV1().Secrets("").Watch(context.TODO(), lo)
},
}),
}
repl.UpdateFuncs = common.UpdateFuncs{
ReplicateDataFrom: repl.ReplicateDataFrom,
ReplicateObjectTo: repl.ReplicateObjectTo,
PatchDeleteDependent: repl.PatchDeleteDependent,
DeleteReplicatedResource: repl.DeleteReplicatedResource,
}
return &repl
}
// ReplicateDataFrom takes a source object and copies over data to target object
func (r *Replicator) ReplicateDataFrom(sourceObj interface{}, targetObj interface{}) error {
source := sourceObj.(*v1.Secret)
target := targetObj.(*v1.Secret)
// make sure replication is allowed
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", common.MustGetKey(target))
if ok, err := r.IsReplicationPermitted(&target.ObjectMeta, &source.ObjectMeta); !ok {
return errors.Wrapf(err, "replication of target %s is not permitted", common.MustGetKey(source))
}
targetVersion, ok := target.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("target %s is already up-to-date", common.MustGetKey(target))
return nil
}
targetCopy := target.DeepCopy()
if targetCopy.Data == nil {
targetCopy.Data = make(map[string][]byte)
}
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&targetCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value)
targetCopy.Data[key] = newValue
replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source any more", k)
delete(targetCopy.Data, k)
}
}
sort.Strings(replicatedKeys)
logger.Infof("updating target %s", common.MustGetKey(target))
targetCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
targetCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
targetCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
s, err := r.Client.CoreV1().Secrets(target.Namespace).Update(context.TODO(), targetCopy, metav1.UpdateOptions{})
if err != nil {
err = errors.Wrapf(err, "Failed updating target %s/%s", target.Namespace, targetCopy.Name)
} else if err = r.Store.Update(s); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s: %v", target.Namespace, targetCopy, err)
}
return err
}
// ReplicateObjectTo copies the whole object to target namespace
func (r *Replicator) ReplicateObjectTo(sourceObj interface{}, target *v1.Namespace) error {
source := sourceObj.(*v1.Secret)
targetLocation := fmt.Sprintf("%s/%s", target.Name, source.Name)
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
targetResourceType := source.Type
targetResource, exists, err := r.Store.GetByKey(targetLocation)
if err != nil {
return errors.Wrapf(err, "Could not get %s from cache!", targetLocation)
}
logger.Infof("Checking if %s exists? %v", targetLocation, exists)
var resourceCopy *v1.Secret
if exists {
targetObject := targetResource.(*v1.Secret)
targetVersion, ok := targetObject.Annotations[common.ReplicatedFromVersionAnnotation]
sourceVersion := source.ResourceVersion
if ok && targetVersion == sourceVersion {
logger.Debugf("Secret %s is already up-to-date", common.MustGetKey(targetObject))
return nil
}
targetResourceType = targetObject.Type
resourceCopy = targetObject.DeepCopy()
} else {
resourceCopy = new(v1.Secret)
}
keepOwnerReferences, ok := source.Annotations[common.KeepOwnerReferences]
if ok && keepOwnerReferences == "true" {
resourceCopy.OwnerReferences = source.OwnerReferences
}
if resourceCopy.Data == nil {
resourceCopy.Data = make(map[string][]byte)
}
if resourceCopy.Annotations == nil {
resourceCopy.Annotations = make(map[string]string)
}
replicatedKeys := r.extractReplicatedKeys(source, targetLocation, resourceCopy)
sort.Strings(replicatedKeys)
labelsCopy := make(map[string]string)
stripLabels, ok := source.Annotations[common.StripLabels]
if !ok && stripLabels != "true" {
if source.Labels != nil {
for key, value := range source.Labels {
labelsCopy[key] = value
}
}
}
resourceCopy.Name = source.Name
resourceCopy.Labels = labelsCopy
resourceCopy.Type = targetResourceType
resourceCopy.Annotations[common.ReplicatedAtAnnotation] = time.Now().Format(time.RFC3339)
resourceCopy.Annotations[common.ReplicatedFromVersionAnnotation] = source.ResourceVersion
resourceCopy.Annotations[common.ReplicatedKeysAnnotation] = strings.Join(replicatedKeys, ",")
var obj interface{}
if exists {
logger.Debugf("Updating existing secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Update(context.TODO(), resourceCopy, metav1.UpdateOptions{})
} else {
logger.Debugf("Creating a new secret secret %s/%s", target.Name, resourceCopy.Name)
obj, err = r.Client.CoreV1().Secrets(target.Name).Create(context.TODO(), resourceCopy, metav1.CreateOptions{})
}
if err != nil {
err = errors.Wrapf(err, "Failed to update secret %s/%s", target.Name, resourceCopy.Name)
} else if err = r.Store.Update(obj); err != nil {
err = errors.Wrapf(err, "Failed to update cache for %s/%s", target.Name, resourceCopy)
}
return err
}
func (r *Replicator) extractReplicatedKeys(source *v1.Secret, targetLocation string, resourceCopy *v1.Secret) []string {
logger := log.
WithField("kind", r.Kind).
WithField("source", common.MustGetKey(source)).
WithField("target", targetLocation)
prevKeys, hasPrevKeys := common.PreviouslyPresentKeys(&resourceCopy.ObjectMeta)
replicatedKeys := make([]string, 0)
for key, value := range source.Data {
newValue := make([]byte, len(value))
copy(newValue, value)
resourceCopy.Data[key] = newValue
replicatedKeys = append(replicatedKeys, key)
delete(prevKeys, key)
}
if hasPrevKeys {
for k := range prevKeys {
logger.Debugf("removing previously present key %s: not present in source secret any more", k)
delete(resourceCopy.Data, k)
}
}
return replicatedKeys
}
func (r *Replicator) | (sourceKey string, target interface{}) (interface{}, error) {
dependentKey := common.MustGetKey(target)
logger := log.WithFields(log.Fields{
"kind": r.Kind,
"source": sourceKey,
"target": dependentKey,
})
targetObject, ok := target.(*v1.Secret)
if !ok {
err := errors.Errorf("bad type returned from Store: %T", target)
return nil, err
}
patch := []common.JSONPatchOperation{{Operation: "remove", Path: "/data"}}
patchBody, err := json.Marshal(&patch)
if err != nil {
return nil, errors.Wrapf(err, "error while building patch body for secret %s: %v", dependentKey, err)
}
logger.Debugf("clearing dependent %s %s", r.Kind, dependentKey)
logger.Tracef("patch body: %s", string(patchBody))
s, err := r.Client.CoreV1().Secrets(targetObject.Namespace).Patch(context.TODO(), targetObject.Name, types.JSONPatchType, patchBody, metav1.PatchOptions{})
if err != nil {
return nil, errors.Wrapf(err, "error while patching secret %s: %v", dependentKey, err)
}
return s, nil
}
// DeleteReplicatedResource deletes a resource replicated by ReplicateTo annotation
func (r *Replicator) DeleteReplicatedResource(targetResource interface{}) error {
targetLocation := common.MustGetKey(targetResource)
logger := log.WithFields(log.Fields{
"kind": r | PatchDeleteDependent | identifier_name |
lib.rs | #[setters(into)]
#[setters(strip_option)]
events: Option<Arc<EventSender>>,
}
impl Default for Fetcher {
fn default() -> Self { Self::new(Client::with_http_client(NativeClient::default())) }
}
impl Fetcher {
/// Wraps the fetcher in an Arc.
pub fn into_arc(self) -> Arc<Self> { Arc::new(self) }
/// Request a file from one or more URIs.
///
/// At least one URI must be provided as a source for the file. Each additional URI
/// serves as a mirror for failover and load-balancing purposes.
pub async fn request(
self: Arc<Self>,
uris: Arc<[Box<str>]>,
to: Arc<Path>,
) -> Result<(), Error> {
match self.clone().inner_request(uris.clone(), to.clone()).await {
Ok(()) => Ok(()),
Err(mut why) => {
for _ in 1..self.retries.get() {
match self.clone().inner_request(uris.clone(), to.clone()).await {
Ok(()) => return Ok(()),
Err(cause) => why = cause,
}
}
Err(why)
}
}
}
async fn inner_request(
self: Arc<Self>,
uris: Arc<[Box<str>]>,
to: Arc<Path>,
) -> Result<(), Error> {
let mut modified = None;
let mut length = None;
let mut if_modified_since = None;
// If the file already exists, validate that it is the same.
if to.exists() {
if let Some(response) = head(&self.client, &*uris[0]).await? {
let content_length = response.content_length();
modified = response.last_modified();
if let (Some(content_length), Some(last_modified)) =
(content_length, modified)
{
match fs::metadata(to.as_ref()).await {
Ok(metadata) => {
let modified = metadata.modified().map_err(Error::Write)?;
let ts = modified
.duration_since(UNIX_EPOCH)
.expect("time went backwards");
if metadata.len() == content_length
&& ts.as_secs() == last_modified.timestamp() as u64
{
self.send((to, FetchEvent::AlreadyFetched));
return Ok(());
}
if_modified_since =
Some(DateTime::<Utc>::from(modified).to_rfc2822());
length = Some(content_length);
}
Err(why) => {
error!("failed to fetch metadata of {:?}: {}", to, why);
fs::remove_file(to.as_ref())
.await
.map_err(Error::MetadataRemove)?;
}
}
}
}
}
// If set, this will use multiple connections to download a file in parts.
if let Some(connections) = self.connections_per_file {
if let Some(response) = head(&self.client, &*uris[0]).await? {
modified = response.last_modified();
let length = match length {
Some(length) => Some(length),
None => response.content_length(),
};
if let Some(length) = length {
if supports_range(&self.client, &*uris[0], length).await? {
self.send((to.clone(), FetchEvent::ContentLength(length)));
return self
.get_many(length, connections.get(), uris, to, modified)
.await;
}
}
}
}
let mut request = self.client.get(&*uris[0]).header("Expect", "").build();
if let Some(modified_since) = if_modified_since {
request.set_header("if-modified-since", modified_since);
}
let path =
match self.get(&mut modified, request, to.clone(), to.clone(), None).await {
Ok(path) => path,
// Server does not support if-modified-since
Err(Error::Status(StatusCode::NotImplemented)) => {
let request = self.client.get(&*uris[0]).header("Expect", "").build();
self.get(&mut modified, request, to.clone(), to, None).await?
}
Err(why) => return Err(why),
};
if let Some(modified) = modified {
let filetime = FileTime::from_unix_time(modified.timestamp(), 0);
filetime::set_file_times(&path, filetime, filetime)
.map_err(move |why| Error::FileTime(path, why))?;
}
Ok(())
}
async fn get(
&self,
modified: &mut Option<DateTime<Utc>>,
request: Request,
to: Arc<Path>,
dest: Arc<Path>,
length: Option<u64>,
) -> Result<Arc<Path>, Error> {
let mut file = File::create(to.as_ref()).await.map_err(Error::FileCreate)?;
if let Some(length) = length {
file.set_len(length).await.map_err(Error::Write)?;
}
let response = &mut validate(if let Some(duration) = self.timeout {
timed(duration, async { self.client.send(request).await.map_err(Error::from) }).await??
} else {
self.client.send(request).await?
})?;
if modified.is_none() {
*modified = response.last_modified();
}
if response.status() == StatusCode::NotModified {
return Ok(to);
}
let buffer = &mut [0u8; 8 * 1024];
let mut read;
loop {
if self.cancelled() {
return Err(Error::Cancelled);
}
let reader = async { response.read(buffer).await.map_err(Error::Write) };
read = match self.timeout {
Some(duration) => timed(duration, reader).await??,
None => reader.await?,
};
if read != 0 {
self.send((dest.clone(), FetchEvent::Progress(read)));
file.write_all(&buffer[..read]).await.map_err(Error::Write)?;
} else {
break;
}
}
Ok(to)
}
async fn get_many(
self: Arc<Self>,
length: u64,
concurrent: u16,
uris: Arc<[Box<str>]>,
to: Arc<Path>,
mut modified: Option<DateTime<Utc>>,
) -> Result<(), Error> {
let parent = to.parent().ok_or(Error::Parentless)?;
let filename = to.file_name().ok_or(Error::Nameless)?;
let mut buf = [0u8; 20];
// The destination which parts will be concatenated to.
let concatenated_file =
&mut File::create(to.as_ref()).await.map_err(Error::FileCreate)?;
let max_part_size =
unsafe { NonZeroU64::new_unchecked(u64::from(self.max_part_size.get())) };
let to_ = to.clone();
let parts = stream::iter(range::generate(length, max_part_size).enumerate())
// Generate a future for fetching each part that a range describes.
.map(move |(partn, (range_start, range_end))| {
let uri = uris[partn % uris.len()].clone();
let part_path = {
let mut new_filename = filename.to_os_string();
new_filename
.push(&[".part", partn.numtoa_str(10, &mut buf)].concat());
parent.join(new_filename)
};
let fetcher = self.clone();
let to = to_.clone();
async move {
let range = range::to_string(range_start, range_end);
fetcher.send((to.clone(), FetchEvent::PartFetching(partn as u64)));
let request = fetcher
.client
.get(&*uri)
.header("range", range.as_str())
.header("Expect", "")
.build();
let result = fetcher
.get(
&mut modified,
request,
part_path.into(),
to.clone(),
Some(range_end - range_start),
)
.await;
fetcher.send((to, FetchEvent::PartFetched(partn as u64)));
result
}
})
// Ensure that only this many connections are happenning concurrently at a
// time
.buffered(concurrent as usize)
// This type exploded the stack, and therefore needs to be boxed
.boxed_local();
systems::concatenator(concatenated_file, parts).await?;
if let Some(modified) = modified {
let filetime = FileTime::from_unix_time(modified.timestamp(), 0);
filetime::set_file_times(&to, filetime, filetime)
.map_err(|why| Error::FileTime(to, why))?;
}
Ok(())
}
fn cancelled(&self) -> bool {
self.cancel.as_ref().map_or(false, |cancel| cancel.load(Ordering::SeqCst))
}
fn send(&self, event: (Arc<Path>, FetchEvent)) {
if let Some(sender) = self.events.as_ref() {
let _ = sender.unbounded_send(event);
}
}
}
async fn head(
client: &Client,
uri: &str,
) -> Result<Option<Response>, Error> {
match validate(client.head(uri).header("Expect", "").await?).map(Some) {
result @ Ok(_) => result,
Err(Error::Status(StatusCode::NotImplemented)) => Ok(None),
Err(other) => Err(other),
} | } | random_line_split |
|
lib.rs | ")]
TimedOut,
#[error("error writing to file")]
Write(#[source] io::Error),
#[error("failed to rename partial to destination")]
Rename(#[source] io::Error),
#[error("server responded with an error: {}", _0)]
Status(StatusCode),
}
/// Information about a source being fetched.
#[derive(Debug, Setters)]
pub struct Source {
/// URLs whereby the file can be found.
#[setters(skip)]
pub urls: Arc<[Box<str>]>,
/// Where the file shall ultimately be fetched to.
#[setters(skip)]
pub dest: Arc<Path>,
/// Optional location to store the partial file
#[setters(strip_option)]
#[setters(into)]
pub part: Option<Arc<Path>>,
}
impl Source {
pub fn new(urls: impl Into<Arc<[Box<str>]>>, dest: impl Into<Arc<Path>>) -> Self {
Self { urls: urls.into(), dest: dest.into(), part: None }
}
}
impl From<surf::Error> for Error {
fn from(e: surf::Error) -> Self { Self::Client(e) }
}
/// Events which are submitted by the fetcher.
#[derive(Debug)]
pub enum | {
/// Signals that this file was already fetched.
AlreadyFetched,
/// States that we know the length of the file being fetched.
ContentLength(u64),
/// Notifies that the file has been fetched.
Fetched,
/// Notifies that a file is being fetched.
Fetching,
/// Reports the amount of bytes that have been read for a file.
Progress(usize),
/// Reports that a part of a file is being fetched.
PartFetching(u64),
/// Reports that a part has been fetched.
PartFetched(u64),
}
/// An asynchronous file fetcher for clients fetching files.
///
/// The futures generated by the fetcher are compatible with single and multi-threaded
/// runtimes, allowing you to choose between the runtime that works best for your
/// application. A single-threaded runtime is generally recommended for fetching files,
/// as your network connection is unlikely to be faster than a single CPU core.
#[derive(new, Setters)]
pub struct Fetcher {
#[setters(skip)]
client: Client,
/// When set, cancels any active operations.
#[new(default)]
#[setters(strip_option)]
cancel: Option<Arc<AtomicBool>>,
/// The number of concurrent connections to sustain per file being fetched.
#[new(default)]
connections_per_file: Option<NonZeroU16>,
/// The number of attempts to make when a request fails.
#[new(value = "unsafe { NonZeroU16::new_unchecked(3) } ")]
retries: NonZeroU16,
/// The maximum size of a part file when downloading in parts.
#[new(value = "unsafe { NonZeroU32::new_unchecked(2 * 1024 * 1024) }")]
max_part_size: NonZeroU32,
/// The time to wait between chunks before giving up.
#[new(default)]
#[setters(strip_option)]
timeout: Option<Duration>,
/// Holds a sender for submitting events to.
#[new(default)]
#[setters(into)]
#[setters(strip_option)]
events: Option<Arc<EventSender>>,
}
impl Default for Fetcher {
fn default() -> Self { Self::new(Client::with_http_client(NativeClient::default())) }
}
impl Fetcher {
/// Wraps the fetcher in an Arc.
pub fn into_arc(self) -> Arc<Self> { Arc::new(self) }
/// Request a file from one or more URIs.
///
/// At least one URI must be provided as a source for the file. Each additional URI
/// serves as a mirror for failover and load-balancing purposes.
pub async fn request(
self: Arc<Self>,
uris: Arc<[Box<str>]>,
to: Arc<Path>,
) -> Result<(), Error> {
match self.clone().inner_request(uris.clone(), to.clone()).await {
Ok(()) => Ok(()),
Err(mut why) => {
for _ in 1..self.retries.get() {
match self.clone().inner_request(uris.clone(), to.clone()).await {
Ok(()) => return Ok(()),
Err(cause) => why = cause,
}
}
Err(why)
}
}
}
async fn inner_request(
self: Arc<Self>,
uris: Arc<[Box<str>]>,
to: Arc<Path>,
) -> Result<(), Error> {
let mut modified = None;
let mut length = None;
let mut if_modified_since = None;
// If the file already exists, validate that it is the same.
if to.exists() {
if let Some(response) = head(&self.client, &*uris[0]).await? {
let content_length = response.content_length();
modified = response.last_modified();
if let (Some(content_length), Some(last_modified)) =
(content_length, modified)
{
match fs::metadata(to.as_ref()).await {
Ok(metadata) => {
let modified = metadata.modified().map_err(Error::Write)?;
let ts = modified
.duration_since(UNIX_EPOCH)
.expect("time went backwards");
if metadata.len() == content_length
&& ts.as_secs() == last_modified.timestamp() as u64
{
self.send((to, FetchEvent::AlreadyFetched));
return Ok(());
}
if_modified_since =
Some(DateTime::<Utc>::from(modified).to_rfc2822());
length = Some(content_length);
}
Err(why) => {
error!("failed to fetch metadata of {:?}: {}", to, why);
fs::remove_file(to.as_ref())
.await
.map_err(Error::MetadataRemove)?;
}
}
}
}
}
// If set, this will use multiple connections to download a file in parts.
if let Some(connections) = self.connections_per_file {
if let Some(response) = head(&self.client, &*uris[0]).await? {
modified = response.last_modified();
let length = match length {
Some(length) => Some(length),
None => response.content_length(),
};
if let Some(length) = length {
if supports_range(&self.client, &*uris[0], length).await? {
self.send((to.clone(), FetchEvent::ContentLength(length)));
return self
.get_many(length, connections.get(), uris, to, modified)
.await;
}
}
}
}
let mut request = self.client.get(&*uris[0]).header("Expect", "").build();
if let Some(modified_since) = if_modified_since {
request.set_header("if-modified-since", modified_since);
}
let path =
match self.get(&mut modified, request, to.clone(), to.clone(), None).await {
Ok(path) => path,
// Server does not support if-modified-since
Err(Error::Status(StatusCode::NotImplemented)) => {
let request = self.client.get(&*uris[0]).header("Expect", "").build();
self.get(&mut modified, request, to.clone(), to, None).await?
}
Err(why) => return Err(why),
};
if let Some(modified) = modified {
let filetime = FileTime::from_unix_time(modified.timestamp(), 0);
filetime::set_file_times(&path, filetime, filetime)
.map_err(move |why| Error::FileTime(path, why))?;
}
Ok(())
}
async fn get(
&self,
modified: &mut Option<DateTime<Utc>>,
request: Request,
to: Arc<Path>,
dest: Arc<Path>,
length: Option<u64>,
) -> Result<Arc<Path>, Error> {
let mut file = File::create(to.as_ref()).await.map_err(Error::FileCreate)?;
if let Some(length) = length {
file.set_len(length).await.map_err(Error::Write)?;
}
let response = &mut validate(if let Some(duration) = self.timeout {
timed(duration, async { self.client.send(request).await.map_err(Error::from) }).await??
} else {
self.client.send(request).await?
})?;
if modified.is_none() {
*modified = response.last_modified();
}
if response.status() == StatusCode::NotModified {
return Ok(to);
}
let buffer = &mut [0u8; 8 * 1024];
let mut read;
loop {
if self.cancelled() {
return Err(Error::Cancelled);
}
let reader = async { response.read(buffer).await.map_err(Error::Write) };
read = match self.timeout {
Some(duration) => timed(duration, reader).await??,
None => reader.await?,
};
if read != 0 {
self.send((dest.clone(), FetchEvent::Progress(read)));
file.write_all(&buffer[..read]).await.map_err(Error::Write)?;
} else {
break;
}
}
Ok(to)
}
async fn get_many(
self: Arc<Self>,
length: u64,
concurrent: u | FetchEvent | identifier_name |
lib.rs | tries.get() {
match self.clone().inner_request(uris.clone(), to.clone()).await {
Ok(()) => return Ok(()),
Err(cause) => why = cause,
}
}
Err(why)
}
}
}
async fn inner_request(
self: Arc<Self>,
uris: Arc<[Box<str>]>,
to: Arc<Path>,
) -> Result<(), Error> {
let mut modified = None;
let mut length = None;
let mut if_modified_since = None;
// If the file already exists, validate that it is the same.
if to.exists() {
if let Some(response) = head(&self.client, &*uris[0]).await? {
let content_length = response.content_length();
modified = response.last_modified();
if let (Some(content_length), Some(last_modified)) =
(content_length, modified)
{
match fs::metadata(to.as_ref()).await {
Ok(metadata) => {
let modified = metadata.modified().map_err(Error::Write)?;
let ts = modified
.duration_since(UNIX_EPOCH)
.expect("time went backwards");
if metadata.len() == content_length
&& ts.as_secs() == last_modified.timestamp() as u64
{
self.send((to, FetchEvent::AlreadyFetched));
return Ok(());
}
if_modified_since =
Some(DateTime::<Utc>::from(modified).to_rfc2822());
length = Some(content_length);
}
Err(why) => {
error!("failed to fetch metadata of {:?}: {}", to, why);
fs::remove_file(to.as_ref())
.await
.map_err(Error::MetadataRemove)?;
}
}
}
}
}
// If set, this will use multiple connections to download a file in parts.
if let Some(connections) = self.connections_per_file {
if let Some(response) = head(&self.client, &*uris[0]).await? {
modified = response.last_modified();
let length = match length {
Some(length) => Some(length),
None => response.content_length(),
};
if let Some(length) = length {
if supports_range(&self.client, &*uris[0], length).await? {
self.send((to.clone(), FetchEvent::ContentLength(length)));
return self
.get_many(length, connections.get(), uris, to, modified)
.await;
}
}
}
}
let mut request = self.client.get(&*uris[0]).header("Expect", "").build();
if let Some(modified_since) = if_modified_since {
request.set_header("if-modified-since", modified_since);
}
let path =
match self.get(&mut modified, request, to.clone(), to.clone(), None).await {
Ok(path) => path,
// Server does not support if-modified-since
Err(Error::Status(StatusCode::NotImplemented)) => {
let request = self.client.get(&*uris[0]).header("Expect", "").build();
self.get(&mut modified, request, to.clone(), to, None).await?
}
Err(why) => return Err(why),
};
if let Some(modified) = modified {
let filetime = FileTime::from_unix_time(modified.timestamp(), 0);
filetime::set_file_times(&path, filetime, filetime)
.map_err(move |why| Error::FileTime(path, why))?;
}
Ok(())
}
async fn get(
&self,
modified: &mut Option<DateTime<Utc>>,
request: Request,
to: Arc<Path>,
dest: Arc<Path>,
length: Option<u64>,
) -> Result<Arc<Path>, Error> {
let mut file = File::create(to.as_ref()).await.map_err(Error::FileCreate)?;
if let Some(length) = length {
file.set_len(length).await.map_err(Error::Write)?;
}
let response = &mut validate(if let Some(duration) = self.timeout {
timed(duration, async { self.client.send(request).await.map_err(Error::from) }).await??
} else {
self.client.send(request).await?
})?;
if modified.is_none() {
*modified = response.last_modified();
}
if response.status() == StatusCode::NotModified {
return Ok(to);
}
let buffer = &mut [0u8; 8 * 1024];
let mut read;
loop {
if self.cancelled() {
return Err(Error::Cancelled);
}
let reader = async { response.read(buffer).await.map_err(Error::Write) };
read = match self.timeout {
Some(duration) => timed(duration, reader).await??,
None => reader.await?,
};
if read != 0 {
self.send((dest.clone(), FetchEvent::Progress(read)));
file.write_all(&buffer[..read]).await.map_err(Error::Write)?;
} else {
break;
}
}
Ok(to)
}
async fn get_many(
self: Arc<Self>,
length: u64,
concurrent: u16,
uris: Arc<[Box<str>]>,
to: Arc<Path>,
mut modified: Option<DateTime<Utc>>,
) -> Result<(), Error> {
let parent = to.parent().ok_or(Error::Parentless)?;
let filename = to.file_name().ok_or(Error::Nameless)?;
let mut buf = [0u8; 20];
// The destination which parts will be concatenated to.
let concatenated_file =
&mut File::create(to.as_ref()).await.map_err(Error::FileCreate)?;
let max_part_size =
unsafe { NonZeroU64::new_unchecked(u64::from(self.max_part_size.get())) };
let to_ = to.clone();
let parts = stream::iter(range::generate(length, max_part_size).enumerate())
// Generate a future for fetching each part that a range describes.
.map(move |(partn, (range_start, range_end))| {
let uri = uris[partn % uris.len()].clone();
let part_path = {
let mut new_filename = filename.to_os_string();
new_filename
.push(&[".part", partn.numtoa_str(10, &mut buf)].concat());
parent.join(new_filename)
};
let fetcher = self.clone();
let to = to_.clone();
async move {
let range = range::to_string(range_start, range_end);
fetcher.send((to.clone(), FetchEvent::PartFetching(partn as u64)));
let request = fetcher
.client
.get(&*uri)
.header("range", range.as_str())
.header("Expect", "")
.build();
let result = fetcher
.get(
&mut modified,
request,
part_path.into(),
to.clone(),
Some(range_end - range_start),
)
.await;
fetcher.send((to, FetchEvent::PartFetched(partn as u64)));
result
}
})
// Ensure that only this many connections are happenning concurrently at a
// time
.buffered(concurrent as usize)
// This type exploded the stack, and therefore needs to be boxed
.boxed_local();
systems::concatenator(concatenated_file, parts).await?;
if let Some(modified) = modified {
let filetime = FileTime::from_unix_time(modified.timestamp(), 0);
filetime::set_file_times(&to, filetime, filetime)
.map_err(|why| Error::FileTime(to, why))?;
}
Ok(())
}
fn cancelled(&self) -> bool {
self.cancel.as_ref().map_or(false, |cancel| cancel.load(Ordering::SeqCst))
}
fn send(&self, event: (Arc<Path>, FetchEvent)) {
if let Some(sender) = self.events.as_ref() {
let _ = sender.unbounded_send(event);
}
}
}
async fn head(
client: &Client,
uri: &str,
) -> Result<Option<Response>, Error> {
match validate(client.head(uri).header("Expect", "").await?).map(Some) {
result @ Ok(_) => result,
Err(Error::Status(StatusCode::NotImplemented)) => Ok(None),
Err(other) => Err(other),
}
}
async fn supports_range(
client: &Client,
uri: &str,
length: u64,
) -> Result<bool, Error> {
let response = client
.head(uri)
.header("Expect", "")
.header("range", range::to_string(0, length).as_str())
.await?;
if response.status() == StatusCode::PartialContent {
Ok(true)
} else {
validate(response).map(|_| false)
}
}
async fn timed<F, T>(duration: Duration, future: F) -> Result<T, Error>
where
F: Future<Output = T>,
{
async_std::future::timeout(duration, future).await.map_err(|_| Error::TimedOut)
}
fn validate(response: Response) -> Result<Response, Error> | {
let status = response.status();
if status.is_informational() || status.is_success() {
Ok(response)
} else {
Err(Error::Status(status))
}
} | identifier_body |
|
statformat.py | stat == "http://purl.obolibrary.org/obo/STATO_0000376":
return("Z")
elif stat == "http://purl.obolibrary.org/obo/STATO_0000282":
return("F")
elif stat == "http://purl.obolibrary.org/obo/STATO_0000176":
return("T")
else:
return("P")
# This function returns the cluster forming threshold type of an image.
def height_thresh_type(graph, imageType):
if run_query(graph, 'askIfOboStatistic', 'Ask'):
return(imageType)
else:
return("P")
# This function returns the statistic type of a statistic
def statistic_type_string(statImage):
if statImage == "T":
return("T")
elif statImage == "F":
return("F")
elif statImage == "Z":
return("Z (Gaussianised T/F)")
def format_cluster_stats(g, excName):
# ----------------------------------------------------------------------
# First we gather data for peaks table.
# ----------------------------------------------------------------------
# Run the peak query
peakQueryResult = run_query(g, 'selectPeakData', 'Select',
{'EXC_NAME': excName})
# Retrieve query results.
peakZstats = [float(peakQueryResult[i]) for i in list(range(0, len(
peakQueryResult), 5))]
clusterIndicesForPeaks = [int(peakQueryResult[i]) for i in list(range(
1, len(peakQueryResult), 5))]
locations = [peakQueryResult[i] for i in list(range(2, len(
peakQueryResult), 5))]
# If a corrected height threshold has been applied we should display
# corrected peak P values. Else we should use uncorrected peak P values.
try:
if run_query(g, 'askCHeightThreshold', 'Ask'):
|
peakPVals = [float(peakQueryResult[i]) for i in list(
range(4, len(peakQueryResult), 5))]
# This is a temporary bug fix due to the FSL exporter currently not
# recording corrected peak P-values.
except ValueError:
peakPVals = [math.nan for row in peakQueryResult]
# Obtain permutation used to sort the results in order of descending
# cluster index and then descending peak statistic size.
peaksSortPermutation = sorted(range(len(clusterIndicesForPeaks)),
reverse=True,
key=lambda k: (clusterIndicesForPeaks[k],
peakZstats[k]))
# Sort all peak data using this permutation.
sortedPeaksZstatsArray = [peakZstats[i] for i in peaksSortPermutation]
sortedClusIndicesForPeaks = [
clusterIndicesForPeaks[i] for i in peaksSortPermutation]
sortedPeakLocations = [locations[i] for i in peaksSortPermutation]
sortedPeakPVals = [peakPVals[i] for i in peaksSortPermutation]
# ----------------------------------------------------------------------
# Second we gather data for cluster table.
# ----------------------------------------------------------------------
# Run the cluster query
clusQueryResult = run_query(g, 'selectClusterData', 'Select',
{'EXC_NAME': excName})
clusterIndices = [
int(clusQueryResult[i]) for i in list(
range(0, len(clusQueryResult), 3))]
clusterSizes = [
int(clusQueryResult[i]) for i in list(
range(1, len(clusQueryResult), 3))]
clusterPVals = [
float(clusQueryResult[i]) for i in list(
range(2, len(clusQueryResult), 3))]
# Create an array for the highest peaks.
highestPeakZArray = [0]*len(clusterIndices)
highestPeakLocations = [0]*len(clusterIndices)
for i in list(range(0, len(peakZstats))):
if highestPeakZArray[clusterIndicesForPeaks[i]-1] < peakZstats[i]:
highestPeakZArray[clusterIndicesForPeaks[i]-1] = peakZstats[i]
highestPeakLocations[clusterIndicesForPeaks[i]-1] = locations[i]
# Obtain permutation used to sort the results in order of descending
# cluster index and then for each cluster by peak statistic size.
clusterSortPermutation = sorted(
range(len(clusterIndices)),
reverse=True,
key=lambda k: (clusterSizes[k], clusterIndices[k]))
# Sorted cluster arrays
sortedClusSizeArray = [
clusterSizes[i] for i in clusterSortPermutation]
sortedClusIndicesArray = [
clusterIndices[i] for i in clusterSortPermutation]
sortedClusPVals = [
clusterPVals[i] for i in clusterSortPermutation]
# Sort the highest peaks
sortedMaxPeakZstats = [
highestPeakZArray[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
sortedMaxPeakLocations = [
highestPeakLocations[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
# Deal with inf issues for peaks.
logPeakPVals = [0]*len(sortedPeakPVals)
for i in list(range(0, len(sortedPeakPVals))):
if sortedPeakPVals[i] == 0:
logPeakPVals[i] = math.inf
else:
logPeakPVals[i] = -math.log(sortedPeakPVals[i], 10)
# Deal with inf issues for clusters.
logClusPVals = [0]*len(sortedClusPVals)
for i in list(range(0, len(sortedClusPVals))):
if sortedClusPVals[i] == 0:
logClusPVals[i] = math.inf
else:
logClusPVals[i] = -math.log(sortedClusPVals[i], 10)
# Record the data for display.
clusterData = {}
# If a corrected cluster threshold has been applied we should display
# cluster P values.
if run_query(g, 'askCExtentThreshold', 'Ask'):
clusterData['clusterPValues'] = sortedClusPVals
clusterData['logClusterPValues'] = logClusPVals
clusterData['clusSizes'] = sortedClusSizeArray
clusterData['clusIndices'] = sortedClusIndicesArray
clusterData['clusPeakZstats'] = sortedMaxPeakZstats
clusterData['clusPeakLocations'] = sortedMaxPeakLocations
clusterData['peakZstats'] = sortedPeaksZstatsArray
clusterData['peakClusIndices'] = sortedClusIndicesForPeaks
clusterData['peakLocations'] = sortedPeakLocations
clusterData['peakPVals'] = sortedPeakPVals
clusterData['logPeakPVals'] = logPeakPVals
return(clusterData)
def contrast_vec(data, v_min, v_max):
# This import is needed only in this function.
from matplotlib import pyplot as plt
conLength = len(data)
# We invert the values so the colours appear correctly (i.
# e. 1 -> white, 0 -> black).
data = np.ones(len(data))-data
# Make the contrast vector larger so we can make an image.
data = np.kron(data, np.ones((10, 30)))
# Add border to data.
data[:, 0] = v_max*np.ones(10)
data[:, 30*conLength-1] = v_max*np.ones(10)
data[0, :] = v_max*np.ones(30*conLength)
data[10-1, :] = v_max*np.ones(30*conLength)
# Create figure.
fig = plt.figure(figsize=(len(data), 1))
# Remove axis
ax = fig.add_subplot(1, 1, 1)
plt.axis('off')
# Add contrast vector to figure
plt.imshow(data, aspect='auto', cmap='Greys', vmin=v_min, vmax=v_max)
# Check for bording box.
extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
# Save figure (without bording box)
tempFile = 'tempCon' + str(random.randint(0, 999999)) + '.png'
plt.savefig(tempFile, bbox_inches=extent)
# Encode the figure.
encodedIm = encode_image(tempFile)
# Remove the image.
os.remove(tempFile)
# Return the image
return('data:image/jpg;base64,' + encodedIm.decode())
# This function takes in an excursion set name and a graph and generates
# an FSL-like name for the HTML output display for the excursionset.
#
# e.g. ExcursionSet_F001.nii.gz -> cluster_zfstat1_std.html
def get_clus_filename(g, excName):
# For SPM data we can't work out the filename we want from just
# the contrast name.
if run_query(g, | peakPVals = [float(peakQueryResult[i]) for i in list(
range(3, len(peakQueryResult), 5))]
else: | random_line_split |
statformat.py | stat == "http://purl.obolibrary.org/obo/STATO_0000376":
|
elif stat == "http://purl.obolibrary.org/obo/STATO_0000282":
return("F")
elif stat == "http://purl.obolibrary.org/obo/STATO_0000176":
return("T")
else:
return("P")
# This function returns the cluster forming threshold type of an image.
def height_thresh_type(graph, imageType):
if run_query(graph, 'askIfOboStatistic', 'Ask'):
return(imageType)
else:
return("P")
# This function returns the statistic type of a statistic
def statistic_type_string(statImage):
if statImage == "T":
return("T")
elif statImage == "F":
return("F")
elif statImage == "Z":
return("Z (Gaussianised T/F)")
def format_cluster_stats(g, excName):
# ----------------------------------------------------------------------
# First we gather data for peaks table.
# ----------------------------------------------------------------------
# Run the peak query
peakQueryResult = run_query(g, 'selectPeakData', 'Select',
{'EXC_NAME': excName})
# Retrieve query results.
peakZstats = [float(peakQueryResult[i]) for i in list(range(0, len(
peakQueryResult), 5))]
clusterIndicesForPeaks = [int(peakQueryResult[i]) for i in list(range(
1, len(peakQueryResult), 5))]
locations = [peakQueryResult[i] for i in list(range(2, len(
peakQueryResult), 5))]
# If a corrected height threshold has been applied we should display
# corrected peak P values. Else we should use uncorrected peak P values.
try:
if run_query(g, 'askCHeightThreshold', 'Ask'):
peakPVals = [float(peakQueryResult[i]) for i in list(
range(3, len(peakQueryResult), 5))]
else:
peakPVals = [float(peakQueryResult[i]) for i in list(
range(4, len(peakQueryResult), 5))]
# This is a temporary bug fix due to the FSL exporter currently not
# recording corrected peak P-values.
except ValueError:
peakPVals = [math.nan for row in peakQueryResult]
# Obtain permutation used to sort the results in order of descending
# cluster index and then descending peak statistic size.
peaksSortPermutation = sorted(range(len(clusterIndicesForPeaks)),
reverse=True,
key=lambda k: (clusterIndicesForPeaks[k],
peakZstats[k]))
# Sort all peak data using this permutation.
sortedPeaksZstatsArray = [peakZstats[i] for i in peaksSortPermutation]
sortedClusIndicesForPeaks = [
clusterIndicesForPeaks[i] for i in peaksSortPermutation]
sortedPeakLocations = [locations[i] for i in peaksSortPermutation]
sortedPeakPVals = [peakPVals[i] for i in peaksSortPermutation]
# ----------------------------------------------------------------------
# Second we gather data for cluster table.
# ----------------------------------------------------------------------
# Run the cluster query
clusQueryResult = run_query(g, 'selectClusterData', 'Select',
{'EXC_NAME': excName})
clusterIndices = [
int(clusQueryResult[i]) for i in list(
range(0, len(clusQueryResult), 3))]
clusterSizes = [
int(clusQueryResult[i]) for i in list(
range(1, len(clusQueryResult), 3))]
clusterPVals = [
float(clusQueryResult[i]) for i in list(
range(2, len(clusQueryResult), 3))]
# Create an array for the highest peaks.
highestPeakZArray = [0]*len(clusterIndices)
highestPeakLocations = [0]*len(clusterIndices)
for i in list(range(0, len(peakZstats))):
if highestPeakZArray[clusterIndicesForPeaks[i]-1] < peakZstats[i]:
highestPeakZArray[clusterIndicesForPeaks[i]-1] = peakZstats[i]
highestPeakLocations[clusterIndicesForPeaks[i]-1] = locations[i]
# Obtain permutation used to sort the results in order of descending
# cluster index and then for each cluster by peak statistic size.
clusterSortPermutation = sorted(
range(len(clusterIndices)),
reverse=True,
key=lambda k: (clusterSizes[k], clusterIndices[k]))
# Sorted cluster arrays
sortedClusSizeArray = [
clusterSizes[i] for i in clusterSortPermutation]
sortedClusIndicesArray = [
clusterIndices[i] for i in clusterSortPermutation]
sortedClusPVals = [
clusterPVals[i] for i in clusterSortPermutation]
# Sort the highest peaks
sortedMaxPeakZstats = [
highestPeakZArray[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
sortedMaxPeakLocations = [
highestPeakLocations[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
# Deal with inf issues for peaks.
logPeakPVals = [0]*len(sortedPeakPVals)
for i in list(range(0, len(sortedPeakPVals))):
if sortedPeakPVals[i] == 0:
logPeakPVals[i] = math.inf
else:
logPeakPVals[i] = -math.log(sortedPeakPVals[i], 10)
# Deal with inf issues for clusters.
logClusPVals = [0]*len(sortedClusPVals)
for i in list(range(0, len(sortedClusPVals))):
if sortedClusPVals[i] == 0:
logClusPVals[i] = math.inf
else:
logClusPVals[i] = -math.log(sortedClusPVals[i], 10)
# Record the data for display.
clusterData = {}
# If a corrected cluster threshold has been applied we should display
# cluster P values.
if run_query(g, 'askCExtentThreshold', 'Ask'):
clusterData['clusterPValues'] = sortedClusPVals
clusterData['logClusterPValues'] = logClusPVals
clusterData['clusSizes'] = sortedClusSizeArray
clusterData['clusIndices'] = sortedClusIndicesArray
clusterData['clusPeakZstats'] = sortedMaxPeakZstats
clusterData['clusPeakLocations'] = sortedMaxPeakLocations
clusterData['peakZstats'] = sortedPeaksZstatsArray
clusterData['peakClusIndices'] = sortedClusIndicesForPeaks
clusterData['peakLocations'] = sortedPeakLocations
clusterData['peakPVals'] = sortedPeakPVals
clusterData['logPeakPVals'] = logPeakPVals
return(clusterData)
def contrast_vec(data, v_min, v_max):
# This import is needed only in this function.
from matplotlib import pyplot as plt
conLength = len(data)
# We invert the values so the colours appear correctly (i.
# e. 1 -> white, 0 -> black).
data = np.ones(len(data))-data
# Make the contrast vector larger so we can make an image.
data = np.kron(data, np.ones((10, 30)))
# Add border to data.
data[:, 0] = v_max*np.ones(10)
data[:, 30*conLength-1] = v_max*np.ones(10)
data[0, :] = v_max*np.ones(30*conLength)
data[10-1, :] = v_max*np.ones(30*conLength)
# Create figure.
fig = plt.figure(figsize=(len(data), 1))
# Remove axis
ax = fig.add_subplot(1, 1, 1)
plt.axis('off')
# Add contrast vector to figure
plt.imshow(data, aspect='auto', cmap='Greys', vmin=v_min, vmax=v_max)
# Check for bording box.
extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
# Save figure (without bording box)
tempFile = 'tempCon' + str(random.randint(0, 999999)) + '.png'
plt.savefig(tempFile, bbox_inches=extent)
# Encode the figure.
encodedIm = encode_image(tempFile)
# Remove the image.
os.remove(tempFile)
# Return the image
return('data:image/jpg;base64,' + encodedIm.decode())
# This function takes in an excursion set name and a graph and generates
# an FSL-like name for the HTML output display for the excursionset.
#
# e.g. ExcursionSet_F001.nii.gz -> cluster_zfstat1_std.html
def get_clus_filename(g, excName):
# For SPM data we can't work out the filename we want from just
# the contrast name.
if run_query(g | return("Z") | conditional_block |
statformat.py | stat == "http://purl.obolibrary.org/obo/STATO_0000376":
return("Z")
elif stat == "http://purl.obolibrary.org/obo/STATO_0000282":
return("F")
elif stat == "http://purl.obolibrary.org/obo/STATO_0000176":
return("T")
else:
return("P")
# This function returns the cluster forming threshold type of an image.
def height_thresh_type(graph, imageType):
if run_query(graph, 'askIfOboStatistic', 'Ask'):
return(imageType)
else:
return("P")
# This function returns the statistic type of a statistic
def statistic_type_string(statImage):
if statImage == "T":
return("T")
elif statImage == "F":
return("F")
elif statImage == "Z":
return("Z (Gaussianised T/F)")
def format_cluster_stats(g, excName):
# ----------------------------------------------------------------------
# First we gather data for peaks table.
# ----------------------------------------------------------------------
# Run the peak query
peakQueryResult = run_query(g, 'selectPeakData', 'Select',
{'EXC_NAME': excName})
# Retrieve query results.
peakZstats = [float(peakQueryResult[i]) for i in list(range(0, len(
peakQueryResult), 5))]
clusterIndicesForPeaks = [int(peakQueryResult[i]) for i in list(range(
1, len(peakQueryResult), 5))]
locations = [peakQueryResult[i] for i in list(range(2, len(
peakQueryResult), 5))]
# If a corrected height threshold has been applied we should display
# corrected peak P values. Else we should use uncorrected peak P values.
try:
if run_query(g, 'askCHeightThreshold', 'Ask'):
peakPVals = [float(peakQueryResult[i]) for i in list(
range(3, len(peakQueryResult), 5))]
else:
peakPVals = [float(peakQueryResult[i]) for i in list(
range(4, len(peakQueryResult), 5))]
# This is a temporary bug fix due to the FSL exporter currently not
# recording corrected peak P-values.
except ValueError:
peakPVals = [math.nan for row in peakQueryResult]
# Obtain permutation used to sort the results in order of descending
# cluster index and then descending peak statistic size.
peaksSortPermutation = sorted(range(len(clusterIndicesForPeaks)),
reverse=True,
key=lambda k: (clusterIndicesForPeaks[k],
peakZstats[k]))
# Sort all peak data using this permutation.
sortedPeaksZstatsArray = [peakZstats[i] for i in peaksSortPermutation]
sortedClusIndicesForPeaks = [
clusterIndicesForPeaks[i] for i in peaksSortPermutation]
sortedPeakLocations = [locations[i] for i in peaksSortPermutation]
sortedPeakPVals = [peakPVals[i] for i in peaksSortPermutation]
# ----------------------------------------------------------------------
# Second we gather data for cluster table.
# ----------------------------------------------------------------------
# Run the cluster query
clusQueryResult = run_query(g, 'selectClusterData', 'Select',
{'EXC_NAME': excName})
clusterIndices = [
int(clusQueryResult[i]) for i in list(
range(0, len(clusQueryResult), 3))]
clusterSizes = [
int(clusQueryResult[i]) for i in list(
range(1, len(clusQueryResult), 3))]
clusterPVals = [
float(clusQueryResult[i]) for i in list(
range(2, len(clusQueryResult), 3))]
# Create an array for the highest peaks.
highestPeakZArray = [0]*len(clusterIndices)
highestPeakLocations = [0]*len(clusterIndices)
for i in list(range(0, len(peakZstats))):
if highestPeakZArray[clusterIndicesForPeaks[i]-1] < peakZstats[i]:
highestPeakZArray[clusterIndicesForPeaks[i]-1] = peakZstats[i]
highestPeakLocations[clusterIndicesForPeaks[i]-1] = locations[i]
# Obtain permutation used to sort the results in order of descending
# cluster index and then for each cluster by peak statistic size.
clusterSortPermutation = sorted(
range(len(clusterIndices)),
reverse=True,
key=lambda k: (clusterSizes[k], clusterIndices[k]))
# Sorted cluster arrays
sortedClusSizeArray = [
clusterSizes[i] for i in clusterSortPermutation]
sortedClusIndicesArray = [
clusterIndices[i] for i in clusterSortPermutation]
sortedClusPVals = [
clusterPVals[i] for i in clusterSortPermutation]
# Sort the highest peaks
sortedMaxPeakZstats = [
highestPeakZArray[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
sortedMaxPeakLocations = [
highestPeakLocations[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
# Deal with inf issues for peaks.
logPeakPVals = [0]*len(sortedPeakPVals)
for i in list(range(0, len(sortedPeakPVals))):
if sortedPeakPVals[i] == 0:
logPeakPVals[i] = math.inf
else:
logPeakPVals[i] = -math.log(sortedPeakPVals[i], 10)
# Deal with inf issues for clusters.
logClusPVals = [0]*len(sortedClusPVals)
for i in list(range(0, len(sortedClusPVals))):
if sortedClusPVals[i] == 0:
logClusPVals[i] = math.inf
else:
logClusPVals[i] = -math.log(sortedClusPVals[i], 10)
# Record the data for display.
clusterData = {}
# If a corrected cluster threshold has been applied we should display
# cluster P values.
if run_query(g, 'askCExtentThreshold', 'Ask'):
clusterData['clusterPValues'] = sortedClusPVals
clusterData['logClusterPValues'] = logClusPVals
clusterData['clusSizes'] = sortedClusSizeArray
clusterData['clusIndices'] = sortedClusIndicesArray
clusterData['clusPeakZstats'] = sortedMaxPeakZstats
clusterData['clusPeakLocations'] = sortedMaxPeakLocations
clusterData['peakZstats'] = sortedPeaksZstatsArray
clusterData['peakClusIndices'] = sortedClusIndicesForPeaks
clusterData['peakLocations'] = sortedPeakLocations
clusterData['peakPVals'] = sortedPeakPVals
clusterData['logPeakPVals'] = logPeakPVals
return(clusterData)
def contrast_vec(data, v_min, v_max):
# This import is needed only in this function.
| # Remove axis
ax = fig.add_subplot(1, 1, 1)
plt.axis('off')
# Add contrast vector to figure
plt.imshow(data, aspect='auto', cmap='Greys', vmin=v_min, vmax=v_max)
# Check for bording box.
extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
# Save figure (without bording box)
tempFile = 'tempCon' + str(random.randint(0, 999999)) + '.png'
plt.savefig(tempFile, bbox_inches=extent)
# Encode the figure.
encodedIm = encode_image(tempFile)
# Remove the image.
os.remove(tempFile)
# Return the image
return('data:image/jpg;base64,' + encodedIm.decode())
# This function takes in an excursion set name and a graph and generates
# an FSL-like name for the HTML output display for the excursionset.
#
# e.g. ExcursionSet_F001.nii.gz -> cluster_zfstat1_std.html
def get_clus_filename(g, excName):
# For SPM data we can't work out the filename we want from just
# the contrast name.
if run_query(g | from matplotlib import pyplot as plt
conLength = len(data)
# We invert the values so the colours appear correctly (i.
# e. 1 -> white, 0 -> black).
data = np.ones(len(data))-data
# Make the contrast vector larger so we can make an image.
data = np.kron(data, np.ones((10, 30)))
# Add border to data.
data[:, 0] = v_max*np.ones(10)
data[:, 30*conLength-1] = v_max*np.ones(10)
data[0, :] = v_max*np.ones(30*conLength)
data[10-1, :] = v_max*np.ones(30*conLength)
# Create figure.
fig = plt.figure(figsize=(len(data), 1))
| identifier_body |
statformat.py | == "http://purl.obolibrary.org/obo/STATO_0000376":
return("Z")
elif stat == "http://purl.obolibrary.org/obo/STATO_0000282":
return("F")
elif stat == "http://purl.obolibrary.org/obo/STATO_0000176":
return("T")
else:
return("P")
# This function returns the cluster forming threshold type of an image.
def height_thresh_type(graph, imageType):
if run_query(graph, 'askIfOboStatistic', 'Ask'):
return(imageType)
else:
return("P")
# This function returns the statistic type of a statistic
def | (statImage):
if statImage == "T":
return("T")
elif statImage == "F":
return("F")
elif statImage == "Z":
return("Z (Gaussianised T/F)")
def format_cluster_stats(g, excName):
# ----------------------------------------------------------------------
# First we gather data for peaks table.
# ----------------------------------------------------------------------
# Run the peak query
peakQueryResult = run_query(g, 'selectPeakData', 'Select',
{'EXC_NAME': excName})
# Retrieve query results.
peakZstats = [float(peakQueryResult[i]) for i in list(range(0, len(
peakQueryResult), 5))]
clusterIndicesForPeaks = [int(peakQueryResult[i]) for i in list(range(
1, len(peakQueryResult), 5))]
locations = [peakQueryResult[i] for i in list(range(2, len(
peakQueryResult), 5))]
# If a corrected height threshold has been applied we should display
# corrected peak P values. Else we should use uncorrected peak P values.
try:
if run_query(g, 'askCHeightThreshold', 'Ask'):
peakPVals = [float(peakQueryResult[i]) for i in list(
range(3, len(peakQueryResult), 5))]
else:
peakPVals = [float(peakQueryResult[i]) for i in list(
range(4, len(peakQueryResult), 5))]
# This is a temporary bug fix due to the FSL exporter currently not
# recording corrected peak P-values.
except ValueError:
peakPVals = [math.nan for row in peakQueryResult]
# Obtain permutation used to sort the results in order of descending
# cluster index and then descending peak statistic size.
peaksSortPermutation = sorted(range(len(clusterIndicesForPeaks)),
reverse=True,
key=lambda k: (clusterIndicesForPeaks[k],
peakZstats[k]))
# Sort all peak data using this permutation.
sortedPeaksZstatsArray = [peakZstats[i] for i in peaksSortPermutation]
sortedClusIndicesForPeaks = [
clusterIndicesForPeaks[i] for i in peaksSortPermutation]
sortedPeakLocations = [locations[i] for i in peaksSortPermutation]
sortedPeakPVals = [peakPVals[i] for i in peaksSortPermutation]
# ----------------------------------------------------------------------
# Second we gather data for cluster table.
# ----------------------------------------------------------------------
# Run the cluster query
clusQueryResult = run_query(g, 'selectClusterData', 'Select',
{'EXC_NAME': excName})
clusterIndices = [
int(clusQueryResult[i]) for i in list(
range(0, len(clusQueryResult), 3))]
clusterSizes = [
int(clusQueryResult[i]) for i in list(
range(1, len(clusQueryResult), 3))]
clusterPVals = [
float(clusQueryResult[i]) for i in list(
range(2, len(clusQueryResult), 3))]
# Create an array for the highest peaks.
highestPeakZArray = [0]*len(clusterIndices)
highestPeakLocations = [0]*len(clusterIndices)
for i in list(range(0, len(peakZstats))):
if highestPeakZArray[clusterIndicesForPeaks[i]-1] < peakZstats[i]:
highestPeakZArray[clusterIndicesForPeaks[i]-1] = peakZstats[i]
highestPeakLocations[clusterIndicesForPeaks[i]-1] = locations[i]
# Obtain permutation used to sort the results in order of descending
# cluster index and then for each cluster by peak statistic size.
clusterSortPermutation = sorted(
range(len(clusterIndices)),
reverse=True,
key=lambda k: (clusterSizes[k], clusterIndices[k]))
# Sorted cluster arrays
sortedClusSizeArray = [
clusterSizes[i] for i in clusterSortPermutation]
sortedClusIndicesArray = [
clusterIndices[i] for i in clusterSortPermutation]
sortedClusPVals = [
clusterPVals[i] for i in clusterSortPermutation]
# Sort the highest peaks
sortedMaxPeakZstats = [
highestPeakZArray[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
sortedMaxPeakLocations = [
highestPeakLocations[
sortedClusIndicesArray[i]-1] for i in list(
range(0, len(clusterIndices)))]
# Deal with inf issues for peaks.
logPeakPVals = [0]*len(sortedPeakPVals)
for i in list(range(0, len(sortedPeakPVals))):
if sortedPeakPVals[i] == 0:
logPeakPVals[i] = math.inf
else:
logPeakPVals[i] = -math.log(sortedPeakPVals[i], 10)
# Deal with inf issues for clusters.
logClusPVals = [0]*len(sortedClusPVals)
for i in list(range(0, len(sortedClusPVals))):
if sortedClusPVals[i] == 0:
logClusPVals[i] = math.inf
else:
logClusPVals[i] = -math.log(sortedClusPVals[i], 10)
# Record the data for display.
clusterData = {}
# If a corrected cluster threshold has been applied we should display
# cluster P values.
if run_query(g, 'askCExtentThreshold', 'Ask'):
clusterData['clusterPValues'] = sortedClusPVals
clusterData['logClusterPValues'] = logClusPVals
clusterData['clusSizes'] = sortedClusSizeArray
clusterData['clusIndices'] = sortedClusIndicesArray
clusterData['clusPeakZstats'] = sortedMaxPeakZstats
clusterData['clusPeakLocations'] = sortedMaxPeakLocations
clusterData['peakZstats'] = sortedPeaksZstatsArray
clusterData['peakClusIndices'] = sortedClusIndicesForPeaks
clusterData['peakLocations'] = sortedPeakLocations
clusterData['peakPVals'] = sortedPeakPVals
clusterData['logPeakPVals'] = logPeakPVals
return(clusterData)
def contrast_vec(data, v_min, v_max):
# This import is needed only in this function.
from matplotlib import pyplot as plt
conLength = len(data)
# We invert the values so the colours appear correctly (i.
# e. 1 -> white, 0 -> black).
data = np.ones(len(data))-data
# Make the contrast vector larger so we can make an image.
data = np.kron(data, np.ones((10, 30)))
# Add border to data.
data[:, 0] = v_max*np.ones(10)
data[:, 30*conLength-1] = v_max*np.ones(10)
data[0, :] = v_max*np.ones(30*conLength)
data[10-1, :] = v_max*np.ones(30*conLength)
# Create figure.
fig = plt.figure(figsize=(len(data), 1))
# Remove axis
ax = fig.add_subplot(1, 1, 1)
plt.axis('off')
# Add contrast vector to figure
plt.imshow(data, aspect='auto', cmap='Greys', vmin=v_min, vmax=v_max)
# Check for bording box.
extent = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
# Save figure (without bording box)
tempFile = 'tempCon' + str(random.randint(0, 999999)) + '.png'
plt.savefig(tempFile, bbox_inches=extent)
# Encode the figure.
encodedIm = encode_image(tempFile)
# Remove the image.
os.remove(tempFile)
# Return the image
return('data:image/jpg;base64,' + encodedIm.decode())
# This function takes in an excursion set name and a graph and generates
# an FSL-like name for the HTML output display for the excursionset.
#
# e.g. ExcursionSet_F001.nii.gz -> cluster_zfstat1_std.html
def get_clus_filename(g, excName):
# For SPM data we can't work out the filename we want from just
# the contrast name.
if run_query(g | statistic_type_string | identifier_name |
message_partition.go | ir,
name: storeName,
mutex: &sync.RWMutex{},
}
return p, p.initialize()
}
func (p *MessagePartition) initialize() error {
p.mutex.Lock()
defer p.mutex.Unlock()
fileList, err := p.scanFiles()
if err != nil {
return err
}
if len(fileList) == 0 {
p.maxMessageId = 0
} else {
var err error
p.maxMessageId, err = p.calculateMaxMessageIdFromIndex(fileList[len(fileList)-1])
if err != nil {
return err
}
}
return nil
}
// returns the max message id for a message file
func (p *MessagePartition) calculateMaxMessageIdFromIndex(fileId uint64) (uint64, error) {
stat, err := os.Stat(p.indexFilenameByMessageId(fileId))
if err != nil {
return 0, err
}
entriesInIndex := uint64(stat.Size() / int64(INDEX_ENTRY_SIZE))
return (entriesInIndex - 1 + fileId), nil
}
// Returns the start messages ids for all available message files
// in a sorted list
func (p *MessagePartition) scanFiles() ([]uint64, error) {
result := []uint64{}
allFiles, err := ioutil.ReadDir(p.basedir)
if err != nil {
return nil, err
}
for _, fileInfo := range allFiles {
if strings.HasPrefix(fileInfo.Name(), p.name+"-") &&
strings.HasSuffix(fileInfo.Name(), ".idx") {
fileIdString := fileInfo.Name()[len(p.name)+1 : len(fileInfo.Name())-4]
if fileId, err := strconv.ParseUint(fileIdString, 10, 64); err == nil {
result = append(result, fileId)
}
}
}
return result, nil
}
func (p *MessagePartition) MaxMessageId() (uint64, error) {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.maxMessageId, nil
}
func (p *MessagePartition) closeAppendFiles() error {
if p.appendFile != nil {
if err := p.appendFile.Close(); err != nil {
if p.appendIndexFile != nil {
defer p.appendIndexFile.Close()
}
return err
}
p.appendFile = nil
}
if p.appendIndexFile != nil {
err := p.appendIndexFile.Close()
p.appendIndexFile = nil
return err
}
return nil
}
func (p *MessagePartition) createNextAppendFiles(msgId uint64) error {
firstMessageIdForFile := p.firstMessageIdForFile(msgId)
file, err := os.OpenFile(p.filenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
return err
}
// write file header on new files
if stat, _ := file.Stat(); stat.Size() == 0 {
p.appendFileWritePosition = uint64(stat.Size())
_, err = file.Write(MAGIC_NUMBER)
if err != nil {
return err
}
_, err = file.Write(FILE_FORMAT_VERSION)
if err != nil {
return err
}
}
index, errIndex := os.OpenFile(p.indexFilenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE, 0666)
if errIndex != nil {
defer file.Close()
defer os.Remove(file.Name())
return err
}
p.appendFile = file
p.appendIndexFile = index
p.appendFirstId = firstMessageIdForFile
p.appendLastId = firstMessageIdForFile + MESSAGES_PER_FILE - 1
stat, err := file.Stat()
p.appendFileWritePosition = uint64(stat.Size())
|
func (p *MessagePartition) Close() error {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.closeAppendFiles()
}
func (p *MessagePartition) DoInTx(fnToExecute func(maxMessageId uint64) error) error {
p.mutex.Lock()
defer p.mutex.Unlock()
return fnToExecute(p.maxMessageId)
}
func (p *MessagePartition) StoreTx(partition string,
callback func(msgId uint64) (msg []byte)) error {
p.mutex.Lock()
defer p.mutex.Unlock()
msgId := p.maxMessageId + 1
return p.store(msgId, callback(msgId))
}
func (p *MessagePartition) Store(msgId uint64, msg []byte) error {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.store(msgId, msg)
}
func (p *MessagePartition) store(msgId uint64, msg []byte) error {
if msgId != 1+p.maxMessageId {
return fmt.Errorf("Invalid message id for partition %v. Next id should be %v, but was %q", p.name, 1+p.maxMessageId, msgId)
}
if msgId > p.appendLastId ||
p.appendFile == nil ||
p.appendIndexFile == nil {
if err := p.closeAppendFiles(); err != nil {
return err
}
if err := p.createNextAppendFiles(msgId); err != nil {
return err
}
}
// write the message size and the message id 32bit and 64 bit
sizeAndId := make([]byte, 12)
binary.LittleEndian.PutUint32(sizeAndId, uint32(len(msg)))
binary.LittleEndian.PutUint64(sizeAndId[4:], msgId)
if _, err := p.appendFile.Write(sizeAndId); err != nil {
return err
}
// write the message
if _, err := p.appendFile.Write(msg); err != nil {
return err
}
// write the index entry to the index file
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (msgId % MESSAGES_PER_FILE))
messageOffset := p.appendFileWritePosition + uint64(len(sizeAndId))
messageOffsetBuff := make([]byte, INDEX_ENTRY_SIZE)
binary.LittleEndian.PutUint64(messageOffsetBuff, messageOffset)
binary.LittleEndian.PutUint32(messageOffsetBuff[8:], uint32(len(msg)))
if _, err := p.appendIndexFile.WriteAt(messageOffsetBuff, indexPosition); err != nil {
return err
}
p.appendFileWritePosition += uint64(len(sizeAndId) + len(msg))
p.maxMessageId = msgId
return nil
}
// fetch a set of messages
func (p *MessagePartition) Fetch(req FetchRequest) {
go func() {
fetchList, err := p.calculateFetchList(req)
if err != nil {
req.ErrorCallback <- err
return
}
req.StartCallback <- len(fetchList)
err = p.fetchByFetchlist(fetchList, req.MessageC)
if err != nil {
req.ErrorCallback <- err
return
}
close(req.MessageC)
}()
}
// fetch the messages in the supplied fetchlist and send them to the channel
func (p *MessagePartition) fetchByFetchlist(fetchList []fetchEntry, messageC chan MessageAndId) error {
var fileId uint64
var file *os.File
var err error
var lastMsgId uint64
for _, f := range fetchList {
if lastMsgId == 0 {
lastMsgId = f.messageId - 1
}
lastMsgId = f.messageId
// ensure, that we read on the correct file
if file == nil || fileId != f.fileId {
file, err = p.checkoutMessagefile(f.fileId)
if err != nil {
return err
}
defer p.releaseMessagefile(f.fileId, file)
fileId = f.fileId
}
msg := make([]byte, f.size, f.size)
_, err = file.ReadAt(msg, f.offset)
if err != nil {
return err
}
messageC <- MessageAndId{f.messageId, msg}
}
return nil
}
// returns a list of fetchEntry records for all message in the fetch request.
func (p *MessagePartition) calculateFetchList(req FetchRequest) ([]fetchEntry, error) {
if req.Direction == 0 {
req.Direction = 1
}
nextId := req.StartId
initialCap := req.Count
if initialCap > 100 {
initialCap = 100
}
result := make([]fetchEntry, 0, initialCap)
var file *os.File
var fileId uint64
for len(result) < req.Count && nextId >= 0 {
nextFileId := p.firstMessageIdForFile(nextId)
// ensure, that we read on the correct file
if file == nil || nextFileId != fileId {
var err error
file, err = p.checkoutIndexfile(nextFileId)
if err != nil {
if os.IsNotExist(err) {
return result, nil
}
return nil, err
}
defer p.releaseIndexfile(fileId, file)
fileId = nextFileId
}
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (nextId % MESSAGES_PER_FILE))
msgOffset, msgSize, err := | return nil
} | random_line_split |
message_partition.go | message file
func (p *MessagePartition) calculateMaxMessageIdFromIndex(fileId uint64) (uint64, error) {
stat, err := os.Stat(p.indexFilenameByMessageId(fileId))
if err != nil {
return 0, err
}
entriesInIndex := uint64(stat.Size() / int64(INDEX_ENTRY_SIZE))
return (entriesInIndex - 1 + fileId), nil
}
// Returns the start messages ids for all available message files
// in a sorted list
func (p *MessagePartition) scanFiles() ([]uint64, error) {
result := []uint64{}
allFiles, err := ioutil.ReadDir(p.basedir)
if err != nil {
return nil, err
}
for _, fileInfo := range allFiles {
if strings.HasPrefix(fileInfo.Name(), p.name+"-") &&
strings.HasSuffix(fileInfo.Name(), ".idx") {
fileIdString := fileInfo.Name()[len(p.name)+1 : len(fileInfo.Name())-4]
if fileId, err := strconv.ParseUint(fileIdString, 10, 64); err == nil {
result = append(result, fileId)
}
}
}
return result, nil
}
func (p *MessagePartition) MaxMessageId() (uint64, error) {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.maxMessageId, nil
}
func (p *MessagePartition) closeAppendFiles() error {
if p.appendFile != nil {
if err := p.appendFile.Close(); err != nil {
if p.appendIndexFile != nil {
defer p.appendIndexFile.Close()
}
return err
}
p.appendFile = nil
}
if p.appendIndexFile != nil {
err := p.appendIndexFile.Close()
p.appendIndexFile = nil
return err
}
return nil
}
func (p *MessagePartition) createNextAppendFiles(msgId uint64) error {
firstMessageIdForFile := p.firstMessageIdForFile(msgId)
file, err := os.OpenFile(p.filenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
return err
}
// write file header on new files
if stat, _ := file.Stat(); stat.Size() == 0 {
p.appendFileWritePosition = uint64(stat.Size())
_, err = file.Write(MAGIC_NUMBER)
if err != nil {
return err
}
_, err = file.Write(FILE_FORMAT_VERSION)
if err != nil {
return err
}
}
index, errIndex := os.OpenFile(p.indexFilenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE, 0666)
if errIndex != nil {
defer file.Close()
defer os.Remove(file.Name())
return err
}
p.appendFile = file
p.appendIndexFile = index
p.appendFirstId = firstMessageIdForFile
p.appendLastId = firstMessageIdForFile + MESSAGES_PER_FILE - 1
stat, err := file.Stat()
p.appendFileWritePosition = uint64(stat.Size())
return nil
}
func (p *MessagePartition) Close() error {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.closeAppendFiles()
}
func (p *MessagePartition) DoInTx(fnToExecute func(maxMessageId uint64) error) error {
p.mutex.Lock()
defer p.mutex.Unlock()
return fnToExecute(p.maxMessageId)
}
func (p *MessagePartition) StoreTx(partition string,
callback func(msgId uint64) (msg []byte)) error {
p.mutex.Lock()
defer p.mutex.Unlock()
msgId := p.maxMessageId + 1
return p.store(msgId, callback(msgId))
}
func (p *MessagePartition) Store(msgId uint64, msg []byte) error {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.store(msgId, msg)
}
func (p *MessagePartition) store(msgId uint64, msg []byte) error {
if msgId != 1+p.maxMessageId {
return fmt.Errorf("Invalid message id for partition %v. Next id should be %v, but was %q", p.name, 1+p.maxMessageId, msgId)
}
if msgId > p.appendLastId ||
p.appendFile == nil ||
p.appendIndexFile == nil {
if err := p.closeAppendFiles(); err != nil {
return err
}
if err := p.createNextAppendFiles(msgId); err != nil {
return err
}
}
// write the message size and the message id 32bit and 64 bit
sizeAndId := make([]byte, 12)
binary.LittleEndian.PutUint32(sizeAndId, uint32(len(msg)))
binary.LittleEndian.PutUint64(sizeAndId[4:], msgId)
if _, err := p.appendFile.Write(sizeAndId); err != nil {
return err
}
// write the message
if _, err := p.appendFile.Write(msg); err != nil {
return err
}
// write the index entry to the index file
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (msgId % MESSAGES_PER_FILE))
messageOffset := p.appendFileWritePosition + uint64(len(sizeAndId))
messageOffsetBuff := make([]byte, INDEX_ENTRY_SIZE)
binary.LittleEndian.PutUint64(messageOffsetBuff, messageOffset)
binary.LittleEndian.PutUint32(messageOffsetBuff[8:], uint32(len(msg)))
if _, err := p.appendIndexFile.WriteAt(messageOffsetBuff, indexPosition); err != nil {
return err
}
p.appendFileWritePosition += uint64(len(sizeAndId) + len(msg))
p.maxMessageId = msgId
return nil
}
// fetch a set of messages
func (p *MessagePartition) Fetch(req FetchRequest) {
go func() {
fetchList, err := p.calculateFetchList(req)
if err != nil {
req.ErrorCallback <- err
return
}
req.StartCallback <- len(fetchList)
err = p.fetchByFetchlist(fetchList, req.MessageC)
if err != nil {
req.ErrorCallback <- err
return
}
close(req.MessageC)
}()
}
// fetch the messages in the supplied fetchlist and send them to the channel
func (p *MessagePartition) fetchByFetchlist(fetchList []fetchEntry, messageC chan MessageAndId) error {
var fileId uint64
var file *os.File
var err error
var lastMsgId uint64
for _, f := range fetchList {
if lastMsgId == 0 {
lastMsgId = f.messageId - 1
}
lastMsgId = f.messageId
// ensure, that we read on the correct file
if file == nil || fileId != f.fileId {
file, err = p.checkoutMessagefile(f.fileId)
if err != nil {
return err
}
defer p.releaseMessagefile(f.fileId, file)
fileId = f.fileId
}
msg := make([]byte, f.size, f.size)
_, err = file.ReadAt(msg, f.offset)
if err != nil {
return err
}
messageC <- MessageAndId{f.messageId, msg}
}
return nil
}
// returns a list of fetchEntry records for all message in the fetch request.
func (p *MessagePartition) calculateFetchList(req FetchRequest) ([]fetchEntry, error) {
if req.Direction == 0 {
req.Direction = 1
}
nextId := req.StartId
initialCap := req.Count
if initialCap > 100 {
initialCap = 100
}
result := make([]fetchEntry, 0, initialCap)
var file *os.File
var fileId uint64
for len(result) < req.Count && nextId >= 0 {
nextFileId := p.firstMessageIdForFile(nextId)
// ensure, that we read on the correct file
if file == nil || nextFileId != fileId {
var err error
file, err = p.checkoutIndexfile(nextFileId)
if err != nil {
if os.IsNotExist(err) {
return result, nil
}
return nil, err
}
defer p.releaseIndexfile(fileId, file)
fileId = nextFileId
}
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (nextId % MESSAGES_PER_FILE))
msgOffset, msgSize, err := readIndexEntry(file, indexPosition)
if err != nil {
if err.Error() == "EOF" {
return result, nil // we reached the end of the index
} else {
return nil, err
}
}
if msgOffset != uint64(0) { // only append, if the message exists
result = append(result, fetchEntry{
messageId: nextId,
fileId: fileId,
offset: int64(msgOffset),
size: int(msgSize),
})
}
nextId += uint64(req.Direction)
}
return result, nil
}
func | readIndexEntry | identifier_name |
|
message_partition.go | ,
name: storeName,
mutex: &sync.RWMutex{},
}
return p, p.initialize()
}
func (p *MessagePartition) initialize() error {
p.mutex.Lock()
defer p.mutex.Unlock()
fileList, err := p.scanFiles()
if err != nil {
return err
}
if len(fileList) == 0 {
p.maxMessageId = 0
} else {
var err error
p.maxMessageId, err = p.calculateMaxMessageIdFromIndex(fileList[len(fileList)-1])
if err != nil {
return err
}
}
return nil
}
// returns the max message id for a message file
func (p *MessagePartition) calculateMaxMessageIdFromIndex(fileId uint64) (uint64, error) {
stat, err := os.Stat(p.indexFilenameByMessageId(fileId))
if err != nil {
return 0, err
}
entriesInIndex := uint64(stat.Size() / int64(INDEX_ENTRY_SIZE))
return (entriesInIndex - 1 + fileId), nil
}
// Returns the start messages ids for all available message files
// in a sorted list
func (p *MessagePartition) scanFiles() ([]uint64, error) {
result := []uint64{}
allFiles, err := ioutil.ReadDir(p.basedir)
if err != nil {
return nil, err
}
for _, fileInfo := range allFiles {
if strings.HasPrefix(fileInfo.Name(), p.name+"-") &&
strings.HasSuffix(fileInfo.Name(), ".idx") {
fileIdString := fileInfo.Name()[len(p.name)+1 : len(fileInfo.Name())-4]
if fileId, err := strconv.ParseUint(fileIdString, 10, 64); err == nil {
result = append(result, fileId)
}
}
}
return result, nil
}
func (p *MessagePartition) MaxMessageId() (uint64, error) {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.maxMessageId, nil
}
func (p *MessagePartition) closeAppendFiles() error {
if p.appendFile != nil {
if err := p.appendFile.Close(); err != nil {
if p.appendIndexFile != nil {
defer p.appendIndexFile.Close()
}
return err
}
p.appendFile = nil
}
if p.appendIndexFile != nil {
err := p.appendIndexFile.Close()
p.appendIndexFile = nil
return err
}
return nil
}
func (p *MessagePartition) createNextAppendFiles(msgId uint64) error {
firstMessageIdForFile := p.firstMessageIdForFile(msgId)
file, err := os.OpenFile(p.filenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
return err
}
// write file header on new files
if stat, _ := file.Stat(); stat.Size() == 0 |
index, errIndex := os.OpenFile(p.indexFilenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE, 0666)
if errIndex != nil {
defer file.Close()
defer os.Remove(file.Name())
return err
}
p.appendFile = file
p.appendIndexFile = index
p.appendFirstId = firstMessageIdForFile
p.appendLastId = firstMessageIdForFile + MESSAGES_PER_FILE - 1
stat, err := file.Stat()
p.appendFileWritePosition = uint64(stat.Size())
return nil
}
func (p *MessagePartition) Close() error {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.closeAppendFiles()
}
func (p *MessagePartition) DoInTx(fnToExecute func(maxMessageId uint64) error) error {
p.mutex.Lock()
defer p.mutex.Unlock()
return fnToExecute(p.maxMessageId)
}
func (p *MessagePartition) StoreTx(partition string,
callback func(msgId uint64) (msg []byte)) error {
p.mutex.Lock()
defer p.mutex.Unlock()
msgId := p.maxMessageId + 1
return p.store(msgId, callback(msgId))
}
func (p *MessagePartition) Store(msgId uint64, msg []byte) error {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.store(msgId, msg)
}
func (p *MessagePartition) store(msgId uint64, msg []byte) error {
if msgId != 1+p.maxMessageId {
return fmt.Errorf("Invalid message id for partition %v. Next id should be %v, but was %q", p.name, 1+p.maxMessageId, msgId)
}
if msgId > p.appendLastId ||
p.appendFile == nil ||
p.appendIndexFile == nil {
if err := p.closeAppendFiles(); err != nil {
return err
}
if err := p.createNextAppendFiles(msgId); err != nil {
return err
}
}
// write the message size and the message id 32bit and 64 bit
sizeAndId := make([]byte, 12)
binary.LittleEndian.PutUint32(sizeAndId, uint32(len(msg)))
binary.LittleEndian.PutUint64(sizeAndId[4:], msgId)
if _, err := p.appendFile.Write(sizeAndId); err != nil {
return err
}
// write the message
if _, err := p.appendFile.Write(msg); err != nil {
return err
}
// write the index entry to the index file
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (msgId % MESSAGES_PER_FILE))
messageOffset := p.appendFileWritePosition + uint64(len(sizeAndId))
messageOffsetBuff := make([]byte, INDEX_ENTRY_SIZE)
binary.LittleEndian.PutUint64(messageOffsetBuff, messageOffset)
binary.LittleEndian.PutUint32(messageOffsetBuff[8:], uint32(len(msg)))
if _, err := p.appendIndexFile.WriteAt(messageOffsetBuff, indexPosition); err != nil {
return err
}
p.appendFileWritePosition += uint64(len(sizeAndId) + len(msg))
p.maxMessageId = msgId
return nil
}
// fetch a set of messages
func (p *MessagePartition) Fetch(req FetchRequest) {
go func() {
fetchList, err := p.calculateFetchList(req)
if err != nil {
req.ErrorCallback <- err
return
}
req.StartCallback <- len(fetchList)
err = p.fetchByFetchlist(fetchList, req.MessageC)
if err != nil {
req.ErrorCallback <- err
return
}
close(req.MessageC)
}()
}
// fetch the messages in the supplied fetchlist and send them to the channel
func (p *MessagePartition) fetchByFetchlist(fetchList []fetchEntry, messageC chan MessageAndId) error {
var fileId uint64
var file *os.File
var err error
var lastMsgId uint64
for _, f := range fetchList {
if lastMsgId == 0 {
lastMsgId = f.messageId - 1
}
lastMsgId = f.messageId
// ensure, that we read on the correct file
if file == nil || fileId != f.fileId {
file, err = p.checkoutMessagefile(f.fileId)
if err != nil {
return err
}
defer p.releaseMessagefile(f.fileId, file)
fileId = f.fileId
}
msg := make([]byte, f.size, f.size)
_, err = file.ReadAt(msg, f.offset)
if err != nil {
return err
}
messageC <- MessageAndId{f.messageId, msg}
}
return nil
}
// returns a list of fetchEntry records for all message in the fetch request.
func (p *MessagePartition) calculateFetchList(req FetchRequest) ([]fetchEntry, error) {
if req.Direction == 0 {
req.Direction = 1
}
nextId := req.StartId
initialCap := req.Count
if initialCap > 100 {
initialCap = 100
}
result := make([]fetchEntry, 0, initialCap)
var file *os.File
var fileId uint64
for len(result) < req.Count && nextId >= 0 {
nextFileId := p.firstMessageIdForFile(nextId)
// ensure, that we read on the correct file
if file == nil || nextFileId != fileId {
var err error
file, err = p.checkoutIndexfile(nextFileId)
if err != nil {
if os.IsNotExist(err) {
return result, nil
}
return nil, err
}
defer p.releaseIndexfile(fileId, file)
fileId = nextFileId
}
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (nextId % MESSAGES_PER_FILE))
msgOffset, msgSize, err := | {
p.appendFileWritePosition = uint64(stat.Size())
_, err = file.Write(MAGIC_NUMBER)
if err != nil {
return err
}
_, err = file.Write(FILE_FORMAT_VERSION)
if err != nil {
return err
}
} | conditional_block |
message_partition.go | ,
name: storeName,
mutex: &sync.RWMutex{},
}
return p, p.initialize()
}
func (p *MessagePartition) initialize() error {
p.mutex.Lock()
defer p.mutex.Unlock()
fileList, err := p.scanFiles()
if err != nil {
return err
}
if len(fileList) == 0 {
p.maxMessageId = 0
} else {
var err error
p.maxMessageId, err = p.calculateMaxMessageIdFromIndex(fileList[len(fileList)-1])
if err != nil {
return err
}
}
return nil
}
// returns the max message id for a message file
func (p *MessagePartition) calculateMaxMessageIdFromIndex(fileId uint64) (uint64, error) {
stat, err := os.Stat(p.indexFilenameByMessageId(fileId))
if err != nil {
return 0, err
}
entriesInIndex := uint64(stat.Size() / int64(INDEX_ENTRY_SIZE))
return (entriesInIndex - 1 + fileId), nil
}
// Returns the start messages ids for all available message files
// in a sorted list
func (p *MessagePartition) scanFiles() ([]uint64, error) {
result := []uint64{}
allFiles, err := ioutil.ReadDir(p.basedir)
if err != nil {
return nil, err
}
for _, fileInfo := range allFiles {
if strings.HasPrefix(fileInfo.Name(), p.name+"-") &&
strings.HasSuffix(fileInfo.Name(), ".idx") {
fileIdString := fileInfo.Name()[len(p.name)+1 : len(fileInfo.Name())-4]
if fileId, err := strconv.ParseUint(fileIdString, 10, 64); err == nil {
result = append(result, fileId)
}
}
}
return result, nil
}
func (p *MessagePartition) MaxMessageId() (uint64, error) {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.maxMessageId, nil
}
func (p *MessagePartition) closeAppendFiles() error {
if p.appendFile != nil {
if err := p.appendFile.Close(); err != nil {
if p.appendIndexFile != nil {
defer p.appendIndexFile.Close()
}
return err
}
p.appendFile = nil
}
if p.appendIndexFile != nil {
err := p.appendIndexFile.Close()
p.appendIndexFile = nil
return err
}
return nil
}
func (p *MessagePartition) createNextAppendFiles(msgId uint64) error {
firstMessageIdForFile := p.firstMessageIdForFile(msgId)
file, err := os.OpenFile(p.filenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
return err
}
// write file header on new files
if stat, _ := file.Stat(); stat.Size() == 0 {
p.appendFileWritePosition = uint64(stat.Size())
_, err = file.Write(MAGIC_NUMBER)
if err != nil {
return err
}
_, err = file.Write(FILE_FORMAT_VERSION)
if err != nil {
return err
}
}
index, errIndex := os.OpenFile(p.indexFilenameByMessageId(firstMessageIdForFile), os.O_RDWR|os.O_CREATE, 0666)
if errIndex != nil {
defer file.Close()
defer os.Remove(file.Name())
return err
}
p.appendFile = file
p.appendIndexFile = index
p.appendFirstId = firstMessageIdForFile
p.appendLastId = firstMessageIdForFile + MESSAGES_PER_FILE - 1
stat, err := file.Stat()
p.appendFileWritePosition = uint64(stat.Size())
return nil
}
func (p *MessagePartition) Close() error {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.closeAppendFiles()
}
func (p *MessagePartition) DoInTx(fnToExecute func(maxMessageId uint64) error) error {
p.mutex.Lock()
defer p.mutex.Unlock()
return fnToExecute(p.maxMessageId)
}
func (p *MessagePartition) StoreTx(partition string,
callback func(msgId uint64) (msg []byte)) error {
p.mutex.Lock()
defer p.mutex.Unlock()
msgId := p.maxMessageId + 1
return p.store(msgId, callback(msgId))
}
func (p *MessagePartition) Store(msgId uint64, msg []byte) error |
func (p *MessagePartition) store(msgId uint64, msg []byte) error {
if msgId != 1+p.maxMessageId {
return fmt.Errorf("Invalid message id for partition %v. Next id should be %v, but was %q", p.name, 1+p.maxMessageId, msgId)
}
if msgId > p.appendLastId ||
p.appendFile == nil ||
p.appendIndexFile == nil {
if err := p.closeAppendFiles(); err != nil {
return err
}
if err := p.createNextAppendFiles(msgId); err != nil {
return err
}
}
// write the message size and the message id 32bit and 64 bit
sizeAndId := make([]byte, 12)
binary.LittleEndian.PutUint32(sizeAndId, uint32(len(msg)))
binary.LittleEndian.PutUint64(sizeAndId[4:], msgId)
if _, err := p.appendFile.Write(sizeAndId); err != nil {
return err
}
// write the message
if _, err := p.appendFile.Write(msg); err != nil {
return err
}
// write the index entry to the index file
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (msgId % MESSAGES_PER_FILE))
messageOffset := p.appendFileWritePosition + uint64(len(sizeAndId))
messageOffsetBuff := make([]byte, INDEX_ENTRY_SIZE)
binary.LittleEndian.PutUint64(messageOffsetBuff, messageOffset)
binary.LittleEndian.PutUint32(messageOffsetBuff[8:], uint32(len(msg)))
if _, err := p.appendIndexFile.WriteAt(messageOffsetBuff, indexPosition); err != nil {
return err
}
p.appendFileWritePosition += uint64(len(sizeAndId) + len(msg))
p.maxMessageId = msgId
return nil
}
// fetch a set of messages
func (p *MessagePartition) Fetch(req FetchRequest) {
go func() {
fetchList, err := p.calculateFetchList(req)
if err != nil {
req.ErrorCallback <- err
return
}
req.StartCallback <- len(fetchList)
err = p.fetchByFetchlist(fetchList, req.MessageC)
if err != nil {
req.ErrorCallback <- err
return
}
close(req.MessageC)
}()
}
// fetch the messages in the supplied fetchlist and send them to the channel
func (p *MessagePartition) fetchByFetchlist(fetchList []fetchEntry, messageC chan MessageAndId) error {
var fileId uint64
var file *os.File
var err error
var lastMsgId uint64
for _, f := range fetchList {
if lastMsgId == 0 {
lastMsgId = f.messageId - 1
}
lastMsgId = f.messageId
// ensure, that we read on the correct file
if file == nil || fileId != f.fileId {
file, err = p.checkoutMessagefile(f.fileId)
if err != nil {
return err
}
defer p.releaseMessagefile(f.fileId, file)
fileId = f.fileId
}
msg := make([]byte, f.size, f.size)
_, err = file.ReadAt(msg, f.offset)
if err != nil {
return err
}
messageC <- MessageAndId{f.messageId, msg}
}
return nil
}
// returns a list of fetchEntry records for all message in the fetch request.
func (p *MessagePartition) calculateFetchList(req FetchRequest) ([]fetchEntry, error) {
if req.Direction == 0 {
req.Direction = 1
}
nextId := req.StartId
initialCap := req.Count
if initialCap > 100 {
initialCap = 100
}
result := make([]fetchEntry, 0, initialCap)
var file *os.File
var fileId uint64
for len(result) < req.Count && nextId >= 0 {
nextFileId := p.firstMessageIdForFile(nextId)
// ensure, that we read on the correct file
if file == nil || nextFileId != fileId {
var err error
file, err = p.checkoutIndexfile(nextFileId)
if err != nil {
if os.IsNotExist(err) {
return result, nil
}
return nil, err
}
defer p.releaseIndexfile(fileId, file)
fileId = nextFileId
}
indexPosition := int64(uint64(INDEX_ENTRY_SIZE) * (nextId % MESSAGES_PER_FILE))
msgOffset, msgSize, err := | {
p.mutex.Lock()
defer p.mutex.Unlock()
return p.store(msgId, msg)
} | identifier_body |
credential.rs | Data {
// id, name, url
pub rp: ctap_types::webauthn::PublicKeyCredentialRpEntity,
// id, icon, name, display_name
pub user: ctap_types::webauthn::PublicKeyCredentialUserEntity,
// can be just a counter, need to be able to determine "latest"
pub creation_time: u32,
// for stateless deterministic keys, it seems CTAP2 (but not CTAP1) makes signature counters optional
use_counter: bool,
// P256 or Ed25519
pub algorithm: i32,
// for RK in non-deterministic mode: refers to actual key
// TODO(implement enums in cbor-deser): for all others, is a wrapped key
// --> use above Key enum
// #[serde(skip_serializing_if = "Option::is_none")]
// key_id: Option<KeyId>,
pub key: Key,
// extensions
#[serde(skip_serializing_if = "Option::is_none")]
pub hmac_secret: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cred_protect: Option<CredentialProtectionPolicy>,
// TODO: add `sig_counter: Option<CounterId>`,
// and grant RKs a per-credential sig-counter.
}
// TODO: figure out sizes
// We may or may not follow https://github.com/satoshilabs/slips/blob/master/slip-0022.md
/// The core structure this authenticator creates and uses.
#[derive(Clone, Debug, serde_indexed::DeserializeIndexed, serde_indexed::SerializeIndexed)]
pub struct Credential {
ctap: CtapVersion,
pub data: CredentialData,
nonce: Bytes<12>,
}
// Alas... it would be more symmetrical to have Credential { meta, data },
// but let's not break binary compatibility for this.
//
// struct Metadata {
// ctap: CtapVersion,
// nonce: Bytes<12>,
// }
impl core::ops::Deref for Credential {
type Target = CredentialData;
fn deref(&self) -> &Self::Target {
&self.data
}
}
/// Compare credentials based on key + timestamp.
///
/// Likely comparison based on timestamp would be good enough?
impl PartialEq for Credential {
fn eq(&self, other: &Self) -> bool {
(self.creation_time == other.creation_time) && (self.key == other.key)
}
}
impl PartialEq<&Credential> for Credential {
fn eq(&self, other: &&Self) -> bool {
self == *other
}
}
impl Eq for Credential {}
impl Ord for Credential {
fn cmp(&self, other: &Self) -> Ordering {
self.data.creation_time.cmp(&other.data.creation_time)
}
}
/// Order by timestamp of creation.
impl PartialOrd for Credential {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl PartialOrd<&Credential> for Credential {
fn partial_cmp(&self, other: &&Self) -> Option<Ordering> {
Some(self.cmp(*other))
}
}
// Bad idea - huge stack
// pub(crate) type CredentialList = Vec<Credential, {ctap_types::sizes::MAX_CREDENTIAL_COUNT_IN_LIST}>;
impl From<CredentialId> for PublicKeyCredentialDescriptor {
fn from(id: CredentialId) -> PublicKeyCredentialDescriptor {
PublicKeyCredentialDescriptor {
id: id.0,
key_type: {
let mut key_type = String::new();
key_type.push_str("public-key").unwrap();
key_type
},
}
}
}
impl Credential {
#[allow(clippy::too_many_arguments)]
pub fn new(
ctap: CtapVersion,
// parameters: &ctap2::make_credential::Parameters,
rp: &ctap_types::webauthn::PublicKeyCredentialRpEntity,
user: &ctap_types::webauthn::PublicKeyCredentialUserEntity,
algorithm: i32,
key: Key,
timestamp: u32,
hmac_secret: Option<bool>,
cred_protect: Option<CredentialProtectionPolicy>,
nonce: [u8; 12],
) -> Self {
info!("credential for algorithm {}", algorithm);
let data = CredentialData {
rp: rp.clone(),
user: user.clone(),
creation_time: timestamp,
use_counter: true,
algorithm,
key,
hmac_secret,
cred_protect,
};
Credential {
ctap,
data,
nonce: Bytes::from_slice(&nonce).unwrap(),
}
}
// ID (or "keyhandle") for the credential.
//
// Originally, the entire data was serialized, and its encryption
// (binding RP as associated data) used as a keyhandle.
//
// However, this leads to problems with relying parties. According to the old U2F
// spec, the length of a keyhandle is encoded as one byte, whereas this procedure would
// generate keyhandles of length ~320 bytes.
//
// Therefore, inessential metadata is stripped before serialization, ensuring
// the ID will stay below 255 bytes.
//
// Existing keyhandles can still be decoded
pub fn id<T: client::Chacha8Poly1305 + client::Sha256>(
&self,
trussed: &mut T,
key_encryption_key: KeyId,
rp_id_hash: Option<&Bytes<32>>,
) -> Result<CredentialId> {
let serialized_credential = self.strip().serialize()?;
let message = &serialized_credential;
// info!("serialized cred = {:?}", message).ok();
let rp_id_hash: Bytes<32> = if let Some(hash) = rp_id_hash {
hash.clone()
} else {
syscall!(trussed.hash_sha256(self.rp.id.as_ref()))
.hash
.to_bytes()
.map_err(|_| Error::Other)?
};
let associated_data = &rp_id_hash[..];
let nonce: [u8; 12] = self.nonce.as_slice().try_into().unwrap();
let encrypted_serialized_credential = EncryptedSerializedCredential(syscall!(trussed
.encrypt_chacha8poly1305(key_encryption_key, message, associated_data, Some(&nonce))));
let credential_id: CredentialId = encrypted_serialized_credential
.try_into()
.map_err(|_| Error::RequestTooLarge)?;
Ok(credential_id)
}
pub fn serialize(&self) -> Result<SerializedCredential> {
trussed::cbor_serialize_bytes(self).map_err(|_| Error::Other)
}
pub fn deserialize(bytes: &SerializedCredential) -> Result<Self> {
match ctap_types::serde::cbor_deserialize(bytes) {
Ok(s) => Ok(s),
Err(_) => {
info_now!("could not deserialize {:?}", bytes);
Err(Error::Other)
}
}
}
pub fn try_from<UP: UserPresence, T: client::Client + client::Chacha8Poly1305>(
authnr: &mut Authenticator<UP, T>,
rp_id_hash: &Bytes<32>,
descriptor: &PublicKeyCredentialDescriptor,
) -> Result<Self> {
Self::try_from_bytes(authnr, rp_id_hash, &descriptor.id)
}
pub fn | <UP: UserPresence, T: client::Client + client::Chacha8Poly1305>(
authnr: &mut Authenticator<UP, T>,
rp_id_hash: &Bytes<32>,
id: &[u8],
) -> Result<Self> {
let mut cred: Bytes<MAX_CREDENTIAL_ID_LENGTH> = Bytes::new();
cred.extend_from_slice(id)
.map_err(|_| Error::InvalidCredential)?;
let encrypted_serialized = EncryptedSerializedCredential::try_from(CredentialId(cred))?;
let kek = authnr
.state
.persistent
.key_encryption_key(&mut authnr.trussed)?;
let serialized = try_syscall!(authnr.trussed.decrypt_chacha8poly1305(
// TODO: use RpId as associated data here?
kek,
&encrypted_serialized.0.ciphertext,
&rp_id_hash[..],
&encrypted_serialized.0.nonce,
&encrypted_serialized.0.tag,
))
.map_err(|_| Error::InvalidCredential)?
.plaintext
.ok_or(Error::InvalidCredential)?;
let credential =
Credential::deserialize(&serialized).map_err(|_| Error::InvalidCredential)?;
Ok(credential)
}
// Remove inessential metadata from credential.
//
// Called by the `id` method, see its documentation.
pub fn strip(&self) -> Self {
info_now!(":: stripping ID");
let mut stripped = self.clone();
let data = &mut stripped.data;
data.rp.name = None;
data.rp.icon = None;
data.user.icon = None;
data.user.name = None;
data.user.display_name = None;
// data.hmac_secret = None;
// data.cred_protect = None;
stripped
}
}
#[cfg(test)]
mod test {
use super::*;
fn credential_data() -> CredentialData {
use ctap_types::webauthn::{ | try_from_bytes | identifier_name |
credential.rs | #[derive(Copy, Clone, Debug, serde::Deserialize, serde::Serialize)]
pub enum CtapVersion {
U2fV2,
Fido20,
Fido21Pre,
}
/// External ID of a credential, commonly known as "keyhandle".
#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
pub struct CredentialId(pub Bytes<MAX_CREDENTIAL_ID_LENGTH>);
// TODO: how to determine necessary size?
// pub type SerializedCredential = Bytes<512>;
// pub type SerializedCredential = Bytes<256>;
pub(crate) type SerializedCredential = trussed::types::Message;
#[derive(Clone, Debug)]
struct EncryptedSerializedCredential(pub trussed::api::reply::Encrypt);
impl TryFrom<EncryptedSerializedCredential> for CredentialId {
type Error = Error;
fn try_from(esc: EncryptedSerializedCredential) -> Result<CredentialId> {
Ok(CredentialId(
trussed::cbor_serialize_bytes(&esc.0).map_err(|_| Error::Other)?,
))
}
}
impl TryFrom<CredentialId> for EncryptedSerializedCredential {
// tag = 16B
// nonce = 12B
type Error = Error;
fn try_from(cid: CredentialId) -> Result<EncryptedSerializedCredential> {
let encrypted_serialized_credential = EncryptedSerializedCredential(
ctap_types::serde::cbor_deserialize(&cid.0).map_err(|_| Error::InvalidCredential)?,
);
Ok(encrypted_serialized_credential)
}
}
/// Credential keys can either be "discoverable" or not.
///
/// The FIDO Alliance likes to refer to "resident keys" as "(client-side) discoverable public key
/// credential sources" now ;)
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub enum Key {
ResidentKey(KeyId),
// THIS USED TO BE 92 NOW IT'S 96 or 97 or so... waddup?
WrappedKey(Bytes<128>),
}
/// The main content of a `Credential`.
#[derive(
Clone, Debug, PartialEq, serde_indexed::DeserializeIndexed, serde_indexed::SerializeIndexed,
)]
pub struct CredentialData {
// id, name, url
pub rp: ctap_types::webauthn::PublicKeyCredentialRpEntity,
// id, icon, name, display_name
pub user: ctap_types::webauthn::PublicKeyCredentialUserEntity,
// can be just a counter, need to be able to determine "latest"
pub creation_time: u32,
// for stateless deterministic keys, it seems CTAP2 (but not CTAP1) makes signature counters optional
use_counter: bool,
// P256 or Ed25519
pub algorithm: i32,
// for RK in non-deterministic mode: refers to actual key
// TODO(implement enums in cbor-deser): for all others, is a wrapped key
// --> use above Key enum
// #[serde(skip_serializing_if = "Option::is_none")]
// key_id: Option<KeyId>,
pub key: Key,
// extensions
#[serde(skip_serializing_if = "Option::is_none")]
pub hmac_secret: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cred_protect: Option<CredentialProtectionPolicy>,
// TODO: add `sig_counter: Option<CounterId>`,
// and grant RKs a per-credential sig-counter.
}
// TODO: figure out sizes
// We may or may not follow https://github.com/satoshilabs/slips/blob/master/slip-0022.md
/// The core structure this authenticator creates and uses.
#[derive(Clone, Debug, serde_indexed::DeserializeIndexed, serde_indexed::SerializeIndexed)]
pub struct Credential {
ctap: CtapVersion,
pub data: CredentialData,
nonce: Bytes<12>,
}
// Alas... it would be more symmetrical to have Credential { meta, data },
// but let's not break binary compatibility for this.
//
// struct Metadata {
// ctap: CtapVersion,
// nonce: Bytes<12>,
// }
impl core::ops::Deref for Credential {
type Target = CredentialData;
fn deref(&self) -> &Self::Target {
&self.data
}
}
/// Compare credentials based on key + timestamp.
///
/// Likely comparison based on timestamp would be good enough?
impl PartialEq for Credential {
fn eq(&self, other: &Self) -> bool {
(self.creation_time == other.creation_time) && (self.key == other.key)
}
}
impl PartialEq<&Credential> for Credential {
fn eq(&self, other: &&Self) -> bool {
self == *other
}
}
impl Eq for Credential {}
impl Ord for Credential {
fn cmp(&self, other: &Self) -> Ordering {
self.data.creation_time.cmp(&other.data.creation_time)
}
}
/// Order by timestamp of creation.
impl PartialOrd for Credential {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl PartialOrd<&Credential> for Credential {
fn partial_cmp(&self, other: &&Self) -> Option<Ordering> {
Some(self.cmp(*other))
}
}
// Bad idea - huge stack
// pub(crate) type CredentialList = Vec<Credential, {ctap_types::sizes::MAX_CREDENTIAL_COUNT_IN_LIST}>;
impl From<CredentialId> for PublicKeyCredentialDescriptor {
fn from(id: CredentialId) -> PublicKeyCredentialDescriptor {
PublicKeyCredentialDescriptor {
id: id.0,
key_type: {
let mut key_type = String::new();
key_type.push_str("public-key").unwrap();
key_type
},
}
}
}
impl Credential {
#[allow(clippy::too_many_arguments)]
pub fn new(
ctap: CtapVersion,
// parameters: &ctap2::make_credential::Parameters,
rp: &ctap_types::webauthn::PublicKeyCredentialRpEntity,
user: &ctap_types::webauthn::PublicKeyCredentialUserEntity,
algorithm: i32,
key: Key,
timestamp: u32,
hmac_secret: Option<bool>,
cred_protect: Option<CredentialProtectionPolicy>,
nonce: [u8; 12],
) -> Self {
info!("credential for algorithm {}", algorithm);
let data = CredentialData {
rp: rp.clone(),
user: user.clone(),
creation_time: timestamp,
use_counter: true,
algorithm,
key,
hmac_secret,
cred_protect,
};
Credential {
ctap,
data,
nonce: Bytes::from_slice(&nonce).unwrap(),
}
}
// ID (or "keyhandle") for the credential.
//
// Originally, the entire data was serialized, and its encryption
// (binding RP as associated data) used as a keyhandle.
//
// However, this leads to problems with relying parties. According to the old U2F
// spec, the length of a keyhandle is encoded as one byte, whereas this procedure would
// generate keyhandles of length ~320 bytes.
//
// Therefore, inessential metadata is stripped before serialization, ensuring
// the ID will stay below 255 bytes.
//
// Existing keyhandles can still be decoded
pub fn id<T: client::Chacha8Poly1305 + client::Sha256>(
&self,
trussed: &mut T,
key_encryption_key: KeyId,
rp_id_hash: Option<&Bytes<32>>,
) -> Result<CredentialId> {
let serialized_credential = self.strip().serialize()?;
let message = &serialized_credential;
// info!("serialized cred = {:?}", message).ok();
let rp_id_hash: Bytes<32> = if let Some(hash) = rp_id_hash {
hash.clone()
} else {
syscall!(trussed.hash_sha256(self.rp.id.as_ref()))
.hash
.to_bytes()
.map_err(|_| Error::Other)?
};
let associated_data = &rp_id_hash[..];
let nonce: [u8; 12] = self.nonce.as_slice().try_into().unwrap();
let encrypted_serialized_credential = EncryptedSerializedCredential(syscall!(trussed
.encrypt_chacha8poly1305(key_encryption_key, message, associated_data, Some(&nonce))));
let credential_id: CredentialId = encrypted_serialized_credential
.try_into()
.map_err(|_| Error::RequestTooLarge)?;
Ok(credential_id)
}
pub fn serialize(&self) -> Result<SerializedCredential> {
trussed::cbor_serialize_bytes(self).map_err(|_| Error::Other)
}
pub fn deserialize(bytes: &SerializedCredential) -> Result<Self> {
match ctap_types::serde::cbor_deserialize(bytes) {
Ok(s) => Ok(s),
Err(_) => {
info_now!("could not deserialize {:?}", bytes);
Err(Error::Other)
}
}
}
pub fn try_from<UP: UserPresence, T: client:: | /// As signaled in `get_info`.
///
/// Eventual goal is full support for the CTAP2.1 specification. | random_line_split |
|
credential.rs | Data {
// id, name, url
pub rp: ctap_types::webauthn::PublicKeyCredentialRpEntity,
// id, icon, name, display_name
pub user: ctap_types::webauthn::PublicKeyCredentialUserEntity,
// can be just a counter, need to be able to determine "latest"
pub creation_time: u32,
// for stateless deterministic keys, it seems CTAP2 (but not CTAP1) makes signature counters optional
use_counter: bool,
// P256 or Ed25519
pub algorithm: i32,
// for RK in non-deterministic mode: refers to actual key
// TODO(implement enums in cbor-deser): for all others, is a wrapped key
// --> use above Key enum
// #[serde(skip_serializing_if = "Option::is_none")]
// key_id: Option<KeyId>,
pub key: Key,
// extensions
#[serde(skip_serializing_if = "Option::is_none")]
pub hmac_secret: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cred_protect: Option<CredentialProtectionPolicy>,
// TODO: add `sig_counter: Option<CounterId>`,
// and grant RKs a per-credential sig-counter.
}
// TODO: figure out sizes
// We may or may not follow https://github.com/satoshilabs/slips/blob/master/slip-0022.md
/// The core structure this authenticator creates and uses.
#[derive(Clone, Debug, serde_indexed::DeserializeIndexed, serde_indexed::SerializeIndexed)]
pub struct Credential {
ctap: CtapVersion,
pub data: CredentialData,
nonce: Bytes<12>,
}
// Alas... it would be more symmetrical to have Credential { meta, data },
// but let's not break binary compatibility for this.
//
// struct Metadata {
// ctap: CtapVersion,
// nonce: Bytes<12>,
// }
impl core::ops::Deref for Credential {
type Target = CredentialData;
fn deref(&self) -> &Self::Target {
&self.data
}
}
/// Compare credentials based on key + timestamp.
///
/// Likely comparison based on timestamp would be good enough?
impl PartialEq for Credential {
fn eq(&self, other: &Self) -> bool {
(self.creation_time == other.creation_time) && (self.key == other.key)
}
}
impl PartialEq<&Credential> for Credential {
fn eq(&self, other: &&Self) -> bool {
self == *other
}
}
impl Eq for Credential {}
impl Ord for Credential {
fn cmp(&self, other: &Self) -> Ordering {
self.data.creation_time.cmp(&other.data.creation_time)
}
}
/// Order by timestamp of creation.
impl PartialOrd for Credential {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl PartialOrd<&Credential> for Credential {
fn partial_cmp(&self, other: &&Self) -> Option<Ordering> {
Some(self.cmp(*other))
}
}
// Bad idea - huge stack
// pub(crate) type CredentialList = Vec<Credential, {ctap_types::sizes::MAX_CREDENTIAL_COUNT_IN_LIST}>;
impl From<CredentialId> for PublicKeyCredentialDescriptor {
fn from(id: CredentialId) -> PublicKeyCredentialDescriptor {
PublicKeyCredentialDescriptor {
id: id.0,
key_type: {
let mut key_type = String::new();
key_type.push_str("public-key").unwrap();
key_type
},
}
}
}
impl Credential {
#[allow(clippy::too_many_arguments)]
pub fn new(
ctap: CtapVersion,
// parameters: &ctap2::make_credential::Parameters,
rp: &ctap_types::webauthn::PublicKeyCredentialRpEntity,
user: &ctap_types::webauthn::PublicKeyCredentialUserEntity,
algorithm: i32,
key: Key,
timestamp: u32,
hmac_secret: Option<bool>,
cred_protect: Option<CredentialProtectionPolicy>,
nonce: [u8; 12],
) -> Self {
info!("credential for algorithm {}", algorithm);
let data = CredentialData {
rp: rp.clone(),
user: user.clone(),
creation_time: timestamp,
use_counter: true,
algorithm,
key,
hmac_secret,
cred_protect,
};
Credential {
ctap,
data,
nonce: Bytes::from_slice(&nonce).unwrap(),
}
}
// ID (or "keyhandle") for the credential.
//
// Originally, the entire data was serialized, and its encryption
// (binding RP as associated data) used as a keyhandle.
//
// However, this leads to problems with relying parties. According to the old U2F
// spec, the length of a keyhandle is encoded as one byte, whereas this procedure would
// generate keyhandles of length ~320 bytes.
//
// Therefore, inessential metadata is stripped before serialization, ensuring
// the ID will stay below 255 bytes.
//
// Existing keyhandles can still be decoded
pub fn id<T: client::Chacha8Poly1305 + client::Sha256>(
&self,
trussed: &mut T,
key_encryption_key: KeyId,
rp_id_hash: Option<&Bytes<32>>,
) -> Result<CredentialId> {
let serialized_credential = self.strip().serialize()?;
let message = &serialized_credential;
// info!("serialized cred = {:?}", message).ok();
let rp_id_hash: Bytes<32> = if let Some(hash) = rp_id_hash {
hash.clone()
} else {
syscall!(trussed.hash_sha256(self.rp.id.as_ref()))
.hash
.to_bytes()
.map_err(|_| Error::Other)?
};
let associated_data = &rp_id_hash[..];
let nonce: [u8; 12] = self.nonce.as_slice().try_into().unwrap();
let encrypted_serialized_credential = EncryptedSerializedCredential(syscall!(trussed
.encrypt_chacha8poly1305(key_encryption_key, message, associated_data, Some(&nonce))));
let credential_id: CredentialId = encrypted_serialized_credential
.try_into()
.map_err(|_| Error::RequestTooLarge)?;
Ok(credential_id)
}
pub fn serialize(&self) -> Result<SerializedCredential> {
trussed::cbor_serialize_bytes(self).map_err(|_| Error::Other)
}
pub fn deserialize(bytes: &SerializedCredential) -> Result<Self> {
match ctap_types::serde::cbor_deserialize(bytes) {
Ok(s) => Ok(s),
Err(_) => |
}
}
pub fn try_from<UP: UserPresence, T: client::Client + client::Chacha8Poly1305>(
authnr: &mut Authenticator<UP, T>,
rp_id_hash: &Bytes<32>,
descriptor: &PublicKeyCredentialDescriptor,
) -> Result<Self> {
Self::try_from_bytes(authnr, rp_id_hash, &descriptor.id)
}
pub fn try_from_bytes<UP: UserPresence, T: client::Client + client::Chacha8Poly1305>(
authnr: &mut Authenticator<UP, T>,
rp_id_hash: &Bytes<32>,
id: &[u8],
) -> Result<Self> {
let mut cred: Bytes<MAX_CREDENTIAL_ID_LENGTH> = Bytes::new();
cred.extend_from_slice(id)
.map_err(|_| Error::InvalidCredential)?;
let encrypted_serialized = EncryptedSerializedCredential::try_from(CredentialId(cred))?;
let kek = authnr
.state
.persistent
.key_encryption_key(&mut authnr.trussed)?;
let serialized = try_syscall!(authnr.trussed.decrypt_chacha8poly1305(
// TODO: use RpId as associated data here?
kek,
&encrypted_serialized.0.ciphertext,
&rp_id_hash[..],
&encrypted_serialized.0.nonce,
&encrypted_serialized.0.tag,
))
.map_err(|_| Error::InvalidCredential)?
.plaintext
.ok_or(Error::InvalidCredential)?;
let credential =
Credential::deserialize(&serialized).map_err(|_| Error::InvalidCredential)?;
Ok(credential)
}
// Remove inessential metadata from credential.
//
// Called by the `id` method, see its documentation.
pub fn strip(&self) -> Self {
info_now!(":: stripping ID");
let mut stripped = self.clone();
let data = &mut stripped.data;
data.rp.name = None;
data.rp.icon = None;
data.user.icon = None;
data.user.name = None;
data.user.display_name = None;
// data.hmac_secret = None;
// data.cred_protect = None;
stripped
}
}
#[cfg(test)]
mod test {
use super::*;
fn credential_data() -> CredentialData {
use ctap_types::webauthn | {
info_now!("could not deserialize {:?}", bytes);
Err(Error::Other)
} | conditional_block |
dns.go | uint16
event Event
}
type dnsAnswer struct {
name []byte
qType uint16
qClass uint16
ttl uint32
dataLen uint16
addr []byte
}
// metaClient is a query client
var metaClient client.CoreInterface
// dnsConn saves DNS protocol
var dnsConn *net.UDPConn
// Start is for external call
func Start() {
startDNS()
}
// startDNS starts edgemesh dns server
func startDNS() {
// init meta client
metaClient = client.New()
// get dns listen ip
lip, err := common.GetInterfaceIP(ifi)
if err != nil {
klog.Errorf("[EdgeMesh] get dns listen ip err: %v", err)
return
}
laddr := &net.UDPAddr{
IP: lip,
Port: 53,
}
udpConn, err := net.ListenUDP("udp", laddr)
if err != nil {
klog.Errorf("[EdgeMesh] dns server listen on %v error: %v", laddr, err)
return
}
defer udpConn.Close()
dnsConn = udpConn
for {
req := make([]byte, bufSize)
n, from, err := dnsConn.ReadFromUDP(req)
if err != nil || n <= 0 {
klog.Errorf("[EdgeMesh] dns server read from udp error: %v", err)
continue
}
que, err := parseDNSQuery(req[:n])
if err != nil {
continue
}
que.from = from
rsp := make([]byte, 0)
rsp, err = recordHandle(que, req[:n])
if err != nil {
klog.Warningf("[EdgeMesh] failed to resolve dns: %v", err)
continue
}
if _, err = dnsConn.WriteTo(rsp, from); err != nil {
klog.Warningf("[EdgeMesh] failed to write: %v", err)
}
}
}
// recordHandle returns the answer for the dns question
func recordHandle(que *dnsQuestion, req []byte) (rsp []byte, err error) {
var exist bool
var ip string
// qType should be 1 for ipv4
if que.name != nil && que.qType == aRecord {
domainName := string(que.name)
exist, ip = lookupFromMetaManager(domainName)
}
if !exist || que.event == eventUpstream {
// if this service doesn't belongs to this cluster
go getFromRealDNS(req, que.from)
return rsp, fmt.Errorf("get from real dns")
}
address := net.ParseIP(ip).To4()
if address == nil {
que.event = eventNxDomain
}
// gen
pre := modifyRspPrefix(que)
rsp = append(rsp, pre...)
if que.event != eventNothing {
return rsp, nil
}
// create a deceptive resp, if no error
dnsAns := &dnsAnswer{
name: que.name,
qType: que.qType,
qClass: que.qClass,
ttl: ttl,
dataLen: uint16(len(address)),
addr: address,
}
ans := dnsAns.getAnswer()
rsp = append(rsp, ans...)
return rsp, nil
}
// parseDNSQuery converts bytes to *dnsQuestion
func parseDNSQuery(req []byte) (que *dnsQuestion, err error) {
head := &dnsHeader{}
head.getHeader(req)
if !head.isAQuery() {
return nil, errors.New("not a dns query, ignore")
}
que = &dnsQuestion{
event: eventNothing,
}
// Generally, when the recursive DNS server requests upward, it may
// initiate a resolution request for multiple aliases/domain names
// at once, Edge DNS does not need to process a message that carries
// multiple questions at a time.
if head.qdCount != 1 |
offset := uint16(unsafe.Sizeof(dnsHeader{}))
// DNS NS <ROOT> operation
if req[offset] == 0x0 {
que.event = eventUpstream
return
}
que.getQuestion(req, offset, head)
err = nil
return
}
// isAQuery judges if the dns pkg is a query
func (h *dnsHeader) isAQuery() bool {
return h.flags&dnsQR != dnsQR
}
// getHeader gets dns pkg head
func (h *dnsHeader) getHeader(req []byte) {
h.id = binary.BigEndian.Uint16(req[0:2])
h.flags = binary.BigEndian.Uint16(req[2:4])
h.qdCount = binary.BigEndian.Uint16(req[4:6])
h.anCount = binary.BigEndian.Uint16(req[6:8])
h.nsCount = binary.BigEndian.Uint16(req[8:10])
h.arCount = binary.BigEndian.Uint16(req[10:12])
}
// getQuestion gets a dns question
func (q *dnsQuestion) getQuestion(req []byte, offset uint16, head *dnsHeader) {
ost := offset
tmp := ost
ost = q.getQName(req, ost)
q.qType = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.qClass = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.head = head
q.queByte = req[tmp:ost]
}
// getAnswer generates answer for the dns question
func (da *dnsAnswer) getAnswer() (answer []byte) {
answer = make([]byte, 0)
if da.qType == aRecord {
answer = append(answer, 0xc0)
answer = append(answer, 0x0c)
tmp16 := make([]byte, 2)
tmp32 := make([]byte, 4)
binary.BigEndian.PutUint16(tmp16, da.qType)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint16(tmp16, da.qClass)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint32(tmp32, da.ttl)
answer = append(answer, tmp32...)
binary.BigEndian.PutUint16(tmp16, da.dataLen)
answer = append(answer, tmp16...)
answer = append(answer, da.addr...)
}
return answer
}
// getQName gets dns question qName
func (q *dnsQuestion) getQName(req []byte, offset uint16) uint16 {
ost := offset
for {
// one byte to suggest length
qbyte := uint16(req[ost])
// qName ends with 0x00, and 0x00 should not be included
if qbyte == 0x00 {
q.name = q.name[:uint16(len(q.name))-oneByteSize]
return ost + oneByteSize
}
// step forward one more byte and get the real stuff
ost += oneByteSize
q.name = append(q.name, req[ost:ost+qbyte]...)
// add "." symbol
q.name = append(q.name, 0x2e)
ost += qbyte
}
}
// lookupFromMetaManager confirms if the service exists
func lookupFromMetaManager(serviceURL string) (exist bool, ip string) {
name, namespace := common.SplitServiceKey(serviceURL)
s, _ := metaClient.Services(namespace).Get(name)
if s != nil {
svcName := namespace + "." + name
ip := listener.GetServiceServer(svcName)
klog.Infof("[EdgeMesh] dns server parse %s ip %s", serviceURL, ip)
return true, ip
}
klog.Errorf("[EdgeMesh] service %s is not found in this cluster", serviceURL)
return false, ""
}
// getFromRealDNS returns a dns response from real dns servers
func getFromRealDNS(req []byte, from *net.UDPAddr) {
rsp := make([]byte, 0)
ips, err := parseNameServer()
if err != nil {
klog.Errorf("[EdgeMesh] parse nameserver err: %v", err)
return
}
laddr := &net.UDPAddr{
IP: net.IPv4zero,
Port: 0,
}
// get from real dns servers
for _, ip := range ips {
raddr := &net.UDPAddr{
IP: ip,
Port: 53,
}
conn, err := net.DialUDP("udp", laddr, raddr)
if err != nil {
continue
}
defer conn.Close()
_, err = conn.Write(req)
if err != nil {
continue
}
if err = conn.SetReadDeadline(time.Now().Add(time.Minute)); err != nil {
continue
}
var n int
buf := make([]byte, bufSize)
n, err = conn.Read(buf)
if err != nil {
continue
| {
que.event = eventUpstream
return
} | conditional_block |
dns.go | uint16
event Event
}
type dnsAnswer struct {
name []byte
qType uint16
qClass uint16
ttl uint32
dataLen uint16
addr []byte
}
// metaClient is a query client
var metaClient client.CoreInterface
// dnsConn saves DNS protocol
var dnsConn *net.UDPConn
// Start is for external call
func Start() {
startDNS()
}
// startDNS starts edgemesh dns server
func startDNS() {
// init meta client
metaClient = client.New()
// get dns listen ip
lip, err := common.GetInterfaceIP(ifi)
if err != nil {
klog.Errorf("[EdgeMesh] get dns listen ip err: %v", err)
return
}
laddr := &net.UDPAddr{
IP: lip,
Port: 53,
}
udpConn, err := net.ListenUDP("udp", laddr)
if err != nil {
klog.Errorf("[EdgeMesh] dns server listen on %v error: %v", laddr, err)
return
}
defer udpConn.Close()
dnsConn = udpConn
for {
req := make([]byte, bufSize)
n, from, err := dnsConn.ReadFromUDP(req)
if err != nil || n <= 0 {
klog.Errorf("[EdgeMesh] dns server read from udp error: %v", err)
continue
}
que, err := parseDNSQuery(req[:n])
if err != nil {
continue
}
que.from = from
rsp := make([]byte, 0)
rsp, err = recordHandle(que, req[:n])
if err != nil {
klog.Warningf("[EdgeMesh] failed to resolve dns: %v", err)
continue
}
if _, err = dnsConn.WriteTo(rsp, from); err != nil {
klog.Warningf("[EdgeMesh] failed to write: %v", err)
}
}
}
// recordHandle returns the answer for the dns question
func | (que *dnsQuestion, req []byte) (rsp []byte, err error) {
var exist bool
var ip string
// qType should be 1 for ipv4
if que.name != nil && que.qType == aRecord {
domainName := string(que.name)
exist, ip = lookupFromMetaManager(domainName)
}
if !exist || que.event == eventUpstream {
// if this service doesn't belongs to this cluster
go getFromRealDNS(req, que.from)
return rsp, fmt.Errorf("get from real dns")
}
address := net.ParseIP(ip).To4()
if address == nil {
que.event = eventNxDomain
}
// gen
pre := modifyRspPrefix(que)
rsp = append(rsp, pre...)
if que.event != eventNothing {
return rsp, nil
}
// create a deceptive resp, if no error
dnsAns := &dnsAnswer{
name: que.name,
qType: que.qType,
qClass: que.qClass,
ttl: ttl,
dataLen: uint16(len(address)),
addr: address,
}
ans := dnsAns.getAnswer()
rsp = append(rsp, ans...)
return rsp, nil
}
// parseDNSQuery converts bytes to *dnsQuestion
func parseDNSQuery(req []byte) (que *dnsQuestion, err error) {
head := &dnsHeader{}
head.getHeader(req)
if !head.isAQuery() {
return nil, errors.New("not a dns query, ignore")
}
que = &dnsQuestion{
event: eventNothing,
}
// Generally, when the recursive DNS server requests upward, it may
// initiate a resolution request for multiple aliases/domain names
// at once, Edge DNS does not need to process a message that carries
// multiple questions at a time.
if head.qdCount != 1 {
que.event = eventUpstream
return
}
offset := uint16(unsafe.Sizeof(dnsHeader{}))
// DNS NS <ROOT> operation
if req[offset] == 0x0 {
que.event = eventUpstream
return
}
que.getQuestion(req, offset, head)
err = nil
return
}
// isAQuery judges if the dns pkg is a query
func (h *dnsHeader) isAQuery() bool {
return h.flags&dnsQR != dnsQR
}
// getHeader gets dns pkg head
func (h *dnsHeader) getHeader(req []byte) {
h.id = binary.BigEndian.Uint16(req[0:2])
h.flags = binary.BigEndian.Uint16(req[2:4])
h.qdCount = binary.BigEndian.Uint16(req[4:6])
h.anCount = binary.BigEndian.Uint16(req[6:8])
h.nsCount = binary.BigEndian.Uint16(req[8:10])
h.arCount = binary.BigEndian.Uint16(req[10:12])
}
// getQuestion gets a dns question
func (q *dnsQuestion) getQuestion(req []byte, offset uint16, head *dnsHeader) {
ost := offset
tmp := ost
ost = q.getQName(req, ost)
q.qType = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.qClass = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.head = head
q.queByte = req[tmp:ost]
}
// getAnswer generates answer for the dns question
func (da *dnsAnswer) getAnswer() (answer []byte) {
answer = make([]byte, 0)
if da.qType == aRecord {
answer = append(answer, 0xc0)
answer = append(answer, 0x0c)
tmp16 := make([]byte, 2)
tmp32 := make([]byte, 4)
binary.BigEndian.PutUint16(tmp16, da.qType)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint16(tmp16, da.qClass)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint32(tmp32, da.ttl)
answer = append(answer, tmp32...)
binary.BigEndian.PutUint16(tmp16, da.dataLen)
answer = append(answer, tmp16...)
answer = append(answer, da.addr...)
}
return answer
}
// getQName gets dns question qName
func (q *dnsQuestion) getQName(req []byte, offset uint16) uint16 {
ost := offset
for {
// one byte to suggest length
qbyte := uint16(req[ost])
// qName ends with 0x00, and 0x00 should not be included
if qbyte == 0x00 {
q.name = q.name[:uint16(len(q.name))-oneByteSize]
return ost + oneByteSize
}
// step forward one more byte and get the real stuff
ost += oneByteSize
q.name = append(q.name, req[ost:ost+qbyte]...)
// add "." symbol
q.name = append(q.name, 0x2e)
ost += qbyte
}
}
// lookupFromMetaManager confirms if the service exists
func lookupFromMetaManager(serviceURL string) (exist bool, ip string) {
name, namespace := common.SplitServiceKey(serviceURL)
s, _ := metaClient.Services(namespace).Get(name)
if s != nil {
svcName := namespace + "." + name
ip := listener.GetServiceServer(svcName)
klog.Infof("[EdgeMesh] dns server parse %s ip %s", serviceURL, ip)
return true, ip
}
klog.Errorf("[EdgeMesh] service %s is not found in this cluster", serviceURL)
return false, ""
}
// getFromRealDNS returns a dns response from real dns servers
func getFromRealDNS(req []byte, from *net.UDPAddr) {
rsp := make([]byte, 0)
ips, err := parseNameServer()
if err != nil {
klog.Errorf("[EdgeMesh] parse nameserver err: %v", err)
return
}
laddr := &net.UDPAddr{
IP: net.IPv4zero,
Port: 0,
}
// get from real dns servers
for _, ip := range ips {
raddr := &net.UDPAddr{
IP: ip,
Port: 53,
}
conn, err := net.DialUDP("udp", laddr, raddr)
if err != nil {
continue
}
defer conn.Close()
_, err = conn.Write(req)
if err != nil {
continue
}
if err = conn.SetReadDeadline(time.Now().Add(time.Minute)); err != nil {
continue
}
var n int
buf := make([]byte, bufSize)
n, err = conn.Read(buf)
if err != nil {
continue
| recordHandle | identifier_name |
dns.go | "bufio"
"encoding/binary"
"errors"
"fmt"
"net"
"os"
"strings"
"time"
"unsafe"
"k8s.io/klog/v2"
"github.com/kubeedge/kubeedge/edge/pkg/metamanager/client"
"github.com/kubeedge/kubeedge/edgemesh/pkg/common"
"github.com/kubeedge/kubeedge/edgemesh/pkg/config"
"github.com/kubeedge/kubeedge/edgemesh/pkg/listener"
)
type Event int
var (
// default docker0
ifi = "docker0"
// QR: 0 represents query, 1 represents response
dnsQR = uint16(0x8000)
oneByteSize = uint16(1)
twoByteSize = uint16(2)
ttl = uint32(64)
)
const (
// 1 for ipv4
aRecord = 1
bufSize = 1024
errNotImplemented = uint16(0x0004)
errRefused = uint16(0x0005)
eventNothing = Event(0)
eventUpstream = Event(1)
eventNxDomain = Event(2)
)
type dnsHeader struct {
id uint16
flags uint16
qdCount uint16
anCount uint16
nsCount uint16
arCount uint16
}
type dnsQuestion struct {
from *net.UDPAddr
head *dnsHeader
name []byte
queByte []byte
qType uint16
qClass uint16
queNum uint16
event Event
}
type dnsAnswer struct {
name []byte
qType uint16
qClass uint16
ttl uint32
dataLen uint16
addr []byte
}
// metaClient is a query client
var metaClient client.CoreInterface
// dnsConn saves DNS protocol
var dnsConn *net.UDPConn
// Start is for external call
func Start() {
startDNS()
}
// startDNS starts edgemesh dns server
func startDNS() {
// init meta client
metaClient = client.New()
// get dns listen ip
lip, err := common.GetInterfaceIP(ifi)
if err != nil {
klog.Errorf("[EdgeMesh] get dns listen ip err: %v", err)
return
}
laddr := &net.UDPAddr{
IP: lip,
Port: 53,
}
udpConn, err := net.ListenUDP("udp", laddr)
if err != nil {
klog.Errorf("[EdgeMesh] dns server listen on %v error: %v", laddr, err)
return
}
defer udpConn.Close()
dnsConn = udpConn
for {
req := make([]byte, bufSize)
n, from, err := dnsConn.ReadFromUDP(req)
if err != nil || n <= 0 {
klog.Errorf("[EdgeMesh] dns server read from udp error: %v", err)
continue
}
que, err := parseDNSQuery(req[:n])
if err != nil {
continue
}
que.from = from
rsp := make([]byte, 0)
rsp, err = recordHandle(que, req[:n])
if err != nil {
klog.Warningf("[EdgeMesh] failed to resolve dns: %v", err)
continue
}
if _, err = dnsConn.WriteTo(rsp, from); err != nil {
klog.Warningf("[EdgeMesh] failed to write: %v", err)
}
}
}
// recordHandle returns the answer for the dns question
func recordHandle(que *dnsQuestion, req []byte) (rsp []byte, err error) {
var exist bool
var ip string
// qType should be 1 for ipv4
if que.name != nil && que.qType == aRecord {
domainName := string(que.name)
exist, ip = lookupFromMetaManager(domainName)
}
if !exist || que.event == eventUpstream {
// if this service doesn't belongs to this cluster
go getFromRealDNS(req, que.from)
return rsp, fmt.Errorf("get from real dns")
}
address := net.ParseIP(ip).To4()
if address == nil {
que.event = eventNxDomain
}
// gen
pre := modifyRspPrefix(que)
rsp = append(rsp, pre...)
if que.event != eventNothing {
return rsp, nil
}
// create a deceptive resp, if no error
dnsAns := &dnsAnswer{
name: que.name,
qType: que.qType,
qClass: que.qClass,
ttl: ttl,
dataLen: uint16(len(address)),
addr: address,
}
ans := dnsAns.getAnswer()
rsp = append(rsp, ans...)
return rsp, nil
}
// parseDNSQuery converts bytes to *dnsQuestion
func parseDNSQuery(req []byte) (que *dnsQuestion, err error) {
head := &dnsHeader{}
head.getHeader(req)
if !head.isAQuery() {
return nil, errors.New("not a dns query, ignore")
}
que = &dnsQuestion{
event: eventNothing,
}
// Generally, when the recursive DNS server requests upward, it may
// initiate a resolution request for multiple aliases/domain names
// at once, Edge DNS does not need to process a message that carries
// multiple questions at a time.
if head.qdCount != 1 {
que.event = eventUpstream
return
}
offset := uint16(unsafe.Sizeof(dnsHeader{}))
// DNS NS <ROOT> operation
if req[offset] == 0x0 {
que.event = eventUpstream
return
}
que.getQuestion(req, offset, head)
err = nil
return
}
// isAQuery judges if the dns pkg is a query
func (h *dnsHeader) isAQuery() bool {
return h.flags&dnsQR != dnsQR
}
// getHeader gets dns pkg head
func (h *dnsHeader) getHeader(req []byte) {
h.id = binary.BigEndian.Uint16(req[0:2])
h.flags = binary.BigEndian.Uint16(req[2:4])
h.qdCount = binary.BigEndian.Uint16(req[4:6])
h.anCount = binary.BigEndian.Uint16(req[6:8])
h.nsCount = binary.BigEndian.Uint16(req[8:10])
h.arCount = binary.BigEndian.Uint16(req[10:12])
}
// getQuestion gets a dns question
func (q *dnsQuestion) getQuestion(req []byte, offset uint16, head *dnsHeader) {
ost := offset
tmp := ost
ost = q.getQName(req, ost)
q.qType = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.qClass = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.head = head
q.queByte = req[tmp:ost]
}
// getAnswer generates answer for the dns question
func (da *dnsAnswer) getAnswer() (answer []byte) {
answer = make([]byte, 0)
if da.qType == aRecord {
answer = append(answer, 0xc0)
answer = append(answer, 0x0c)
tmp16 := make([]byte, 2)
tmp32 := make([]byte, 4)
binary.BigEndian.PutUint16(tmp16, da.qType)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint16(tmp16, da.qClass)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint32(tmp32, da.ttl)
answer = append(answer, tmp32...)
binary.BigEndian.PutUint16(tmp16, da.dataLen)
answer = append(answer, tmp16...)
answer = append(answer, da.addr...)
}
return answer
}
// getQName gets dns question qName
func (q *dnsQuestion) getQName(req []byte, offset uint16) uint16 {
ost := offset
for {
// one byte to suggest length
qbyte := uint16(req[ost])
// qName ends with 0x00, and 0x00 should not be included
if qbyte == 0x00 {
q.name = q.name[:uint16(len(q.name))-oneByteSize]
return ost + oneByteSize
}
// step forward one more byte and get the real stuff
ost += oneByteSize
q.name = append(q.name, req[ost:ost+qbyte]...)
// add "." symbol
q.name = append(q.name, 0x2e)
ost += qbyte
}
}
// lookupFromMetaManager confirms if the service exists
func lookupFromMetaManager(serviceURL string) (exist bool, ip string |
import ( | random_line_split |
|
dns.go | nil && que.qType == aRecord {
domainName := string(que.name)
exist, ip = lookupFromMetaManager(domainName)
}
if !exist || que.event == eventUpstream {
// if this service doesn't belongs to this cluster
go getFromRealDNS(req, que.from)
return rsp, fmt.Errorf("get from real dns")
}
address := net.ParseIP(ip).To4()
if address == nil {
que.event = eventNxDomain
}
// gen
pre := modifyRspPrefix(que)
rsp = append(rsp, pre...)
if que.event != eventNothing {
return rsp, nil
}
// create a deceptive resp, if no error
dnsAns := &dnsAnswer{
name: que.name,
qType: que.qType,
qClass: que.qClass,
ttl: ttl,
dataLen: uint16(len(address)),
addr: address,
}
ans := dnsAns.getAnswer()
rsp = append(rsp, ans...)
return rsp, nil
}
// parseDNSQuery converts bytes to *dnsQuestion
func parseDNSQuery(req []byte) (que *dnsQuestion, err error) {
head := &dnsHeader{}
head.getHeader(req)
if !head.isAQuery() {
return nil, errors.New("not a dns query, ignore")
}
que = &dnsQuestion{
event: eventNothing,
}
// Generally, when the recursive DNS server requests upward, it may
// initiate a resolution request for multiple aliases/domain names
// at once, Edge DNS does not need to process a message that carries
// multiple questions at a time.
if head.qdCount != 1 {
que.event = eventUpstream
return
}
offset := uint16(unsafe.Sizeof(dnsHeader{}))
// DNS NS <ROOT> operation
if req[offset] == 0x0 {
que.event = eventUpstream
return
}
que.getQuestion(req, offset, head)
err = nil
return
}
// isAQuery judges if the dns pkg is a query
func (h *dnsHeader) isAQuery() bool {
return h.flags&dnsQR != dnsQR
}
// getHeader gets dns pkg head
func (h *dnsHeader) getHeader(req []byte) {
h.id = binary.BigEndian.Uint16(req[0:2])
h.flags = binary.BigEndian.Uint16(req[2:4])
h.qdCount = binary.BigEndian.Uint16(req[4:6])
h.anCount = binary.BigEndian.Uint16(req[6:8])
h.nsCount = binary.BigEndian.Uint16(req[8:10])
h.arCount = binary.BigEndian.Uint16(req[10:12])
}
// getQuestion gets a dns question
func (q *dnsQuestion) getQuestion(req []byte, offset uint16, head *dnsHeader) {
ost := offset
tmp := ost
ost = q.getQName(req, ost)
q.qType = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.qClass = binary.BigEndian.Uint16(req[ost : ost+twoByteSize])
ost += twoByteSize
q.head = head
q.queByte = req[tmp:ost]
}
// getAnswer generates answer for the dns question
func (da *dnsAnswer) getAnswer() (answer []byte) {
answer = make([]byte, 0)
if da.qType == aRecord {
answer = append(answer, 0xc0)
answer = append(answer, 0x0c)
tmp16 := make([]byte, 2)
tmp32 := make([]byte, 4)
binary.BigEndian.PutUint16(tmp16, da.qType)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint16(tmp16, da.qClass)
answer = append(answer, tmp16...)
binary.BigEndian.PutUint32(tmp32, da.ttl)
answer = append(answer, tmp32...)
binary.BigEndian.PutUint16(tmp16, da.dataLen)
answer = append(answer, tmp16...)
answer = append(answer, da.addr...)
}
return answer
}
// getQName gets dns question qName
func (q *dnsQuestion) getQName(req []byte, offset uint16) uint16 {
ost := offset
for {
// one byte to suggest length
qbyte := uint16(req[ost])
// qName ends with 0x00, and 0x00 should not be included
if qbyte == 0x00 {
q.name = q.name[:uint16(len(q.name))-oneByteSize]
return ost + oneByteSize
}
// step forward one more byte and get the real stuff
ost += oneByteSize
q.name = append(q.name, req[ost:ost+qbyte]...)
// add "." symbol
q.name = append(q.name, 0x2e)
ost += qbyte
}
}
// lookupFromMetaManager confirms if the service exists
func lookupFromMetaManager(serviceURL string) (exist bool, ip string) {
name, namespace := common.SplitServiceKey(serviceURL)
s, _ := metaClient.Services(namespace).Get(name)
if s != nil {
svcName := namespace + "." + name
ip := listener.GetServiceServer(svcName)
klog.Infof("[EdgeMesh] dns server parse %s ip %s", serviceURL, ip)
return true, ip
}
klog.Errorf("[EdgeMesh] service %s is not found in this cluster", serviceURL)
return false, ""
}
// getFromRealDNS returns a dns response from real dns servers
func getFromRealDNS(req []byte, from *net.UDPAddr) {
rsp := make([]byte, 0)
ips, err := parseNameServer()
if err != nil {
klog.Errorf("[EdgeMesh] parse nameserver err: %v", err)
return
}
laddr := &net.UDPAddr{
IP: net.IPv4zero,
Port: 0,
}
// get from real dns servers
for _, ip := range ips {
raddr := &net.UDPAddr{
IP: ip,
Port: 53,
}
conn, err := net.DialUDP("udp", laddr, raddr)
if err != nil {
continue
}
defer conn.Close()
_, err = conn.Write(req)
if err != nil {
continue
}
if err = conn.SetReadDeadline(time.Now().Add(time.Minute)); err != nil {
continue
}
var n int
buf := make([]byte, bufSize)
n, err = conn.Read(buf)
if err != nil {
continue
}
if n > 0 {
rsp = append(rsp, buf[:n]...)
if _, err = dnsConn.WriteToUDP(rsp, from); err != nil {
klog.Errorf("[EdgeMesh] failed to wirte to udp, err: %v", err)
continue
}
break
}
}
}
// parseNameServer gets all real nameservers from the resolv.conf
func parseNameServer() ([]net.IP, error) {
file, err := os.Open("/etc/resolv.conf")
if err != nil {
return nil, fmt.Errorf("error opening /etc/resolv.conf: %v", err)
}
defer file.Close()
scan := bufio.NewScanner(file)
scan.Split(bufio.ScanLines)
ip := make([]net.IP, 0)
for scan.Scan() {
serverString := scan.Text()
if strings.Contains(serverString, "nameserver") {
tmpString := strings.Replace(serverString, "nameserver", "", 1)
nameserver := strings.TrimSpace(tmpString)
sip := net.ParseIP(nameserver)
if sip != nil && !sip.Equal(config.Config.ListenIP) {
ip = append(ip, sip)
}
}
}
if len(ip) == 0 {
return nil, fmt.Errorf("there is no nameserver in /etc/resolv.conf")
}
return ip, nil
}
// modifyRspPrefix generates a dns response head
func modifyRspPrefix(que *dnsQuestion) (pre []byte) {
if que == nil {
return
}
// use head in que
rspHead := que.head
rspHead.convertQueryRsp(true)
if que.qType == aRecord {
rspHead.setAnswerNum(1)
} else {
rspHead.setAnswerNum(0)
}
rspHead.setRspRCode(que)
pre = rspHead.getByteFromDNSHeader()
pre = append(pre, que.queByte...)
return
}
// convertQueryRsp converts a dns question head to a response head
func (h *dnsHeader) convertQueryRsp(isRsp bool) {
if isRsp {
h.flags |= dnsQR
}
}
// setAnswerNum sets the answer num for dns head
func (h *dnsHeader) setAnswerNum(num uint16) | {
h.anCount = num
} | identifier_body |
|
getprimers.py | df_primers_dups = pd.read_excel(self.excel_file, header=0, parse_cols='A:M, O:X', skiprows=2,
names=['Gene', 'Exon', 'Direction', 'Version', 'Primer_seq', 'Chrom', 'M13_tag',
'Batch', 'project', 'Order_date', 'Frag_size', 'anneal_temp', 'Other',
'snp_check', 'no_snps', 'rs', 'hgvs', 'freq', 'ss', 'ss_proj', 'other2',
'action_to_take', 'check_by'],
sheetname=sheetname, index_col=None)
to_drop = ['Version', 'M13_tag', 'Batch', 'project', 'Order_date', 'Frag_size', 'anneal_temp', 'Other',
'snp_check', 'no_snps', 'rs', 'hgvs', 'freq', 'ss', 'ss_proj', 'other2', 'action_to_take',
'check_by']
df_primers_dups = df_primers_dups.where((pd.notnull(df_primers_dups)), None) # easier to work with than NaN
df_primers = df_primers_dups.drop(to_drop, axis=1)
df_primers = df_primers.drop_duplicates(subset=('Gene', 'Exon', 'Direction', 'Chrom'))
df_primers = df_primers.reset_index(drop=True)
return df_primers_dups, df_primers
def run_pcr(self, csv):
"""Runs virtual PCR on a CSV file using the isPcr and pslToBed tools installed from UCSC.
:param csv: a csv file is need as an input with format "name, forward, reverse".
:return bedfile: with results of virtual PCR if there is a match.
"""
print "Running virtual PCR..."
chromosomes = ['chr1.2bit', 'chr11.2bit', 'chr12.2bit', 'chrX.2bit', 'chr13.2bit', 'chr14.2bit', 'chr15.2bit',
'chr16.2bit', 'chr17.2bit', 'chr18.2bit', 'chr19.2bit', 'chr20.2bit', 'chr21.2bit', 'chr22.2bit',
'chr2.2bit', 'chr3.2bit', 'chr4.2bit', 'chr5.2bit', 'chr6.2bit', 'chr7.2bit', 'chr8.2bit',
'chr9.2bit', 'chr10.2bit', 'chrY.2bit']
for chr in chromosomes:
os.system(
"/opt/kentools/isPcr -out=psl /media/genomicdata/ucsc_hg19_by_chr/2bit_chr/%s \
%s %s.tmp.psl" % (chr, csv, chr[:-5]))
pslfile = "%s.tmp.psl" % chr[:-5]
bedfile = "%s.tmp.bed" % chr[:-5]
# Only converts a non-empty psl file to a bed file, and removes all psl files in folder.
if os.path.getsize(pslfile) != 0:
os.system("/opt/kentools/pslToBed %s %s" % (pslfile, bedfile))
os.system("rm %s" % pslfile)
return bedfile
else:
os.system("rm %s" % pslfile)
def get_coords(self, df_primers):
"""Generates csv file for virtual PCR and imports results into a pandas data frame.
:param df_primers: data frame of primer data.
:return df_coords: data frame with chromosome, start and end coordinates, and a name
(format "Gene_ExonDirection") for each primer.
"""
primer_list = []
names_dup = []
names = []
exons = []
dirs = []
start_coords = []
end_coords = []
chroms = []
seq_position = 0
list_position = 0
primer_seqs = pd.DataFrame([])
csv = '%s.csv' % self.excel_file[:-5]
csv = csv.replace(" ", "")
# (1) Gets sequences, exons and directions, splits the sequences into F+R and combines into series and then csv.
for row_index, row in df_primers.iterrows():
primer_list.append(str(row['Primer_seq']))
names_dup.append(str(row['Gene']) + '_' + str(row['Exon']) + str(row['Direction']))
exons.append(str(row['Exon']))
dirs.append(str(row['Direction']))
for item in names_dup:
if item not in names:
names.append(item)
forwards = primer_list[::2]
reverses = primer_list[1::2]
while list_position < len(forwards):
ser = pd.Series([names[list_position], forwards[list_position], reverses[list_position]])
primer_seqs = primer_seqs.append(ser, ignore_index=True)
list_position += 1
primer_seqs.to_csv(csv, header=None, index=None, sep='\t')
# (2) Runs virtual PCR on generated csv.
bedfile = self.run_pcr(csv)
tool = BedTool(bedfile)
# (3) Uses results to calculate start and end position of each primer (results give PCR product). Adds to df.
for row in tool:
chroms.append(row.chrom)
start_coords.append(row.start)
end_coords.append(row.start + len(primer_list[seq_position]))
chroms.append(row.chrom)
end_coords.append(row.end)
start_coords.append(row.end - len(primer_list[seq_position + 1]))
seq_position += 1
df_coords = pd.DataFrame([])
df_coords.insert(0, 'chrom', chroms)
df_coords.insert(1, 'start', start_coords)
df_coords.insert(2, 'end', end_coords)
df_coords.insert(3, 'name', names)
# (4) Generates a bed file from df_coords (not currently used in application).
bed = os.path.splitext(bedfile)[0]
df_coords.to_csv('%s.csv' % bed, header=None, index=None, sep='\t') # cannot directly convert to bed.
csv_file = BedTool('%s.csv' % bed)
csv_file.saveas('%s.bed' % bed)
df_coords.insert(4, 'Exon', exons) # not need in bed file so added after.
df_coords.insert(5, 'Direction', dirs)
# Removes unnecessary files and moves BED file into shared folder. (add /tests for unit testing)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s.csv" % bed)
os.system("mv /home/cuser/PycharmProjects/django_apps/mysite/%s.bed /media/sf_sarah_share/bedfiles" %
bed)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s" % csv)
return df_coords
def col_to_string(self, row):
"""Converts values in the Exon column into string values which makes merging data frames easier.
:param row: for every row in Exon column.
:return string of value.
"""
return str(row['Exon'])
def combine_coords_primers(self, df_coords, df_primers_dups):
"""Adds primer coordinates to original df_primers_dups data frame.
:param df_primers_dups: data frame with primer data from excel.
:param df_coords: data frame with chrom, start, end, name, exon, direction.
:return df_combined: data frame of merge between df_coords and df_primers_dups.
:return gene_name: this will be added to the Genes table and used to check if already in database.
"""
df_coords['Exon'] = df_coords.apply(self.col_to_string, axis=1)
df_primers_dups['Exon'] = df_primers_dups.apply(self.col_to_string, axis=1)
# Merge based on Exon and Direction columns
df_combined = pd.merge(df_primers_dups, df_coords, how='left', on=['Exon', 'Direction'])
# There is already a Chromosome column in df_primers_dups
cols_to_drop = ['chrom']
df_combined = df_combined.drop(cols_to_drop, axis=1)
gene_name = df_combined.get_value(0, 'Gene')
return df_combined, gene_name
def check_in_db(self, gene):
"""Queries the database to check if data for a particular gene is already present.
:param gene: a gene name to check against the database.
:return result: query result which will be a gene if already in database and None if not.
"""
curs.execute("SELECT Gene FROM Genes WHERE Gene LIKE '%s'" % gene)
result = curs.fetchone()
return result
def to_db(self, df_combined, gene_name):
"""Creates tables and | :param sheetname: sheet data to be extracted from
:return df_primers_dups: data frame containing extracted data which may include duplicates.
:return df_primers: data frame containing only data necessary to get genome coordinates.
""" | random_line_split |
|
getprimers.py | ps', 'rs', 'hgvs', 'freq', 'ss', 'ss_proj', 'other2',
'action_to_take', 'check_by'],
sheetname=sheetname, index_col=None)
to_drop = ['Version', 'M13_tag', 'Batch', 'project', 'Order_date', 'Frag_size', 'anneal_temp', 'Other',
'snp_check', 'no_snps', 'rs', 'hgvs', 'freq', 'ss', 'ss_proj', 'other2', 'action_to_take',
'check_by']
df_primers_dups = df_primers_dups.where((pd.notnull(df_primers_dups)), None) # easier to work with than NaN
df_primers = df_primers_dups.drop(to_drop, axis=1)
df_primers = df_primers.drop_duplicates(subset=('Gene', 'Exon', 'Direction', 'Chrom'))
df_primers = df_primers.reset_index(drop=True)
return df_primers_dups, df_primers
def | (self, csv):
"""Runs virtual PCR on a CSV file using the isPcr and pslToBed tools installed from UCSC.
:param csv: a csv file is need as an input with format "name, forward, reverse".
:return bedfile: with results of virtual PCR if there is a match.
"""
print "Running virtual PCR..."
chromosomes = ['chr1.2bit', 'chr11.2bit', 'chr12.2bit', 'chrX.2bit', 'chr13.2bit', 'chr14.2bit', 'chr15.2bit',
'chr16.2bit', 'chr17.2bit', 'chr18.2bit', 'chr19.2bit', 'chr20.2bit', 'chr21.2bit', 'chr22.2bit',
'chr2.2bit', 'chr3.2bit', 'chr4.2bit', 'chr5.2bit', 'chr6.2bit', 'chr7.2bit', 'chr8.2bit',
'chr9.2bit', 'chr10.2bit', 'chrY.2bit']
for chr in chromosomes:
os.system(
"/opt/kentools/isPcr -out=psl /media/genomicdata/ucsc_hg19_by_chr/2bit_chr/%s \
%s %s.tmp.psl" % (chr, csv, chr[:-5]))
pslfile = "%s.tmp.psl" % chr[:-5]
bedfile = "%s.tmp.bed" % chr[:-5]
# Only converts a non-empty psl file to a bed file, and removes all psl files in folder.
if os.path.getsize(pslfile) != 0:
os.system("/opt/kentools/pslToBed %s %s" % (pslfile, bedfile))
os.system("rm %s" % pslfile)
return bedfile
else:
os.system("rm %s" % pslfile)
def get_coords(self, df_primers):
"""Generates csv file for virtual PCR and imports results into a pandas data frame.
:param df_primers: data frame of primer data.
:return df_coords: data frame with chromosome, start and end coordinates, and a name
(format "Gene_ExonDirection") for each primer.
"""
primer_list = []
names_dup = []
names = []
exons = []
dirs = []
start_coords = []
end_coords = []
chroms = []
seq_position = 0
list_position = 0
primer_seqs = pd.DataFrame([])
csv = '%s.csv' % self.excel_file[:-5]
csv = csv.replace(" ", "")
# (1) Gets sequences, exons and directions, splits the sequences into F+R and combines into series and then csv.
for row_index, row in df_primers.iterrows():
primer_list.append(str(row['Primer_seq']))
names_dup.append(str(row['Gene']) + '_' + str(row['Exon']) + str(row['Direction']))
exons.append(str(row['Exon']))
dirs.append(str(row['Direction']))
for item in names_dup:
if item not in names:
names.append(item)
forwards = primer_list[::2]
reverses = primer_list[1::2]
while list_position < len(forwards):
ser = pd.Series([names[list_position], forwards[list_position], reverses[list_position]])
primer_seqs = primer_seqs.append(ser, ignore_index=True)
list_position += 1
primer_seqs.to_csv(csv, header=None, index=None, sep='\t')
# (2) Runs virtual PCR on generated csv.
bedfile = self.run_pcr(csv)
tool = BedTool(bedfile)
# (3) Uses results to calculate start and end position of each primer (results give PCR product). Adds to df.
for row in tool:
chroms.append(row.chrom)
start_coords.append(row.start)
end_coords.append(row.start + len(primer_list[seq_position]))
chroms.append(row.chrom)
end_coords.append(row.end)
start_coords.append(row.end - len(primer_list[seq_position + 1]))
seq_position += 1
df_coords = pd.DataFrame([])
df_coords.insert(0, 'chrom', chroms)
df_coords.insert(1, 'start', start_coords)
df_coords.insert(2, 'end', end_coords)
df_coords.insert(3, 'name', names)
# (4) Generates a bed file from df_coords (not currently used in application).
bed = os.path.splitext(bedfile)[0]
df_coords.to_csv('%s.csv' % bed, header=None, index=None, sep='\t') # cannot directly convert to bed.
csv_file = BedTool('%s.csv' % bed)
csv_file.saveas('%s.bed' % bed)
df_coords.insert(4, 'Exon', exons) # not need in bed file so added after.
df_coords.insert(5, 'Direction', dirs)
# Removes unnecessary files and moves BED file into shared folder. (add /tests for unit testing)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s.csv" % bed)
os.system("mv /home/cuser/PycharmProjects/django_apps/mysite/%s.bed /media/sf_sarah_share/bedfiles" %
bed)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s" % csv)
return df_coords
def col_to_string(self, row):
"""Converts values in the Exon column into string values which makes merging data frames easier.
:param row: for every row in Exon column.
:return string of value.
"""
return str(row['Exon'])
def combine_coords_primers(self, df_coords, df_primers_dups):
"""Adds primer coordinates to original df_primers_dups data frame.
:param df_primers_dups: data frame with primer data from excel.
:param df_coords: data frame with chrom, start, end, name, exon, direction.
:return df_combined: data frame of merge between df_coords and df_primers_dups.
:return gene_name: this will be added to the Genes table and used to check if already in database.
"""
df_coords['Exon'] = df_coords.apply(self.col_to_string, axis=1)
df_primers_dups['Exon'] = df_primers_dups.apply(self.col_to_string, axis=1)
# Merge based on Exon and Direction columns
df_combined = pd.merge(df_primers_dups, df_coords, how='left', on=['Exon', 'Direction'])
# There is already a Chromosome column in df_primers_dups
cols_to_drop = ['chrom']
df_combined = df_combined.drop(cols_to_drop, axis=1)
gene_name = df_combined.get_value(0, 'Gene')
return df_combined, gene_name
def check_in_db(self, gene):
"""Queries the database to check if data for a particular gene is already present.
:param gene: a gene name to check against the database.
:return result: query result which will be a gene if already in database and None if not.
"""
curs.execute("SELECT Gene FROM Genes WHERE Gene LIKE '%s'" % gene)
result = curs.fetchone()
return result
def to_db(self, df_combined, gene_name):
"""Creates tables and adds data into the database.
Function modifies the given data frame to generate three tables in the database (Primers, SNPs, Genes) and
performs data checks. If data for a particular gene is already in the database, this is overridden and the
previous data is saved to an excel document (archived_files).
The commented out section should only be used for the first file to initially set up the tables.
:param gene_name: gene to check against database.
:param df_combined: data frame to be inserted into database.
:return info: description of action performed (for audit log).
:return archived_filename: filename the previous data is saved under (for audit log).
| run_pcr | identifier_name |
getprimers.py | ps', 'rs', 'hgvs', 'freq', 'ss', 'ss_proj', 'other2',
'action_to_take', 'check_by'],
sheetname=sheetname, index_col=None)
to_drop = ['Version', 'M13_tag', 'Batch', 'project', 'Order_date', 'Frag_size', 'anneal_temp', 'Other',
'snp_check', 'no_snps', 'rs', 'hgvs', 'freq', 'ss', 'ss_proj', 'other2', 'action_to_take',
'check_by']
df_primers_dups = df_primers_dups.where((pd.notnull(df_primers_dups)), None) # easier to work with than NaN
df_primers = df_primers_dups.drop(to_drop, axis=1)
df_primers = df_primers.drop_duplicates(subset=('Gene', 'Exon', 'Direction', 'Chrom'))
df_primers = df_primers.reset_index(drop=True)
return df_primers_dups, df_primers
def run_pcr(self, csv):
"""Runs virtual PCR on a CSV file using the isPcr and pslToBed tools installed from UCSC.
:param csv: a csv file is need as an input with format "name, forward, reverse".
:return bedfile: with results of virtual PCR if there is a match.
"""
print "Running virtual PCR..."
chromosomes = ['chr1.2bit', 'chr11.2bit', 'chr12.2bit', 'chrX.2bit', 'chr13.2bit', 'chr14.2bit', 'chr15.2bit',
'chr16.2bit', 'chr17.2bit', 'chr18.2bit', 'chr19.2bit', 'chr20.2bit', 'chr21.2bit', 'chr22.2bit',
'chr2.2bit', 'chr3.2bit', 'chr4.2bit', 'chr5.2bit', 'chr6.2bit', 'chr7.2bit', 'chr8.2bit',
'chr9.2bit', 'chr10.2bit', 'chrY.2bit']
for chr in chromosomes:
os.system(
"/opt/kentools/isPcr -out=psl /media/genomicdata/ucsc_hg19_by_chr/2bit_chr/%s \
%s %s.tmp.psl" % (chr, csv, chr[:-5]))
pslfile = "%s.tmp.psl" % chr[:-5]
bedfile = "%s.tmp.bed" % chr[:-5]
# Only converts a non-empty psl file to a bed file, and removes all psl files in folder.
if os.path.getsize(pslfile) != 0:
os.system("/opt/kentools/pslToBed %s %s" % (pslfile, bedfile))
os.system("rm %s" % pslfile)
return bedfile
else:
os.system("rm %s" % pslfile)
def get_coords(self, df_primers):
"""Generates csv file for virtual PCR and imports results into a pandas data frame.
:param df_primers: data frame of primer data.
:return df_coords: data frame with chromosome, start and end coordinates, and a name
(format "Gene_ExonDirection") for each primer.
"""
primer_list = []
names_dup = []
names = []
exons = []
dirs = []
start_coords = []
end_coords = []
chroms = []
seq_position = 0
list_position = 0
primer_seqs = pd.DataFrame([])
csv = '%s.csv' % self.excel_file[:-5]
csv = csv.replace(" ", "")
# (1) Gets sequences, exons and directions, splits the sequences into F+R and combines into series and then csv.
for row_index, row in df_primers.iterrows():
primer_list.append(str(row['Primer_seq']))
names_dup.append(str(row['Gene']) + '_' + str(row['Exon']) + str(row['Direction']))
exons.append(str(row['Exon']))
dirs.append(str(row['Direction']))
for item in names_dup:
if item not in names:
|
forwards = primer_list[::2]
reverses = primer_list[1::2]
while list_position < len(forwards):
ser = pd.Series([names[list_position], forwards[list_position], reverses[list_position]])
primer_seqs = primer_seqs.append(ser, ignore_index=True)
list_position += 1
primer_seqs.to_csv(csv, header=None, index=None, sep='\t')
# (2) Runs virtual PCR on generated csv.
bedfile = self.run_pcr(csv)
tool = BedTool(bedfile)
# (3) Uses results to calculate start and end position of each primer (results give PCR product). Adds to df.
for row in tool:
chroms.append(row.chrom)
start_coords.append(row.start)
end_coords.append(row.start + len(primer_list[seq_position]))
chroms.append(row.chrom)
end_coords.append(row.end)
start_coords.append(row.end - len(primer_list[seq_position + 1]))
seq_position += 1
df_coords = pd.DataFrame([])
df_coords.insert(0, 'chrom', chroms)
df_coords.insert(1, 'start', start_coords)
df_coords.insert(2, 'end', end_coords)
df_coords.insert(3, 'name', names)
# (4) Generates a bed file from df_coords (not currently used in application).
bed = os.path.splitext(bedfile)[0]
df_coords.to_csv('%s.csv' % bed, header=None, index=None, sep='\t') # cannot directly convert to bed.
csv_file = BedTool('%s.csv' % bed)
csv_file.saveas('%s.bed' % bed)
df_coords.insert(4, 'Exon', exons) # not need in bed file so added after.
df_coords.insert(5, 'Direction', dirs)
# Removes unnecessary files and moves BED file into shared folder. (add /tests for unit testing)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s.csv" % bed)
os.system("mv /home/cuser/PycharmProjects/django_apps/mysite/%s.bed /media/sf_sarah_share/bedfiles" %
bed)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s" % csv)
return df_coords
def col_to_string(self, row):
"""Converts values in the Exon column into string values which makes merging data frames easier.
:param row: for every row in Exon column.
:return string of value.
"""
return str(row['Exon'])
def combine_coords_primers(self, df_coords, df_primers_dups):
"""Adds primer coordinates to original df_primers_dups data frame.
:param df_primers_dups: data frame with primer data from excel.
:param df_coords: data frame with chrom, start, end, name, exon, direction.
:return df_combined: data frame of merge between df_coords and df_primers_dups.
:return gene_name: this will be added to the Genes table and used to check if already in database.
"""
df_coords['Exon'] = df_coords.apply(self.col_to_string, axis=1)
df_primers_dups['Exon'] = df_primers_dups.apply(self.col_to_string, axis=1)
# Merge based on Exon and Direction columns
df_combined = pd.merge(df_primers_dups, df_coords, how='left', on=['Exon', 'Direction'])
# There is already a Chromosome column in df_primers_dups
cols_to_drop = ['chrom']
df_combined = df_combined.drop(cols_to_drop, axis=1)
gene_name = df_combined.get_value(0, 'Gene')
return df_combined, gene_name
def check_in_db(self, gene):
"""Queries the database to check if data for a particular gene is already present.
:param gene: a gene name to check against the database.
:return result: query result which will be a gene if already in database and None if not.
"""
curs.execute("SELECT Gene FROM Genes WHERE Gene LIKE '%s'" % gene)
result = curs.fetchone()
return result
def to_db(self, df_combined, gene_name):
"""Creates tables and adds data into the database.
Function modifies the given data frame to generate three tables in the database (Primers, SNPs, Genes) and
performs data checks. If data for a particular gene is already in the database, this is overridden and the
previous data is saved to an excel document (archived_files).
The commented out section should only be used for the first file to initially set up the tables.
:param gene_name: gene to check against database.
:param df_combined: data frame to be inserted into database.
:return info: description of action performed (for audit log).
:return archived_filename: filename the previous data is saved under (for audit log).
| names.append(item) | conditional_block |
getprimers.py | Chrom'))
df_primers = df_primers.reset_index(drop=True)
return df_primers_dups, df_primers
def run_pcr(self, csv):
"""Runs virtual PCR on a CSV file using the isPcr and pslToBed tools installed from UCSC.
:param csv: a csv file is need as an input with format "name, forward, reverse".
:return bedfile: with results of virtual PCR if there is a match.
"""
print "Running virtual PCR..."
chromosomes = ['chr1.2bit', 'chr11.2bit', 'chr12.2bit', 'chrX.2bit', 'chr13.2bit', 'chr14.2bit', 'chr15.2bit',
'chr16.2bit', 'chr17.2bit', 'chr18.2bit', 'chr19.2bit', 'chr20.2bit', 'chr21.2bit', 'chr22.2bit',
'chr2.2bit', 'chr3.2bit', 'chr4.2bit', 'chr5.2bit', 'chr6.2bit', 'chr7.2bit', 'chr8.2bit',
'chr9.2bit', 'chr10.2bit', 'chrY.2bit']
for chr in chromosomes:
os.system(
"/opt/kentools/isPcr -out=psl /media/genomicdata/ucsc_hg19_by_chr/2bit_chr/%s \
%s %s.tmp.psl" % (chr, csv, chr[:-5]))
pslfile = "%s.tmp.psl" % chr[:-5]
bedfile = "%s.tmp.bed" % chr[:-5]
# Only converts a non-empty psl file to a bed file, and removes all psl files in folder.
if os.path.getsize(pslfile) != 0:
os.system("/opt/kentools/pslToBed %s %s" % (pslfile, bedfile))
os.system("rm %s" % pslfile)
return bedfile
else:
os.system("rm %s" % pslfile)
def get_coords(self, df_primers):
"""Generates csv file for virtual PCR and imports results into a pandas data frame.
:param df_primers: data frame of primer data.
:return df_coords: data frame with chromosome, start and end coordinates, and a name
(format "Gene_ExonDirection") for each primer.
"""
primer_list = []
names_dup = []
names = []
exons = []
dirs = []
start_coords = []
end_coords = []
chroms = []
seq_position = 0
list_position = 0
primer_seqs = pd.DataFrame([])
csv = '%s.csv' % self.excel_file[:-5]
csv = csv.replace(" ", "")
# (1) Gets sequences, exons and directions, splits the sequences into F+R and combines into series and then csv.
for row_index, row in df_primers.iterrows():
primer_list.append(str(row['Primer_seq']))
names_dup.append(str(row['Gene']) + '_' + str(row['Exon']) + str(row['Direction']))
exons.append(str(row['Exon']))
dirs.append(str(row['Direction']))
for item in names_dup:
if item not in names:
names.append(item)
forwards = primer_list[::2]
reverses = primer_list[1::2]
while list_position < len(forwards):
ser = pd.Series([names[list_position], forwards[list_position], reverses[list_position]])
primer_seqs = primer_seqs.append(ser, ignore_index=True)
list_position += 1
primer_seqs.to_csv(csv, header=None, index=None, sep='\t')
# (2) Runs virtual PCR on generated csv.
bedfile = self.run_pcr(csv)
tool = BedTool(bedfile)
# (3) Uses results to calculate start and end position of each primer (results give PCR product). Adds to df.
for row in tool:
chroms.append(row.chrom)
start_coords.append(row.start)
end_coords.append(row.start + len(primer_list[seq_position]))
chroms.append(row.chrom)
end_coords.append(row.end)
start_coords.append(row.end - len(primer_list[seq_position + 1]))
seq_position += 1
df_coords = pd.DataFrame([])
df_coords.insert(0, 'chrom', chroms)
df_coords.insert(1, 'start', start_coords)
df_coords.insert(2, 'end', end_coords)
df_coords.insert(3, 'name', names)
# (4) Generates a bed file from df_coords (not currently used in application).
bed = os.path.splitext(bedfile)[0]
df_coords.to_csv('%s.csv' % bed, header=None, index=None, sep='\t') # cannot directly convert to bed.
csv_file = BedTool('%s.csv' % bed)
csv_file.saveas('%s.bed' % bed)
df_coords.insert(4, 'Exon', exons) # not need in bed file so added after.
df_coords.insert(5, 'Direction', dirs)
# Removes unnecessary files and moves BED file into shared folder. (add /tests for unit testing)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s.csv" % bed)
os.system("mv /home/cuser/PycharmProjects/django_apps/mysite/%s.bed /media/sf_sarah_share/bedfiles" %
bed)
os.system("rm /home/cuser/PycharmProjects/django_apps/mysite/%s" % csv)
return df_coords
def col_to_string(self, row):
"""Converts values in the Exon column into string values which makes merging data frames easier.
:param row: for every row in Exon column.
:return string of value.
"""
return str(row['Exon'])
def combine_coords_primers(self, df_coords, df_primers_dups):
"""Adds primer coordinates to original df_primers_dups data frame.
:param df_primers_dups: data frame with primer data from excel.
:param df_coords: data frame with chrom, start, end, name, exon, direction.
:return df_combined: data frame of merge between df_coords and df_primers_dups.
:return gene_name: this will be added to the Genes table and used to check if already in database.
"""
df_coords['Exon'] = df_coords.apply(self.col_to_string, axis=1)
df_primers_dups['Exon'] = df_primers_dups.apply(self.col_to_string, axis=1)
# Merge based on Exon and Direction columns
df_combined = pd.merge(df_primers_dups, df_coords, how='left', on=['Exon', 'Direction'])
# There is already a Chromosome column in df_primers_dups
cols_to_drop = ['chrom']
df_combined = df_combined.drop(cols_to_drop, axis=1)
gene_name = df_combined.get_value(0, 'Gene')
return df_combined, gene_name
def check_in_db(self, gene):
"""Queries the database to check if data for a particular gene is already present.
:param gene: a gene name to check against the database.
:return result: query result which will be a gene if already in database and None if not.
"""
curs.execute("SELECT Gene FROM Genes WHERE Gene LIKE '%s'" % gene)
result = curs.fetchone()
return result
def to_db(self, df_combined, gene_name):
| """Creates tables and adds data into the database.
Function modifies the given data frame to generate three tables in the database (Primers, SNPs, Genes) and
performs data checks. If data for a particular gene is already in the database, this is overridden and the
previous data is saved to an excel document (archived_files).
The commented out section should only be used for the first file to initially set up the tables.
:param gene_name: gene to check against database.
:param df_combined: data frame to be inserted into database.
:return info: description of action performed (for audit log).
:return archived_filename: filename the previous data is saved under (for audit log).
"""
# (1) Creates database schema
curs.execute("CREATE TABLE IF NOT EXISTS Primers(PrimerId INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "
"Gene TEXT, Exon TEXT, Direction TEXT, Version INTEGER, Primer_Seq TEXT, Chrom TEXT, M13_Tag TEXT"
", Batch TEXT, Project TEXT, Order_date TEXT, Frag_size INTEGER, Anneal_Temp TEXT, Other TEXT, "
"snp_check INTEGER, no_snps INTEGER, rs TEXT, hgvs TEXT, freq TEXT, ss TEXT, ss_proj TEXT, "
"other2 TEXT, action_to_take TEXT, check_by TEXT, start TEXT, end TEXT, name TEXT)")
curs.execute("CREATE TABLE IF NOT EXISTS SNPs(SNP_Id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, Gene TEXT, "
"Exon TEXT, Direction TEXT, snp_check INTEGER, rs TEXT, hgvs TEXT, freq TEXT, ss TEXT, " | identifier_body |
|
lib.rs | _void, _>(null_mut()))
}
#[repr(C)]
#[derive(Debug)]
pub enum RawType
{
Null,
Bool,
Uint64,
Int64,
Double,
Date,
String,
Binary,
Fd,
Dictionary,
Array,
Error,
}
#[repr(C)]
#[derive(Debug)]
pub enum CallStatus
{
InProgress,
MoreAvailable,
Done,
Error,
Aborted,
Ended
}
pub enum RawObject {}
pub enum RawConnection {}
pub enum RawClient {}
pub enum RawCall {}
pub struct Object
{
value: *mut RawObject,
}
pub struct Connection
{
value: *mut RawConnection
}
pub struct Client
{
value: *mut RawClient,
connection: Connection
}
pub struct Call<'a>
{
connection: &'a Connection,
value: *mut RawCall
}
pub struct Instance<'a>
{
connection: &'a Connection,
path: String
}
pub struct Interface<'a>
{
instance: &'a Instance<'a>,
name: String
}
#[derive(Clone, Debug)]
pub enum Value
{
Null,
Bool(bool),
Uint64(u64),
Int64(i64),
Double(f64),
Date(u64),
String(String),
Binary(Vec<u8>),
Array(Vec<Value>),
Dictionary(HashMap<String, Value>),
Object(Object),
Fd(i32),
Error(Error)
}
#[derive(Clone, Debug)]
pub struct |
{
code: u32,
message: String,
stack_trace: Box<Value>,
extra: Box<Value>
}
#[link(name = "rpc")]
extern {
/* rpc/object.h */
pub fn rpc_get_type(value: *mut RawObject) -> RawType;
pub fn rpc_hash(value: *mut RawObject) -> u32;
pub fn rpc_null_create() -> *mut RawObject;
pub fn rpc_bool_create(value: bool) -> *mut RawObject;
pub fn rpc_bool_get_value(value: *mut RawObject) -> bool;
pub fn rpc_uint64_create(value: u64) -> *mut RawObject;
pub fn rpc_uint64_get_value(value: *mut RawObject) -> u64;
pub fn rpc_int64_create(value: i64) -> *mut RawObject;
pub fn rpc_int64_get_value(value: *mut RawObject) -> i64;
pub fn rpc_double_create(value: f64) -> *mut RawObject;
pub fn rpc_double_get_value(value: *mut RawObject) -> f64;
pub fn rpc_date_create(value: u64) -> *mut RawObject;
pub fn rpc_date_get_value(obj: *mut RawObject) -> u64;
pub fn rpc_string_create(value: *const c_char) -> *mut RawObject;
pub fn rpc_string_get_string_ptr(value: *mut RawObject) -> *const c_char;
pub fn rpc_data_create(ptr: *const u8, len: usize, dtor: *const c_void) -> *mut RawObject;
pub fn rpc_array_create() -> *mut RawObject;
pub fn rpc_dictionary_create() -> *mut RawObject;
pub fn rpc_array_append_value(obj: *mut RawObject, value: *mut RawObject);
pub fn rpc_dictionary_set_value(obj: *mut RawObject, key: *const c_char, value: *mut RawObject);
pub fn rpc_fd_create(value: i32) -> *mut RawObject;
pub fn rpc_fd_get_value(obj: *mut RawObject) -> i32;
pub fn rpc_copy_description(value: *mut RawObject) -> *mut c_char;
pub fn rpc_retain(value: *mut RawObject) -> *mut RawObject;
pub fn rpc_release_impl(value: *mut RawObject);
/* rpc/connection.h */
pub fn rpc_connection_call(conn: *mut RawConnection, path: *const c_char,
interface: *const c_char, name: *const c_char,
args: *const RawObject,
callback: &Block<(*mut RawCall,), bool>) -> *mut RawCall;
pub fn rpc_call_status(call: *mut RawCall) -> CallStatus;
pub fn rpc_call_result(call: *mut RawCall) -> *mut RawObject;
pub fn rpc_call_continue(call: *mut RawCall);
pub fn rpc_call_abort(call: *mut RawCall);
pub fn rpc_call_wait(call: *mut RawCall);
/* rpc/client.h */
pub fn rpc_client_create(uri: *const c_char, params: *const RawObject) -> *mut RawClient;
pub fn rpc_client_get_connection(client: *mut RawClient) -> *mut RawConnection;
}
pub trait Create<T> {
fn create(value: T) -> Object;
}
impl Clone for Object {
fn clone(&self) -> Object {
unsafe {
return Object { value: rpc_retain(self.value) }
}
}
}
impl Drop for Object {
fn drop(&mut self) {
unsafe {
rpc_release_impl(self.value)
}
}
}
impl<T> Create<T> for Object where Value: std::convert::From<T> {
fn create(value: T) -> Object {
Object::new(Value::from(value))
}
}
impl From<bool> for Value {
fn from(value: bool) -> Value {
Value::Bool(value)
}
}
impl From<u64> for Value {
fn from(value: u64) -> Value {
Value::Uint64(value)
}
}
impl From<i64> for Value {
fn from(value: i64) -> Value {
Value::Int64(value)
}
}
impl From<f64> for Value {
fn from(value: f64) -> Value {
Value::Double(value)
}
}
impl<'a> From<&'a str> for Value {
fn from(value: &str) -> Value {
Value::String(String::from(value))
}
}
impl From<String> for Value {
fn from(value: String) -> Value {
Value::String(value)
}
}
impl From<Vec<u8>> for Value {
fn from(value: Vec<u8>) -> Value {
Value::Binary(value)
}
}
impl<'a> From<&'a [Value]> for Value {
fn from(value: &[Value]) -> Value {
Value::Array(value.to_vec())
}
}
impl From<Vec<Value>> for Value {
fn from(value: Vec<Value>) -> Value {
Value::Array(value)
}
}
impl<'a> From<HashMap<&'a str, Value>> for Value {
fn from(value: HashMap<&str, Value>) -> Value {
Value::Dictionary(value.iter().map( | ( & k, v) |
(String::from(k), v.clone())
).collect())
}
}
impl From<HashMap<String, Value>> for Value {
fn from(value: HashMap<String, Value>) -> Value {
Value::Dictionary(value)
}
}
impl Object {
pub fn new(value: Value) -> Object {
unsafe {
let obj = match value {
Value::Null => rpc_null_create(),
Value::Bool(val) => rpc_bool_create(val),
Value::Uint64(val) => rpc_uint64_create(val),
Value::Int64(val) => rpc_int64_create(val),
Value::Double(val) => rpc_double_create(val),
Value::Date(val) => rpc_date_create(val),
Value::Fd(val) => rpc_fd_create(val),
Value::Binary(ref val) => rpc_data_create(val.as_ptr(), val.len(), null()),
Value::Object(ref val) => rpc_retain(val.value),
Value::String(ref val) => {
let c_val = to_cstr!(val.as_str());
rpc_string_create(c_val.as_ptr())
},
Value::Array(val) => {
let arr = rpc_array_create();
for i in val {
rpc_array_append_value(arr, Object::new(i).value);
}
arr
},
Value::Dictionary(val) => {
let dict = rpc_dictionary_create();
for (k, v) in val {
let c_key = to_cstr!(k.as_str());
rpc_dictionary_set_value(dict, c_key.as_ptr(), Object::new(v).value);
}
dict
},
Value::Error(val) => {
rpc_null_create()
}
};
return Object { value: obj };
}
}
pub fn get_raw_type(&self) -> RawType {
unsafe {
rpc_get_type(self.value)
}
}
pub fn unpack(&self) -> Value {
unsafe {
match self.get_raw_type() {
RawType::Null => Value::Null,
RawType::Bool => Value::Bool(rpc_bool_get_value(self.value)),
RawType::Uint64 => Value::Uint64(rpc_uint64_get_value(self.value)),
RawType::Int64 => Value::Int64(rpc_int64_get_value(self.value)),
RawType::Double => Value::Double(rpc_double_get_value(self.value)),
RawType::String => Value::String(String::from(CStr::from_ptr(
rpc_string_get_string_ptr(self.value)).to_str().unwrap())),
RawType::Date => Value::Date(rpc_date_get_value(self.value)),
RawType::Binary => Value::Null,
Raw | Error | identifier_name |
lib.rs | c_void, _>(null_mut()))
}
#[repr(C)]
#[derive(Debug)]
pub enum RawType
{
Null,
Bool, | Uint64,
Int64,
Double,
Date,
String,
Binary,
Fd,
Dictionary,
Array,
Error,
}
#[repr(C)]
#[derive(Debug)]
pub enum CallStatus
{
InProgress,
MoreAvailable,
Done,
Error,
Aborted,
Ended
}
pub enum RawObject {}
pub enum RawConnection {}
pub enum RawClient {}
pub enum RawCall {}
pub struct Object
{
value: *mut RawObject,
}
pub struct Connection
{
value: *mut RawConnection
}
pub struct Client
{
value: *mut RawClient,
connection: Connection
}
pub struct Call<'a>
{
connection: &'a Connection,
value: *mut RawCall
}
pub struct Instance<'a>
{
connection: &'a Connection,
path: String
}
pub struct Interface<'a>
{
instance: &'a Instance<'a>,
name: String
}
#[derive(Clone, Debug)]
pub enum Value
{
Null,
Bool(bool),
Uint64(u64),
Int64(i64),
Double(f64),
Date(u64),
String(String),
Binary(Vec<u8>),
Array(Vec<Value>),
Dictionary(HashMap<String, Value>),
Object(Object),
Fd(i32),
Error(Error)
}
#[derive(Clone, Debug)]
pub struct Error
{
code: u32,
message: String,
stack_trace: Box<Value>,
extra: Box<Value>
}
#[link(name = "rpc")]
extern {
/* rpc/object.h */
pub fn rpc_get_type(value: *mut RawObject) -> RawType;
pub fn rpc_hash(value: *mut RawObject) -> u32;
pub fn rpc_null_create() -> *mut RawObject;
pub fn rpc_bool_create(value: bool) -> *mut RawObject;
pub fn rpc_bool_get_value(value: *mut RawObject) -> bool;
pub fn rpc_uint64_create(value: u64) -> *mut RawObject;
pub fn rpc_uint64_get_value(value: *mut RawObject) -> u64;
pub fn rpc_int64_create(value: i64) -> *mut RawObject;
pub fn rpc_int64_get_value(value: *mut RawObject) -> i64;
pub fn rpc_double_create(value: f64) -> *mut RawObject;
pub fn rpc_double_get_value(value: *mut RawObject) -> f64;
pub fn rpc_date_create(value: u64) -> *mut RawObject;
pub fn rpc_date_get_value(obj: *mut RawObject) -> u64;
pub fn rpc_string_create(value: *const c_char) -> *mut RawObject;
pub fn rpc_string_get_string_ptr(value: *mut RawObject) -> *const c_char;
pub fn rpc_data_create(ptr: *const u8, len: usize, dtor: *const c_void) -> *mut RawObject;
pub fn rpc_array_create() -> *mut RawObject;
pub fn rpc_dictionary_create() -> *mut RawObject;
pub fn rpc_array_append_value(obj: *mut RawObject, value: *mut RawObject);
pub fn rpc_dictionary_set_value(obj: *mut RawObject, key: *const c_char, value: *mut RawObject);
pub fn rpc_fd_create(value: i32) -> *mut RawObject;
pub fn rpc_fd_get_value(obj: *mut RawObject) -> i32;
pub fn rpc_copy_description(value: *mut RawObject) -> *mut c_char;
pub fn rpc_retain(value: *mut RawObject) -> *mut RawObject;
pub fn rpc_release_impl(value: *mut RawObject);
/* rpc/connection.h */
pub fn rpc_connection_call(conn: *mut RawConnection, path: *const c_char,
interface: *const c_char, name: *const c_char,
args: *const RawObject,
callback: &Block<(*mut RawCall,), bool>) -> *mut RawCall;
pub fn rpc_call_status(call: *mut RawCall) -> CallStatus;
pub fn rpc_call_result(call: *mut RawCall) -> *mut RawObject;
pub fn rpc_call_continue(call: *mut RawCall);
pub fn rpc_call_abort(call: *mut RawCall);
pub fn rpc_call_wait(call: *mut RawCall);
/* rpc/client.h */
pub fn rpc_client_create(uri: *const c_char, params: *const RawObject) -> *mut RawClient;
pub fn rpc_client_get_connection(client: *mut RawClient) -> *mut RawConnection;
}
pub trait Create<T> {
fn create(value: T) -> Object;
}
impl Clone for Object {
fn clone(&self) -> Object {
unsafe {
return Object { value: rpc_retain(self.value) }
}
}
}
impl Drop for Object {
fn drop(&mut self) {
unsafe {
rpc_release_impl(self.value)
}
}
}
impl<T> Create<T> for Object where Value: std::convert::From<T> {
fn create(value: T) -> Object {
Object::new(Value::from(value))
}
}
impl From<bool> for Value {
fn from(value: bool) -> Value {
Value::Bool(value)
}
}
impl From<u64> for Value {
fn from(value: u64) -> Value {
Value::Uint64(value)
}
}
impl From<i64> for Value {
fn from(value: i64) -> Value {
Value::Int64(value)
}
}
impl From<f64> for Value {
fn from(value: f64) -> Value {
Value::Double(value)
}
}
impl<'a> From<&'a str> for Value {
fn from(value: &str) -> Value {
Value::String(String::from(value))
}
}
impl From<String> for Value {
fn from(value: String) -> Value {
Value::String(value)
}
}
impl From<Vec<u8>> for Value {
fn from(value: Vec<u8>) -> Value {
Value::Binary(value)
}
}
impl<'a> From<&'a [Value]> for Value {
fn from(value: &[Value]) -> Value {
Value::Array(value.to_vec())
}
}
impl From<Vec<Value>> for Value {
fn from(value: Vec<Value>) -> Value {
Value::Array(value)
}
}
impl<'a> From<HashMap<&'a str, Value>> for Value {
fn from(value: HashMap<&str, Value>) -> Value {
Value::Dictionary(value.iter().map( | ( & k, v) |
(String::from(k), v.clone())
).collect())
}
}
impl From<HashMap<String, Value>> for Value {
fn from(value: HashMap<String, Value>) -> Value {
Value::Dictionary(value)
}
}
impl Object {
pub fn new(value: Value) -> Object {
unsafe {
let obj = match value {
Value::Null => rpc_null_create(),
Value::Bool(val) => rpc_bool_create(val),
Value::Uint64(val) => rpc_uint64_create(val),
Value::Int64(val) => rpc_int64_create(val),
Value::Double(val) => rpc_double_create(val),
Value::Date(val) => rpc_date_create(val),
Value::Fd(val) => rpc_fd_create(val),
Value::Binary(ref val) => rpc_data_create(val.as_ptr(), val.len(), null()),
Value::Object(ref val) => rpc_retain(val.value),
Value::String(ref val) => {
let c_val = to_cstr!(val.as_str());
rpc_string_create(c_val.as_ptr())
},
Value::Array(val) => {
let arr = rpc_array_create();
for i in val {
rpc_array_append_value(arr, Object::new(i).value);
}
arr
},
Value::Dictionary(val) => {
let dict = rpc_dictionary_create();
for (k, v) in val {
let c_key = to_cstr!(k.as_str());
rpc_dictionary_set_value(dict, c_key.as_ptr(), Object::new(v).value);
}
dict
},
Value::Error(val) => {
rpc_null_create()
}
};
return Object { value: obj };
}
}
pub fn get_raw_type(&self) -> RawType {
unsafe {
rpc_get_type(self.value)
}
}
pub fn unpack(&self) -> Value {
unsafe {
match self.get_raw_type() {
RawType::Null => Value::Null,
RawType::Bool => Value::Bool(rpc_bool_get_value(self.value)),
RawType::Uint64 => Value::Uint64(rpc_uint64_get_value(self.value)),
RawType::Int64 => Value::Int64(rpc_int64_get_value(self.value)),
RawType::Double => Value::Double(rpc_double_get_value(self.value)),
RawType::String => Value::String(String::from(CStr::from_ptr(
rpc_string_get_string_ptr(self.value)).to_str().unwrap())),
RawType::Date => Value::Date(rpc_date_get_value(self.value)),
RawType::Binary => Value::Null,
Raw | random_line_split |
|
pirep.py | loc2>[A-Z0-9]{3,4})"
)
OV_OFFSET = re.compile(
(
r"(?P<dist>[0-9]{1,3})\s?"
"(?P<dir>NORTH|EAST|SOUTH|WEST|N|NNE|NE|ENE|E|ESE|"
r"SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW)\s+(OF )?(?P<loc>[A-Z0-9]{3,4})"
)
)
DRCT2DIR = {
"N": 0,
"NNE": 22.5,
"NE": 45,
"ENE": 67.5,
"E": 90,
"ESE": 112.5,
"SE": 135,
"SSE": 157.5,
"S": 180,
"SSW": 202.5,
"SW": 225,
"WSW": 247.5,
"W": 270,
"WNW": 292.5,
"NW": 305,
"NNW": 327.5,
"NORTH": 0,
"EAST": 90,
"SOUTH": 180,
"WEST": 270,
}
class Priority(str, Enum):
"""Types of reports."""
def __str__(self):
"""When we want the str repr."""
return str(self.value)
UA = "UA"
UUA = "UUA"
class | (BaseModel):
""" A Pilot Report. """
base_loc: str = None
text: str = None
priority: Priority = None
latitude: float = None
longitude: float = None
valid: datetime.datetime = None
cwsu: str = None
aircraft_type: str = None
is_duplicate: bool = False
class Pirep(product.TextProduct):
""" Class for parsing and representing Space Wx Products. """
def __init__(
self, text, utcnow=None, ugc_provider=None, nwsli_provider=None
):
""" constructor """
product.TextProduct.__init__(
self,
text,
utcnow=utcnow,
ugc_provider=ugc_provider,
nwsli_provider=nwsli_provider,
)
self.reports = []
self.parse_reports()
def parse_reports(self):
"""Actually do the parsing of the product that generates the reports
stored within the self.reports list"""
txt = (
self.unixtext
if self.unixtext[:2] != "\001\n"
else self.unixtext[2:]
)
lines = txt.split("\n")
# There may be an AWIPSID in line 3 or silly aviation control char
pos = 3 if len(lines[2]) < 10 or lines[2].startswith("\x1e") else 2
meat = "".join(lines[pos:])
for report in meat.split("="):
if report.strip() == "":
continue
res = self.process_pirep(" ".join(report.strip().split()))
if res is not None:
self.reports.append(res)
def process_pirep(self, report):
""" Convert this report text into an actual PIREP object """
_pr = PilotReport()
_pr.text = report
for i, token in enumerate(report.split("/")):
token = token.strip()
# First token is always priority
if i == 0:
if len(token) > 10:
LOG.info("Aborting as not-PIREP? |%s|", report)
return
if token.find(" UUA") > 0:
_pr.priority = Priority.UUA
else:
_pr.priority = Priority.UA
parts = token.split()
if len(parts) == 2:
_pr.base_loc = parts[0]
if len(_pr.base_loc) == 4 and _pr.base_loc[0] == "K":
_pr.base_loc = _pr.base_loc[1:]
continue
# Aircraft Type
if token.startswith("TP "):
_pr.aircraft_type = token[3:]
# Location
if token.startswith("OV "):
dist = 0
bearing = 0
therest = token[3:]
if len(therest) == 3:
loc = therest
elif therest.startswith("FINAL RWY"):
loc = report[:8].split()[0]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
elif len(therest) == 4:
if therest[0] == "K":
loc = therest[1:]
else:
loc = therest
elif re.match(OV_OFFSET, therest):
d = re.match(OV_OFFSET, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
dist = int(d["dist"])
bearing = DRCT2DIR[d["dir"]]
elif re.match(OV_LOCDIR, therest):
# KFAR330008
d = re.match(OV_LOCDIR, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
bearing = int(d["dir"])
dist = int(d["dist"])
elif re.match(OV_LATLON, therest):
# 2500N07000W
# FMH-12 says this is in degrees and minutes!
d = re.match(OV_LATLON, therest).groupdict()
_pr.latitude = float(
"%s.%i"
% (
d["lat"][:-2],
int(float(d["lat"][-2:]) / 60.0 * 10000.0),
)
)
if d["latsign"] == "S":
_pr.latitude = 0 - _pr.latitude
_pr.longitude = float(
"%s.%i"
% (
d["lon"][:-2],
int(float(d["lon"][-2:]) / 60.0 * 10000.0),
)
)
if d["lonsign"] == "W":
_pr.longitude = 0 - _pr.longitude
continue
elif therest == "O":
# Use the first part of the report in this case
loc = report[:3]
elif therest.find("-") > 0 and re.match(OV_TWOLOC, therest):
d = re.match(OV_TWOLOC, therest).groupdict()
numbers = re.findall("[0-9]{6}", therest)
if numbers:
bearing = int(numbers[0][:3])
dist = int(numbers[0][3:])
loc = d["loc2"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
else:
# Split the distance between the two points
lats = []
lons = []
for loc in [d["loc1"], d["loc2"]]:
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
if loc not in self.nwsli_provider:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
lats.append(self.nwsli_provider[loc]["lat"])
lons.append(self.nwsli_provider[loc]["lon"])
_pr.latitude = sum(lats) / 2.0
_pr.longitude = sum(lons) / 2.0
continue
else:
loc = therest[:3]
if loc not in self.nwsli_provider:
if _pr.base_loc is None:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
loc = _pr.base_loc
if loc not in self.nwsli_provider:
self.warnings.append(
f"Double-unknown location: {report}"
)
return None
# So we discard the offset when we go back to the base
dist = 0
bearing = 0
_pr.longitude, _pr.latitude = self.compute_loc(
loc, dist, bearing
)
continue
# Time
if token.startswith("TM "):
numbers = re.findall("[0-9]{4}", token)
if len(numbers) != 1:
self.warnings.append("TM parse failed %s" % (report,))
return None
hour = int(numbers[0][:2])
minute = int(numbers[0][2:])
_pr.valid = self.compute_pirep_valid(hour, minute)
continue
return _pr if _pr.latitude is not None else None
def compute_loc(self, loc, dist, bearing):
| PilotReport | identifier_name |
pirep.py | ,
"SSW": 202.5,
"SW": 225,
"WSW": 247.5,
"W": 270,
"WNW": 292.5,
"NW": 305,
"NNW": 327.5,
"NORTH": 0,
"EAST": 90,
"SOUTH": 180,
"WEST": 270,
}
class Priority(str, Enum):
"""Types of reports."""
def __str__(self):
"""When we want the str repr."""
return str(self.value)
UA = "UA"
UUA = "UUA"
class PilotReport(BaseModel):
""" A Pilot Report. """
base_loc: str = None
text: str = None
priority: Priority = None
latitude: float = None
longitude: float = None
valid: datetime.datetime = None
cwsu: str = None
aircraft_type: str = None
is_duplicate: bool = False
class Pirep(product.TextProduct):
""" Class for parsing and representing Space Wx Products. """
def __init__(
self, text, utcnow=None, ugc_provider=None, nwsli_provider=None
):
""" constructor """
product.TextProduct.__init__(
self,
text,
utcnow=utcnow,
ugc_provider=ugc_provider,
nwsli_provider=nwsli_provider,
)
self.reports = []
self.parse_reports()
def parse_reports(self):
"""Actually do the parsing of the product that generates the reports
stored within the self.reports list"""
txt = (
self.unixtext
if self.unixtext[:2] != "\001\n"
else self.unixtext[2:]
)
lines = txt.split("\n")
# There may be an AWIPSID in line 3 or silly aviation control char
pos = 3 if len(lines[2]) < 10 or lines[2].startswith("\x1e") else 2
meat = "".join(lines[pos:])
for report in meat.split("="):
if report.strip() == "":
continue
res = self.process_pirep(" ".join(report.strip().split()))
if res is not None:
self.reports.append(res)
def process_pirep(self, report):
""" Convert this report text into an actual PIREP object """
_pr = PilotReport()
_pr.text = report
for i, token in enumerate(report.split("/")):
token = token.strip()
# First token is always priority
if i == 0:
if len(token) > 10:
LOG.info("Aborting as not-PIREP? |%s|", report)
return
if token.find(" UUA") > 0:
_pr.priority = Priority.UUA
else:
_pr.priority = Priority.UA
parts = token.split()
if len(parts) == 2:
_pr.base_loc = parts[0]
if len(_pr.base_loc) == 4 and _pr.base_loc[0] == "K":
_pr.base_loc = _pr.base_loc[1:]
continue
# Aircraft Type
if token.startswith("TP "):
_pr.aircraft_type = token[3:]
# Location
if token.startswith("OV "):
dist = 0
bearing = 0
therest = token[3:]
if len(therest) == 3:
loc = therest
elif therest.startswith("FINAL RWY"):
loc = report[:8].split()[0]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
elif len(therest) == 4:
if therest[0] == "K":
loc = therest[1:]
else:
loc = therest
elif re.match(OV_OFFSET, therest):
d = re.match(OV_OFFSET, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
dist = int(d["dist"])
bearing = DRCT2DIR[d["dir"]]
elif re.match(OV_LOCDIR, therest):
# KFAR330008
d = re.match(OV_LOCDIR, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
bearing = int(d["dir"])
dist = int(d["dist"])
elif re.match(OV_LATLON, therest):
# 2500N07000W
# FMH-12 says this is in degrees and minutes!
d = re.match(OV_LATLON, therest).groupdict()
_pr.latitude = float(
"%s.%i"
% (
d["lat"][:-2],
int(float(d["lat"][-2:]) / 60.0 * 10000.0),
)
)
if d["latsign"] == "S":
_pr.latitude = 0 - _pr.latitude
_pr.longitude = float(
"%s.%i"
% (
d["lon"][:-2],
int(float(d["lon"][-2:]) / 60.0 * 10000.0),
)
)
if d["lonsign"] == "W":
_pr.longitude = 0 - _pr.longitude
continue
elif therest == "O":
# Use the first part of the report in this case
loc = report[:3]
elif therest.find("-") > 0 and re.match(OV_TWOLOC, therest):
d = re.match(OV_TWOLOC, therest).groupdict()
numbers = re.findall("[0-9]{6}", therest)
if numbers:
bearing = int(numbers[0][:3])
dist = int(numbers[0][3:])
loc = d["loc2"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
else:
# Split the distance between the two points
lats = []
lons = []
for loc in [d["loc1"], d["loc2"]]:
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
if loc not in self.nwsli_provider:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
lats.append(self.nwsli_provider[loc]["lat"])
lons.append(self.nwsli_provider[loc]["lon"])
_pr.latitude = sum(lats) / 2.0
_pr.longitude = sum(lons) / 2.0
continue
else:
loc = therest[:3]
if loc not in self.nwsli_provider:
if _pr.base_loc is None:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
loc = _pr.base_loc
if loc not in self.nwsli_provider:
self.warnings.append(
f"Double-unknown location: {report}"
)
return None
# So we discard the offset when we go back to the base
dist = 0
bearing = 0
_pr.longitude, _pr.latitude = self.compute_loc(
loc, dist, bearing
)
continue
# Time
if token.startswith("TM "):
numbers = re.findall("[0-9]{4}", token)
if len(numbers) != 1:
self.warnings.append("TM parse failed %s" % (report,))
return None
hour = int(numbers[0][:2])
minute = int(numbers[0][2:])
_pr.valid = self.compute_pirep_valid(hour, minute)
continue
return _pr if _pr.latitude is not None else None
def compute_loc(self, loc, dist, bearing):
""" Figure out the lon/lat for this location """
lat = self.nwsli_provider[loc]["lat"]
lon = self.nwsli_provider[loc]["lon"]
# shortcut
if dist == 0:
return lon, lat
meters = distance(float(dist), "MI").value("M")
northing = meters * math.cos(math.radians(bearing)) / 111111.0
easting = (
meters
* math.sin(math.radians(bearing))
/ math.cos(math.radians(lat))
/ 111111.0
)
return lon + easting, lat + northing
def compute_pirep_valid(self, hour, minute):
""" Based on what utcnow is set to, compute when this is valid """
res = self.utcnow.replace(
hour=hour, minute=minute, second=0, microsecond=0
)
if hour > self.utcnow.hour:
| res -= datetime.timedelta(hours=24) | conditional_block |
|
pirep.py | NNE": 22.5,
"NE": 45,
"ENE": 67.5,
"E": 90,
"ESE": 112.5,
"SE": 135,
"SSE": 157.5,
"S": 180,
"SSW": 202.5,
"SW": 225,
"WSW": 247.5,
"W": 270,
"WNW": 292.5,
"NW": 305,
"NNW": 327.5,
"NORTH": 0,
"EAST": 90,
"SOUTH": 180,
"WEST": 270,
}
class Priority(str, Enum):
"""Types of reports."""
def __str__(self):
"""When we want the str repr."""
return str(self.value)
UA = "UA"
UUA = "UUA"
class PilotReport(BaseModel):
""" A Pilot Report. """
base_loc: str = None
text: str = None
priority: Priority = None
latitude: float = None
longitude: float = None
valid: datetime.datetime = None
cwsu: str = None
aircraft_type: str = None
is_duplicate: bool = False
class Pirep(product.TextProduct):
""" Class for parsing and representing Space Wx Products. """
def __init__(
self, text, utcnow=None, ugc_provider=None, nwsli_provider=None
):
""" constructor """
product.TextProduct.__init__(
self,
text,
utcnow=utcnow,
ugc_provider=ugc_provider,
nwsli_provider=nwsli_provider,
)
self.reports = []
self.parse_reports()
def parse_reports(self):
"""Actually do the parsing of the product that generates the reports
stored within the self.reports list"""
txt = (
self.unixtext
if self.unixtext[:2] != "\001\n"
else self.unixtext[2:]
)
lines = txt.split("\n")
# There may be an AWIPSID in line 3 or silly aviation control char
pos = 3 if len(lines[2]) < 10 or lines[2].startswith("\x1e") else 2
meat = "".join(lines[pos:])
for report in meat.split("="):
if report.strip() == "":
continue
res = self.process_pirep(" ".join(report.strip().split()))
if res is not None:
self.reports.append(res)
def process_pirep(self, report):
""" Convert this report text into an actual PIREP object """
_pr = PilotReport()
_pr.text = report
for i, token in enumerate(report.split("/")):
token = token.strip()
# First token is always priority
if i == 0:
if len(token) > 10:
LOG.info("Aborting as not-PIREP? |%s|", report)
return
if token.find(" UUA") > 0:
_pr.priority = Priority.UUA
else:
_pr.priority = Priority.UA
parts = token.split()
if len(parts) == 2:
_pr.base_loc = parts[0]
if len(_pr.base_loc) == 4 and _pr.base_loc[0] == "K":
_pr.base_loc = _pr.base_loc[1:]
continue
# Aircraft Type
if token.startswith("TP "):
_pr.aircraft_type = token[3:]
# Location
if token.startswith("OV "):
dist = 0
bearing = 0
therest = token[3:]
if len(therest) == 3:
loc = therest
elif therest.startswith("FINAL RWY"):
loc = report[:8].split()[0]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
elif len(therest) == 4:
if therest[0] == "K":
loc = therest[1:]
else:
loc = therest
elif re.match(OV_OFFSET, therest):
d = re.match(OV_OFFSET, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
dist = int(d["dist"])
bearing = DRCT2DIR[d["dir"]]
elif re.match(OV_LOCDIR, therest):
# KFAR330008
d = re.match(OV_LOCDIR, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
bearing = int(d["dir"])
dist = int(d["dist"])
elif re.match(OV_LATLON, therest):
# 2500N07000W
# FMH-12 says this is in degrees and minutes!
d = re.match(OV_LATLON, therest).groupdict()
_pr.latitude = float(
"%s.%i"
% (
d["lat"][:-2],
int(float(d["lat"][-2:]) / 60.0 * 10000.0),
)
)
if d["latsign"] == "S":
_pr.latitude = 0 - _pr.latitude
_pr.longitude = float(
"%s.%i"
% (
d["lon"][:-2],
int(float(d["lon"][-2:]) / 60.0 * 10000.0),
)
)
if d["lonsign"] == "W":
_pr.longitude = 0 - _pr.longitude
continue
elif therest == "O":
# Use the first part of the report in this case
loc = report[:3]
elif therest.find("-") > 0 and re.match(OV_TWOLOC, therest):
d = re.match(OV_TWOLOC, therest).groupdict()
numbers = re.findall("[0-9]{6}", therest)
if numbers:
bearing = int(numbers[0][:3])
dist = int(numbers[0][3:])
loc = d["loc2"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
else:
# Split the distance between the two points
lats = []
lons = []
for loc in [d["loc1"], d["loc2"]]:
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
if loc not in self.nwsli_provider:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
lats.append(self.nwsli_provider[loc]["lat"])
lons.append(self.nwsli_provider[loc]["lon"])
_pr.latitude = sum(lats) / 2.0
_pr.longitude = sum(lons) / 2.0
continue
else:
loc = therest[:3]
if loc not in self.nwsli_provider:
if _pr.base_loc is None:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
loc = _pr.base_loc
if loc not in self.nwsli_provider:
self.warnings.append(
f"Double-unknown location: {report}"
)
return None
# So we discard the offset when we go back to the base
dist = 0
bearing = 0
_pr.longitude, _pr.latitude = self.compute_loc(
loc, dist, bearing
)
continue
# Time
if token.startswith("TM "):
numbers = re.findall("[0-9]{4}", token)
if len(numbers) != 1:
self.warnings.append("TM parse failed %s" % (report,))
return None
hour = int(numbers[0][:2])
minute = int(numbers[0][2:])
_pr.valid = self.compute_pirep_valid(hour, minute)
continue
return _pr if _pr.latitude is not None else None
def compute_loc(self, loc, dist, bearing):
| """ Figure out the lon/lat for this location """
lat = self.nwsli_provider[loc]["lat"]
lon = self.nwsli_provider[loc]["lon"]
# shortcut
if dist == 0:
return lon, lat
meters = distance(float(dist), "MI").value("M")
northing = meters * math.cos(math.radians(bearing)) / 111111.0
easting = (
meters
* math.sin(math.radians(bearing))
/ math.cos(math.radians(lat))
/ 111111.0
)
return lon + easting, lat + northing | identifier_body |
|
pirep.py | ):
"""When we want the str repr."""
return str(self.value)
UA = "UA"
UUA = "UUA"
class PilotReport(BaseModel):
""" A Pilot Report. """
base_loc: str = None
text: str = None
priority: Priority = None
latitude: float = None
longitude: float = None
valid: datetime.datetime = None
cwsu: str = None
aircraft_type: str = None
is_duplicate: bool = False
class Pirep(product.TextProduct):
""" Class for parsing and representing Space Wx Products. """
def __init__(
self, text, utcnow=None, ugc_provider=None, nwsli_provider=None
):
""" constructor """
product.TextProduct.__init__(
self,
text,
utcnow=utcnow,
ugc_provider=ugc_provider,
nwsli_provider=nwsli_provider,
)
self.reports = []
self.parse_reports()
def parse_reports(self):
"""Actually do the parsing of the product that generates the reports
stored within the self.reports list"""
txt = (
self.unixtext
if self.unixtext[:2] != "\001\n"
else self.unixtext[2:]
)
lines = txt.split("\n")
# There may be an AWIPSID in line 3 or silly aviation control char
pos = 3 if len(lines[2]) < 10 or lines[2].startswith("\x1e") else 2
meat = "".join(lines[pos:])
for report in meat.split("="):
if report.strip() == "":
continue
res = self.process_pirep(" ".join(report.strip().split()))
if res is not None:
self.reports.append(res)
def process_pirep(self, report):
""" Convert this report text into an actual PIREP object """
_pr = PilotReport()
_pr.text = report
for i, token in enumerate(report.split("/")):
token = token.strip()
# First token is always priority
if i == 0:
if len(token) > 10:
LOG.info("Aborting as not-PIREP? |%s|", report)
return
if token.find(" UUA") > 0:
_pr.priority = Priority.UUA
else:
_pr.priority = Priority.UA
parts = token.split()
if len(parts) == 2:
_pr.base_loc = parts[0]
if len(_pr.base_loc) == 4 and _pr.base_loc[0] == "K":
_pr.base_loc = _pr.base_loc[1:]
continue
# Aircraft Type
if token.startswith("TP "):
_pr.aircraft_type = token[3:]
# Location
if token.startswith("OV "):
dist = 0
bearing = 0
therest = token[3:]
if len(therest) == 3:
loc = therest
elif therest.startswith("FINAL RWY"):
loc = report[:8].split()[0]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
elif len(therest) == 4:
if therest[0] == "K":
loc = therest[1:]
else:
loc = therest
elif re.match(OV_OFFSET, therest):
d = re.match(OV_OFFSET, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
dist = int(d["dist"])
bearing = DRCT2DIR[d["dir"]]
elif re.match(OV_LOCDIR, therest):
# KFAR330008
d = re.match(OV_LOCDIR, therest).groupdict()
loc = d["loc"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
bearing = int(d["dir"])
dist = int(d["dist"])
elif re.match(OV_LATLON, therest):
# 2500N07000W
# FMH-12 says this is in degrees and minutes!
d = re.match(OV_LATLON, therest).groupdict()
_pr.latitude = float(
"%s.%i"
% (
d["lat"][:-2],
int(float(d["lat"][-2:]) / 60.0 * 10000.0),
)
)
if d["latsign"] == "S":
_pr.latitude = 0 - _pr.latitude
_pr.longitude = float(
"%s.%i"
% (
d["lon"][:-2],
int(float(d["lon"][-2:]) / 60.0 * 10000.0),
)
)
if d["lonsign"] == "W":
_pr.longitude = 0 - _pr.longitude
continue
elif therest == "O":
# Use the first part of the report in this case
loc = report[:3]
elif therest.find("-") > 0 and re.match(OV_TWOLOC, therest):
d = re.match(OV_TWOLOC, therest).groupdict()
numbers = re.findall("[0-9]{6}", therest)
if numbers:
bearing = int(numbers[0][:3])
dist = int(numbers[0][3:])
loc = d["loc2"]
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
else:
# Split the distance between the two points
lats = []
lons = []
for loc in [d["loc1"], d["loc2"]]:
if len(loc) == 4 and loc[0] == "K":
loc = loc[1:]
if loc not in self.nwsli_provider:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
lats.append(self.nwsli_provider[loc]["lat"])
lons.append(self.nwsli_provider[loc]["lon"])
_pr.latitude = sum(lats) / 2.0
_pr.longitude = sum(lons) / 2.0
continue
else:
loc = therest[:3]
if loc not in self.nwsli_provider:
if _pr.base_loc is None:
self.warnings.append(
f"Unknown location: {loc} '{report}'"
)
return None
loc = _pr.base_loc
if loc not in self.nwsli_provider:
self.warnings.append(
f"Double-unknown location: {report}"
)
return None
# So we discard the offset when we go back to the base
dist = 0
bearing = 0
_pr.longitude, _pr.latitude = self.compute_loc(
loc, dist, bearing
)
continue
# Time
if token.startswith("TM "):
numbers = re.findall("[0-9]{4}", token)
if len(numbers) != 1:
self.warnings.append("TM parse failed %s" % (report,))
return None
hour = int(numbers[0][:2])
minute = int(numbers[0][2:])
_pr.valid = self.compute_pirep_valid(hour, minute)
continue
return _pr if _pr.latitude is not None else None
def compute_loc(self, loc, dist, bearing):
""" Figure out the lon/lat for this location """
lat = self.nwsli_provider[loc]["lat"]
lon = self.nwsli_provider[loc]["lon"]
# shortcut
if dist == 0:
return lon, lat
meters = distance(float(dist), "MI").value("M")
northing = meters * math.cos(math.radians(bearing)) / 111111.0
easting = (
meters
* math.sin(math.radians(bearing))
/ math.cos(math.radians(lat))
/ 111111.0
)
return lon + easting, lat + northing
def compute_pirep_valid(self, hour, minute):
""" Based on what utcnow is set to, compute when this is valid """
res = self.utcnow.replace(
hour=hour, minute=minute, second=0, microsecond=0
)
if hour > self.utcnow.hour:
res -= datetime.timedelta(hours=24)
return res
def sql(self, txn):
""" Save the reports to the database via the transaction """
for report in self.reports:
if report.is_duplicate:
continue
txn.execute(
"INSERT into pireps(valid, geom, is_urgent, "
"aircraft_type, report) VALUES (%s, "
"ST_GeographyFromText('SRID=4326;POINT(%s %s)'),%s,%s,%s)",
(
report.valid,
report.longitude,
report.latitude,
report.priority == Priority.UUA, | report.aircraft_type, | random_line_split |
|
requester.go | struct {
// Request is the request to be made.
Request *http.Request
//RequestBody []byte
RequestParamSlice *RequestParamSlice
DataType string
DisableOutput bool
// N is the total number of requests to make.
N int
// C is the concurrency level, the number of concurrent workers to run.
C int
// H2 is an option to make HTTP/2 requests
H2 bool
// Timeout in seconds.
SingleRequestTimeout time.Duration
// Timeout in seconds
PerformanceTimeout time.Duration
// Qps is the rate limit.
QPS int
// DisableCompression is an option to disable compression in response
DisableCompression bool
// DisableKeepAlives is an option to prevents re-use of TCP connections between different HTTP requests
DisableKeepAlives bool
// DisableRedirects is an option to prevent the following of HTTP redirects
DisableRedirects bool
// RandomInput is an option to enable random data for input when input file has multi rows
RandomInput bool
// send requests synchronous in single worker
Async bool
// Output represents the output type. If "csv" is provided, the
// output will be dumped as a csv stream.
Output string
// ProxyAddr is the address of HTTP proxy server in the format on "host:port".
// Optional.
ProxyAddr *url.URL
// Writer is where results will be written. If nil, results are written to stdout.
Writer io.Writer
results chan *result
stopCh chan struct{}
startTime time.Time
report *report
}
func (b *Work) writer() io.Writer {
if b.Writer == nil {
return os.Stdout
}
return b.Writer
}
// Run makes all the requests, prints the summary. It blocks until
// all work is done.
func (b *Work) Run() {
// append hey's user agent
ua := b.Request.UserAgent()
if ua == "" {
ua = megSenderUA
} else {
ua += " " + megSenderUA
}
b.results = make(chan *result)
b.stopCh = make(chan struct{}, b.C)
b.startTime = time.Now()
b.report = newReport(b.writer(), b.results, b.Output)
b.report.start()
b.runWorkers()
b.Finish()
}
func (b *Work) Finish() {
for i := 0; i < b.C; i++ {
b.stopCh <- struct{}{}
}
close(b.results)
b.results = nil
b.report.stop()
}
func (b *Work) makeRequest(c *http.Client, p *RequestParam) {
s := time.Now()
var size int64
var code int
var dnsStart, connStart, resStart, reqStart, delayStart time.Time
var dnsDuration, connDuration, resDuration, reqDuration, delayDuration time.Duration
//req := cloneRequest(b.Request, b.RequestBody)
req := cloneRequest(b.Request, p, b.DataType)
trace := &httptrace.ClientTrace{
DNSStart: func(info httptrace.DNSStartInfo) {
dnsStart = time.Now()
},
DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
dnsDuration = time.Now().Sub(dnsStart)
},
GetConn: func(h string) {
connStart = time.Now()
},
GotConn: func(connInfo httptrace.GotConnInfo) {
connDuration = time.Now().Sub(connStart)
reqStart = time.Now()
},
WroteRequest: func(w httptrace.WroteRequestInfo) {
reqDuration = time.Now().Sub(reqStart)
delayStart = time.Now()
},
GotFirstResponseByte: func() {
delayDuration = time.Now().Sub(delayStart)
resStart = time.Now()
},
}
req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
resp, err := c.Do(req)
if resp != nil {
defer resp.Body.Close()
}
if err == nil {
size = resp.ContentLength
code = resp.StatusCode
body := &bytes.Buffer{}
if b.DisableOutput == false {
_, err := body.ReadFrom(resp.Body)
if err == nil {
Info.Printf("%s\t%d\t%s\n", strings.TrimSpace(string(p.Content)), code, strings.TrimSpace(body.String()))
} else {
Error.Println(err)
return
}
}
io.Copy(ioutil.Discard, resp.Body)
} else {
Error.Println(err)
return
}
t := time.Now()
resDuration = t.Sub(resStart)
finish := t.Sub(s)
select {
case b.results <- &result{
statusCode: code,
duration: finish,
err: err,
contentLength: size,
connDuration: connDuration,
dnsDuration: dnsDuration,
reqDuration: reqDuration,
resDuration: resDuration,
delayDuration: delayDuration,
}:
default:
}
}
// @param n count to send
func (b *Work) runWorker(n int, widx int) {
var throttle <-chan time.Time
if b.QPS > 0 {
throttle = time.Tick(time.Duration((1e6/(b.QPS))*b.C) * time.Microsecond)
}
tr := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
DisableCompression: b.DisableCompression,
DisableKeepAlives: b.DisableKeepAlives,
Proxy: http.ProxyURL(b.ProxyAddr),
}
if b.H2 {
http2.ConfigureTransport(tr)
} else {
tr.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper)
}
client := &http.Client{Transport: tr, Timeout: b.SingleRequestTimeout}
if b.DisableRedirects {
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
}
}
if b.Async {
// async
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.asyncSend(throttle, cliObj)
} else {
b.asyncSendN(widx, n, throttle, cliObj)
}
}
} else {
// sync
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.syncSend(throttle, cliObj)
} else {
b.syncSendN(widx, n, throttle, cliObj)
}
}
}
}
// sync send n
func (b *Work) syncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
for i := 0; i < n; i++ |
}
// sync send
func (b *Work) syncSend(throttle <-chan time.Time, client http.Client) {
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
}
}
// async send by count
func (b *Work) asyncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
wg.Add(n)
for i := 0; i < n; i++ {
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
// async send by time
func (b *Work) asyncSend(throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
wg.Add(1)
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
func (b *Work) getRequestParam(idx int) RequestParam {
length := len(b.RequestParamSlice.RequestParams)
if length > 0 {
if b.RandomInput {
return b.RequestParamSlice.RequestParams[rand.Intn(length)]
} else {
return b.RequestParamSlice.RequestParams[(idx)%length]
| {
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
} | conditional_block |
requester.go | Work struct {
// Request is the request to be made.
Request *http.Request
//RequestBody []byte
RequestParamSlice *RequestParamSlice
DataType string
DisableOutput bool
// N is the total number of requests to make.
N int
// C is the concurrency level, the number of concurrent workers to run.
C int
// H2 is an option to make HTTP/2 requests
H2 bool
// Timeout in seconds.
SingleRequestTimeout time.Duration
// Timeout in seconds
PerformanceTimeout time.Duration
// Qps is the rate limit.
QPS int
// DisableCompression is an option to disable compression in response
DisableCompression bool
// DisableKeepAlives is an option to prevents re-use of TCP connections between different HTTP requests
DisableKeepAlives bool
// DisableRedirects is an option to prevent the following of HTTP redirects
DisableRedirects bool
// RandomInput is an option to enable random data for input when input file has multi rows
RandomInput bool
// send requests synchronous in single worker
Async bool
// Output represents the output type. If "csv" is provided, the
// output will be dumped as a csv stream.
Output string
// ProxyAddr is the address of HTTP proxy server in the format on "host:port".
// Optional.
ProxyAddr *url.URL
// Writer is where results will be written. If nil, results are written to stdout.
Writer io.Writer
results chan *result
stopCh chan struct{}
startTime time.Time
report *report
}
| return os.Stdout
}
return b.Writer
}
// Run makes all the requests, prints the summary. It blocks until
// all work is done.
func (b *Work) Run() {
// append hey's user agent
ua := b.Request.UserAgent()
if ua == "" {
ua = megSenderUA
} else {
ua += " " + megSenderUA
}
b.results = make(chan *result)
b.stopCh = make(chan struct{}, b.C)
b.startTime = time.Now()
b.report = newReport(b.writer(), b.results, b.Output)
b.report.start()
b.runWorkers()
b.Finish()
}
func (b *Work) Finish() {
for i := 0; i < b.C; i++ {
b.stopCh <- struct{}{}
}
close(b.results)
b.results = nil
b.report.stop()
}
func (b *Work) makeRequest(c *http.Client, p *RequestParam) {
s := time.Now()
var size int64
var code int
var dnsStart, connStart, resStart, reqStart, delayStart time.Time
var dnsDuration, connDuration, resDuration, reqDuration, delayDuration time.Duration
//req := cloneRequest(b.Request, b.RequestBody)
req := cloneRequest(b.Request, p, b.DataType)
trace := &httptrace.ClientTrace{
DNSStart: func(info httptrace.DNSStartInfo) {
dnsStart = time.Now()
},
DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
dnsDuration = time.Now().Sub(dnsStart)
},
GetConn: func(h string) {
connStart = time.Now()
},
GotConn: func(connInfo httptrace.GotConnInfo) {
connDuration = time.Now().Sub(connStart)
reqStart = time.Now()
},
WroteRequest: func(w httptrace.WroteRequestInfo) {
reqDuration = time.Now().Sub(reqStart)
delayStart = time.Now()
},
GotFirstResponseByte: func() {
delayDuration = time.Now().Sub(delayStart)
resStart = time.Now()
},
}
req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
resp, err := c.Do(req)
if resp != nil {
defer resp.Body.Close()
}
if err == nil {
size = resp.ContentLength
code = resp.StatusCode
body := &bytes.Buffer{}
if b.DisableOutput == false {
_, err := body.ReadFrom(resp.Body)
if err == nil {
Info.Printf("%s\t%d\t%s\n", strings.TrimSpace(string(p.Content)), code, strings.TrimSpace(body.String()))
} else {
Error.Println(err)
return
}
}
io.Copy(ioutil.Discard, resp.Body)
} else {
Error.Println(err)
return
}
t := time.Now()
resDuration = t.Sub(resStart)
finish := t.Sub(s)
select {
case b.results <- &result{
statusCode: code,
duration: finish,
err: err,
contentLength: size,
connDuration: connDuration,
dnsDuration: dnsDuration,
reqDuration: reqDuration,
resDuration: resDuration,
delayDuration: delayDuration,
}:
default:
}
}
// @param n count to send
func (b *Work) runWorker(n int, widx int) {
var throttle <-chan time.Time
if b.QPS > 0 {
throttle = time.Tick(time.Duration((1e6/(b.QPS))*b.C) * time.Microsecond)
}
tr := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
DisableCompression: b.DisableCompression,
DisableKeepAlives: b.DisableKeepAlives,
Proxy: http.ProxyURL(b.ProxyAddr),
}
if b.H2 {
http2.ConfigureTransport(tr)
} else {
tr.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper)
}
client := &http.Client{Transport: tr, Timeout: b.SingleRequestTimeout}
if b.DisableRedirects {
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
}
}
if b.Async {
// async
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.asyncSend(throttle, cliObj)
} else {
b.asyncSendN(widx, n, throttle, cliObj)
}
}
} else {
// sync
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.syncSend(throttle, cliObj)
} else {
b.syncSendN(widx, n, throttle, cliObj)
}
}
}
}
// sync send n
func (b *Work) syncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
for i := 0; i < n; i++ {
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
}
}
// sync send
func (b *Work) syncSend(throttle <-chan time.Time, client http.Client) {
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
}
}
// async send by count
func (b *Work) asyncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
wg.Add(n)
for i := 0; i < n; i++ {
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
// async send by time
func (b *Work) asyncSend(throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
wg.Add(1)
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
func (b *Work) getRequestParam(idx int) RequestParam {
length := len(b.RequestParamSlice.RequestParams)
if length > 0 {
if b.RandomInput {
return b.RequestParamSlice.RequestParams[rand.Intn(length)]
} else {
return b.RequestParamSlice.RequestParams[(idx)%length]
| func (b *Work) writer() io.Writer {
if b.Writer == nil { | random_line_split |
requester.go | Work struct {
// Request is the request to be made.
Request *http.Request
//RequestBody []byte
RequestParamSlice *RequestParamSlice
DataType string
DisableOutput bool
// N is the total number of requests to make.
N int
// C is the concurrency level, the number of concurrent workers to run.
C int
// H2 is an option to make HTTP/2 requests
H2 bool
// Timeout in seconds.
SingleRequestTimeout time.Duration
// Timeout in seconds
PerformanceTimeout time.Duration
// Qps is the rate limit.
QPS int
// DisableCompression is an option to disable compression in response
DisableCompression bool
// DisableKeepAlives is an option to prevents re-use of TCP connections between different HTTP requests
DisableKeepAlives bool
// DisableRedirects is an option to prevent the following of HTTP redirects
DisableRedirects bool
// RandomInput is an option to enable random data for input when input file has multi rows
RandomInput bool
// send requests synchronous in single worker
Async bool
// Output represents the output type. If "csv" is provided, the
// output will be dumped as a csv stream.
Output string
// ProxyAddr is the address of HTTP proxy server in the format on "host:port".
// Optional.
ProxyAddr *url.URL
// Writer is where results will be written. If nil, results are written to stdout.
Writer io.Writer
results chan *result
stopCh chan struct{}
startTime time.Time
report *report
}
func (b *Work) | () io.Writer {
if b.Writer == nil {
return os.Stdout
}
return b.Writer
}
// Run makes all the requests, prints the summary. It blocks until
// all work is done.
func (b *Work) Run() {
// append hey's user agent
ua := b.Request.UserAgent()
if ua == "" {
ua = megSenderUA
} else {
ua += " " + megSenderUA
}
b.results = make(chan *result)
b.stopCh = make(chan struct{}, b.C)
b.startTime = time.Now()
b.report = newReport(b.writer(), b.results, b.Output)
b.report.start()
b.runWorkers()
b.Finish()
}
func (b *Work) Finish() {
for i := 0; i < b.C; i++ {
b.stopCh <- struct{}{}
}
close(b.results)
b.results = nil
b.report.stop()
}
func (b *Work) makeRequest(c *http.Client, p *RequestParam) {
s := time.Now()
var size int64
var code int
var dnsStart, connStart, resStart, reqStart, delayStart time.Time
var dnsDuration, connDuration, resDuration, reqDuration, delayDuration time.Duration
//req := cloneRequest(b.Request, b.RequestBody)
req := cloneRequest(b.Request, p, b.DataType)
trace := &httptrace.ClientTrace{
DNSStart: func(info httptrace.DNSStartInfo) {
dnsStart = time.Now()
},
DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
dnsDuration = time.Now().Sub(dnsStart)
},
GetConn: func(h string) {
connStart = time.Now()
},
GotConn: func(connInfo httptrace.GotConnInfo) {
connDuration = time.Now().Sub(connStart)
reqStart = time.Now()
},
WroteRequest: func(w httptrace.WroteRequestInfo) {
reqDuration = time.Now().Sub(reqStart)
delayStart = time.Now()
},
GotFirstResponseByte: func() {
delayDuration = time.Now().Sub(delayStart)
resStart = time.Now()
},
}
req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
resp, err := c.Do(req)
if resp != nil {
defer resp.Body.Close()
}
if err == nil {
size = resp.ContentLength
code = resp.StatusCode
body := &bytes.Buffer{}
if b.DisableOutput == false {
_, err := body.ReadFrom(resp.Body)
if err == nil {
Info.Printf("%s\t%d\t%s\n", strings.TrimSpace(string(p.Content)), code, strings.TrimSpace(body.String()))
} else {
Error.Println(err)
return
}
}
io.Copy(ioutil.Discard, resp.Body)
} else {
Error.Println(err)
return
}
t := time.Now()
resDuration = t.Sub(resStart)
finish := t.Sub(s)
select {
case b.results <- &result{
statusCode: code,
duration: finish,
err: err,
contentLength: size,
connDuration: connDuration,
dnsDuration: dnsDuration,
reqDuration: reqDuration,
resDuration: resDuration,
delayDuration: delayDuration,
}:
default:
}
}
// @param n count to send
func (b *Work) runWorker(n int, widx int) {
var throttle <-chan time.Time
if b.QPS > 0 {
throttle = time.Tick(time.Duration((1e6/(b.QPS))*b.C) * time.Microsecond)
}
tr := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
DisableCompression: b.DisableCompression,
DisableKeepAlives: b.DisableKeepAlives,
Proxy: http.ProxyURL(b.ProxyAddr),
}
if b.H2 {
http2.ConfigureTransport(tr)
} else {
tr.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper)
}
client := &http.Client{Transport: tr, Timeout: b.SingleRequestTimeout}
if b.DisableRedirects {
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
}
}
if b.Async {
// async
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.asyncSend(throttle, cliObj)
} else {
b.asyncSendN(widx, n, throttle, cliObj)
}
}
} else {
// sync
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.syncSend(throttle, cliObj)
} else {
b.syncSendN(widx, n, throttle, cliObj)
}
}
}
}
// sync send n
func (b *Work) syncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
for i := 0; i < n; i++ {
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
}
}
// sync send
func (b *Work) syncSend(throttle <-chan time.Time, client http.Client) {
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
}
}
// async send by count
func (b *Work) asyncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
wg.Add(n)
for i := 0; i < n; i++ {
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
// async send by time
func (b *Work) asyncSend(throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
wg.Add(1)
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
func (b *Work) getRequestParam(idx int) RequestParam {
length := len(b.RequestParamSlice.RequestParams)
if length > 0 {
if b.RandomInput {
return b.RequestParamSlice.RequestParams[rand.Intn(length)]
} else {
return b.RequestParamSlice.RequestParams[(idx)%length]
| writer | identifier_name |
requester.go | seconds.
SingleRequestTimeout time.Duration
// Timeout in seconds
PerformanceTimeout time.Duration
// Qps is the rate limit.
QPS int
// DisableCompression is an option to disable compression in response
DisableCompression bool
// DisableKeepAlives is an option to prevents re-use of TCP connections between different HTTP requests
DisableKeepAlives bool
// DisableRedirects is an option to prevent the following of HTTP redirects
DisableRedirects bool
// RandomInput is an option to enable random data for input when input file has multi rows
RandomInput bool
// send requests synchronous in single worker
Async bool
// Output represents the output type. If "csv" is provided, the
// output will be dumped as a csv stream.
Output string
// ProxyAddr is the address of HTTP proxy server in the format on "host:port".
// Optional.
ProxyAddr *url.URL
// Writer is where results will be written. If nil, results are written to stdout.
Writer io.Writer
results chan *result
stopCh chan struct{}
startTime time.Time
report *report
}
func (b *Work) writer() io.Writer {
if b.Writer == nil {
return os.Stdout
}
return b.Writer
}
// Run makes all the requests, prints the summary. It blocks until
// all work is done.
func (b *Work) Run() {
// append hey's user agent
ua := b.Request.UserAgent()
if ua == "" {
ua = megSenderUA
} else {
ua += " " + megSenderUA
}
b.results = make(chan *result)
b.stopCh = make(chan struct{}, b.C)
b.startTime = time.Now()
b.report = newReport(b.writer(), b.results, b.Output)
b.report.start()
b.runWorkers()
b.Finish()
}
func (b *Work) Finish() {
for i := 0; i < b.C; i++ {
b.stopCh <- struct{}{}
}
close(b.results)
b.results = nil
b.report.stop()
}
func (b *Work) makeRequest(c *http.Client, p *RequestParam) {
s := time.Now()
var size int64
var code int
var dnsStart, connStart, resStart, reqStart, delayStart time.Time
var dnsDuration, connDuration, resDuration, reqDuration, delayDuration time.Duration
//req := cloneRequest(b.Request, b.RequestBody)
req := cloneRequest(b.Request, p, b.DataType)
trace := &httptrace.ClientTrace{
DNSStart: func(info httptrace.DNSStartInfo) {
dnsStart = time.Now()
},
DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
dnsDuration = time.Now().Sub(dnsStart)
},
GetConn: func(h string) {
connStart = time.Now()
},
GotConn: func(connInfo httptrace.GotConnInfo) {
connDuration = time.Now().Sub(connStart)
reqStart = time.Now()
},
WroteRequest: func(w httptrace.WroteRequestInfo) {
reqDuration = time.Now().Sub(reqStart)
delayStart = time.Now()
},
GotFirstResponseByte: func() {
delayDuration = time.Now().Sub(delayStart)
resStart = time.Now()
},
}
req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
resp, err := c.Do(req)
if resp != nil {
defer resp.Body.Close()
}
if err == nil {
size = resp.ContentLength
code = resp.StatusCode
body := &bytes.Buffer{}
if b.DisableOutput == false {
_, err := body.ReadFrom(resp.Body)
if err == nil {
Info.Printf("%s\t%d\t%s\n", strings.TrimSpace(string(p.Content)), code, strings.TrimSpace(body.String()))
} else {
Error.Println(err)
return
}
}
io.Copy(ioutil.Discard, resp.Body)
} else {
Error.Println(err)
return
}
t := time.Now()
resDuration = t.Sub(resStart)
finish := t.Sub(s)
select {
case b.results <- &result{
statusCode: code,
duration: finish,
err: err,
contentLength: size,
connDuration: connDuration,
dnsDuration: dnsDuration,
reqDuration: reqDuration,
resDuration: resDuration,
delayDuration: delayDuration,
}:
default:
}
}
// @param n count to send
func (b *Work) runWorker(n int, widx int) {
var throttle <-chan time.Time
if b.QPS > 0 {
throttle = time.Tick(time.Duration((1e6/(b.QPS))*b.C) * time.Microsecond)
}
tr := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
DisableCompression: b.DisableCompression,
DisableKeepAlives: b.DisableKeepAlives,
Proxy: http.ProxyURL(b.ProxyAddr),
}
if b.H2 {
http2.ConfigureTransport(tr)
} else {
tr.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper)
}
client := &http.Client{Transport: tr, Timeout: b.SingleRequestTimeout}
if b.DisableRedirects {
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
}
}
if b.Async {
// async
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.asyncSend(throttle, cliObj)
} else {
b.asyncSendN(widx, n, throttle, cliObj)
}
}
} else {
// sync
cli := deepcopy.Copy(*client)
cliObj, ok := cli.(http.Client)
if ok {
if b.PerformanceTimeout > 0 {
b.syncSend(throttle, cliObj)
} else {
b.syncSendN(widx, n, throttle, cliObj)
}
}
}
}
// sync send n
func (b *Work) syncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
for i := 0; i < n; i++ {
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
}
}
// sync send
func (b *Work) syncSend(throttle <-chan time.Time, client http.Client) {
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
if b.QPS > 0 {
<-throttle
}
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
}
}
// async send by count
func (b *Work) asyncSendN(widx int, n int, throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
wg.Add(n)
for i := 0; i < n; i++ {
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i*b.C + widx)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
// async send by time
func (b *Work) asyncSend(throttle <-chan time.Time, client http.Client) {
var wg sync.WaitGroup
for i := 0; ; i++ {
if time.Now().Sub(b.startTime) > b.PerformanceTimeout {
break
}
wg.Add(1)
if b.QPS > 0 {
<-throttle
}
go func() {
select {
case <-b.stopCh:
break
default:
requestParam := b.getRequestParam(i)
b.makeRequest(&client, &requestParam)
}
wg.Done()
}()
}
wg.Wait()
}
func (b *Work) getRequestParam(idx int) RequestParam {
length := len(b.RequestParamSlice.RequestParams)
if length > 0 {
if b.RandomInput {
return b.RequestParamSlice.RequestParams[rand.Intn(length)]
} else {
return b.RequestParamSlice.RequestParams[(idx)%length]
}
} else {
return RequestParam{
Content: []byte(""),
}
}
}
func (b *Work) runWorkers() | {
var wg sync.WaitGroup
wg.Add(b.C)
for i := 0; i < b.C; i++ {
go func(i int) {
b.runWorker(b.N/(b.C), i)
defer wg.Done()
}(i)
}
wg.Wait()
} | identifier_body |
|
type_check.rs | x, t1) :: ctx) e2
--lambdas are complicated (this represents ʎx.e)
typeInfer ctx (Lambda x e) = do
t1 <- allocExistentialVariable
t2 <- typeInfer ((x, t1) :: ctx) e
return $ FunctionType t1 t2 -- ie. t1 -> t2
--to solve the problem of map :: (a -> b) -> [a] -> [b]
when we use a variable whose type has universal tvars, convert those universal
tvars to existential ones
-and each distinct universal tvar needs to map to the same existential type
-so we change typeinfer:
typeInfer ctx (Var x) = do
case (lookup x ctx) of
Nothing -> ...
Just t -> do
let uvars = nub (toList t) -- nub removes duplicates, so this gets unique universally quantified variables
evars <- mapM (const allocExistentialVariable) uvars
let varMap = zip uvars evars
let vixVar varMap v = fromJust $ lookup v varMap
return (fmap (fixVar varMap) t)
--how do we define unify??
-recall, type signature is:
unify :: Type a -> Type b -> Matching (Type c)
unify BoolType BoolType = BoolType --easy, same for all constants
unify (FunctionType t1 t2) (FunctionType t3 t4) = do
t5 <- unify t1 t3
t6 <- unify t2 t4
return $ FunctionType t5 t6
unify (TVar a) (TVar b) = if a == b then TVar a else fail
--existential types can be assigned another type at most once
--some complicated stuff about hanlding existential types
--everything else is a type error
unify a b = fail
SKOLEMIZATION - how you prevent an unassigned existential type variable from leaking!
-before a type gets to global scope, replace all unassigned existential vars w/ new unique universal
type variables
*/
#[derive(Debug, PartialEq, Clone)]
pub enum Type {
TVar(TypeVar),
TConst(TypeConst),
TFunc(Box<Type>, Box<Type>),
}
#[derive(Debug, PartialEq, Clone)]
pub enum TypeVar {
Univ(Rc<String>),
Exist(u64),
}
impl TypeVar {
fn univ(label: &str) -> TypeVar {
TypeVar::Univ(Rc::new(label.to_string()))
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum TypeConst {
UserT(Rc<String>),
Integer,
Float,
StringT,
Boolean,
Unit,
Bottom,
}
type TypeCheckResult = Result<Type, String>;
#[derive(Debug, PartialEq, Eq, Hash)]
struct PathSpecifier(Rc<String>);
#[derive(Debug, PartialEq, Clone)]
struct TypeContextEntry {
ty: Type,
constant: bool
}
pub struct T | {
symbol_table: HashMap<PathSpecifier, TypeContextEntry>,
evar_table: HashMap<u64, Type>,
existential_type_label_count: u64
}
impl TypeContext {
pub fn new() -> TypeContext {
TypeContext {
symbol_table: HashMap::new(),
evar_table: HashMap::new(),
existential_type_label_count: 0,
}
}
pub fn add_symbols(&mut self, ast: &AST) {
use self::Declaration::*;
use self::Type::*;
use self::TypeConst::*;
for statement in ast.0.iter() {
match *statement {
Statement::ExpressionStatement(_) => (),
Statement::Declaration(ref decl) => match *decl {
FuncSig(_) => (),
Impl { .. } => (),
TypeDecl(ref type_constructor, ref body) => {
for variant in body.0.iter() {
let (spec, ty) = match variant {
&Variant::UnitStruct(ref data_constructor) => {
let spec = PathSpecifier(data_constructor.clone());
let ty = TConst(UserT(type_constructor.name.clone()));
(spec, ty)
},
&Variant::TupleStruct(ref data_construcor, ref args) => {
//TODO fix
let arg = args.get(0).unwrap();
let type_arg = self.from_anno(arg);
let spec = PathSpecifier(data_construcor.clone());
let ty = TFunc(Box::new(type_arg), Box::new(TConst(UserT(type_constructor.name.clone()))));
(spec, ty)
},
&Variant::Record(_, _) => unimplemented!(),
};
let entry = TypeContextEntry { ty, constant: true };
self.symbol_table.insert(spec, entry);
}
},
TypeAlias { .. } => (),
Binding {ref name, ref constant, ref expr} => {
let spec = PathSpecifier(name.clone());
let ty = expr.1.as_ref()
.map(|ty| self.from_anno(ty))
.unwrap_or_else(|| { self.alloc_existential_type() }); // this call to alloc_existential is OK b/c a binding only ever has one type, so if the annotation is absent, it's fine to just make one de novo
let entry = TypeContextEntry { ty, constant: *constant };
self.symbol_table.insert(spec, entry);
},
FuncDecl(ref signature, _) => {
let spec = PathSpecifier(signature.name.clone());
let ty = self.from_signature(signature);
let entry = TypeContextEntry { ty, constant: true };
self.symbol_table.insert(spec, entry);
},
}
}
}
}
fn lookup(&mut self, binding: &Rc<String>) -> Option<TypeContextEntry> {
let key = PathSpecifier(binding.clone());
self.symbol_table.get(&key).map(|entry| entry.clone())
}
pub fn debug_symbol_table(&self) -> String {
format!("Symbol table:\n {:?}\nEvar table:\n{:?}", self.symbol_table, self.evar_table)
}
fn alloc_existential_type(&mut self) -> Type {
let ret = Type::TVar(TypeVar::Exist(self.existential_type_label_count));
self.existential_type_label_count += 1;
ret
}
fn from_anno(&mut self, anno: &TypeName) -> Type {
use self::Type::*;
use self::TypeConst::*;
match anno {
&TypeName::Singleton(TypeSingletonName { ref name, .. }) => {
match name.as_ref().as_ref() {
"Int" => TConst(Integer),
"Float" => TConst(Float),
"Bool" => TConst(Boolean),
"String" => TConst(StringT),
s => TVar(TypeVar::Univ(Rc::new(format!("{}",s)))),
}
},
&TypeName::Tuple(ref items) => {
if items.len() == 1 {
TConst(Unit)
} else {
TConst(Bottom)
}
}
}
}
fn from_signature(&mut self, sig: &Signature) -> Type {
use self::Type::*;
use self::TypeConst::*;
//TODO this won't work properly until you make sure that all (universal) type vars in the function have the same existential type var
// actually this should never even put existential types into the symbol table at all
//this will crash if more than 5 arg function is used
let names = vec!["a", "b", "c", "d", "e", "f"];
let mut idx = 0;
let mut get_type = || { let q = TVar(TypeVar::Univ(Rc::new(format!("{}", names.get(idx).unwrap())))); idx += 1; q };
let return_type = sig.type_anno.as_ref().map(|anno| self.from_anno(&anno)).unwrap_or_else(|| { get_type() });
if sig.params.len() == 0 {
TFunc(Box::new(TConst(Unit)), Box::new(return_type))
} else {
let mut output_type = return_type;
for p in sig.params.iter() {
let p_type = p.1.as_ref().map(|anno| self.from_anno(anno)).unwrap_or_else(|| { get_type() });
output_type = TFunc(Box::new(p_type), Box::new(output_type));
}
output_type
}
}
pub fn type_check(&mut self, ast: &AST) -> TypeCheckResult {
use self::Type::*;
use self::TypeConst::*;
let mut last = TConst(Unit);
for statement in ast.0.iter() {
match statement {
&Statement::Declaration(ref _decl) => {
//return Err(format!("Declarations not supported"));
},
&Statement::ExpressionStatement(ref expr) => {
last = self.infer(expr)?;
}
}
}
Ok(last)
}
fn infer(&mut self, expr: &Expression) -> TypeCheckResult {
match (&expr.0, &expr.1) {
(exprtype, &Some(ref anno)) => {
let tx = self.infer_no_anno(exprtype)?;
let ty = self.from_anno(anno);
self.unify(tx, ty)
},
(exprtype, &None) => self.infer_no_anno(exprtype),
}
}
fn infer_no_anno(&mut self, ex: &ExpressionType) -> TypeCheck | ypeContext | identifier_name |
type_check.rs | = args.get(0).unwrap();
let type_arg = self.from_anno(arg);
let spec = PathSpecifier(data_construcor.clone());
let ty = TFunc(Box::new(type_arg), Box::new(TConst(UserT(type_constructor.name.clone()))));
(spec, ty)
},
&Variant::Record(_, _) => unimplemented!(),
};
let entry = TypeContextEntry { ty, constant: true };
self.symbol_table.insert(spec, entry);
}
},
TypeAlias { .. } => (),
Binding {ref name, ref constant, ref expr} => {
let spec = PathSpecifier(name.clone());
let ty = expr.1.as_ref()
.map(|ty| self.from_anno(ty))
.unwrap_or_else(|| { self.alloc_existential_type() }); // this call to alloc_existential is OK b/c a binding only ever has one type, so if the annotation is absent, it's fine to just make one de novo
let entry = TypeContextEntry { ty, constant: *constant };
self.symbol_table.insert(spec, entry);
},
FuncDecl(ref signature, _) => {
let spec = PathSpecifier(signature.name.clone());
let ty = self.from_signature(signature);
let entry = TypeContextEntry { ty, constant: true };
self.symbol_table.insert(spec, entry);
},
}
}
}
}
fn lookup(&mut self, binding: &Rc<String>) -> Option<TypeContextEntry> {
let key = PathSpecifier(binding.clone());
self.symbol_table.get(&key).map(|entry| entry.clone())
}
pub fn debug_symbol_table(&self) -> String {
format!("Symbol table:\n {:?}\nEvar table:\n{:?}", self.symbol_table, self.evar_table)
}
fn alloc_existential_type(&mut self) -> Type {
let ret = Type::TVar(TypeVar::Exist(self.existential_type_label_count));
self.existential_type_label_count += 1;
ret
}
fn from_anno(&mut self, anno: &TypeName) -> Type {
use self::Type::*;
use self::TypeConst::*;
match anno {
&TypeName::Singleton(TypeSingletonName { ref name, .. }) => {
match name.as_ref().as_ref() {
"Int" => TConst(Integer),
"Float" => TConst(Float),
"Bool" => TConst(Boolean),
"String" => TConst(StringT),
s => TVar(TypeVar::Univ(Rc::new(format!("{}",s)))),
}
},
&TypeName::Tuple(ref items) => {
if items.len() == 1 {
TConst(Unit)
} else {
TConst(Bottom)
}
}
}
}
fn from_signature(&mut self, sig: &Signature) -> Type {
use self::Type::*;
use self::TypeConst::*;
//TODO this won't work properly until you make sure that all (universal) type vars in the function have the same existential type var
// actually this should never even put existential types into the symbol table at all
//this will crash if more than 5 arg function is used
let names = vec!["a", "b", "c", "d", "e", "f"];
let mut idx = 0;
let mut get_type = || { let q = TVar(TypeVar::Univ(Rc::new(format!("{}", names.get(idx).unwrap())))); idx += 1; q };
let return_type = sig.type_anno.as_ref().map(|anno| self.from_anno(&anno)).unwrap_or_else(|| { get_type() });
if sig.params.len() == 0 {
TFunc(Box::new(TConst(Unit)), Box::new(return_type))
} else {
let mut output_type = return_type;
for p in sig.params.iter() {
let p_type = p.1.as_ref().map(|anno| self.from_anno(anno)).unwrap_or_else(|| { get_type() });
output_type = TFunc(Box::new(p_type), Box::new(output_type));
}
output_type
}
}
pub fn type_check(&mut self, ast: &AST) -> TypeCheckResult {
use self::Type::*;
use self::TypeConst::*;
let mut last = TConst(Unit);
for statement in ast.0.iter() {
match statement {
&Statement::Declaration(ref _decl) => {
//return Err(format!("Declarations not supported"));
},
&Statement::ExpressionStatement(ref expr) => {
last = self.infer(expr)?;
}
}
}
Ok(last)
}
fn infer(&mut self, expr: &Expression) -> TypeCheckResult {
match (&expr.0, &expr.1) {
(exprtype, &Some(ref anno)) => {
let tx = self.infer_no_anno(exprtype)?;
let ty = self.from_anno(anno);
self.unify(tx, ty)
},
(exprtype, &None) => self.infer_no_anno(exprtype),
}
}
fn infer_no_anno(&mut self, ex: &ExpressionType) -> TypeCheckResult {
use self::ExpressionType::*;
use self::Type::*;
use self::TypeConst::*;
Ok(match ex {
&IntLiteral(_) => TConst(Integer),
&FloatLiteral(_) => TConst(Float),
&StringLiteral(_) => TConst(StringT),
&BoolLiteral(_) => TConst(Boolean),
&Value(ref name, _) => {
self.lookup(name)
.map(|entry| entry.ty)
.ok_or(format!("Couldn't find {}", name))?
},
&BinExp(ref op, ref lhs, ref rhs) => {
let t_lhs = self.infer(lhs)?;
match self.infer_op(op)? {
TFunc(t1, t2) => {
let _ = self.unify(t_lhs, *t1)?;
let t_rhs = self.infer(rhs)?;
let x = *t2;
match x {
TFunc(t3, t4) => {
let _ = self.unify(t_rhs, *t3)?;
*t4
},
_ => return Err(format!("Not a function type either")),
}
},
_ => return Err(format!("Op {:?} is not a function type", op)),
}
},
&Call { ref f, ref arguments } => {
let tf = self.infer(f)?;
let targ = self.infer(arguments.get(0).unwrap())?;
match tf {
TFunc(box t1, box t2) => {
let _ = self.unify(t1, targ)?;
t2
},
_ => return Err(format!("Not a function!")),
}
},
_ => TConst(Bottom),
})
}
fn infer_op(&mut self, op: &Operation) -> TypeCheckResult {
use self::Type::*;
use self::TypeConst::*;
macro_rules! binoptype {
($lhs:expr, $rhs:expr, $out:expr) => { TFunc(Box::new($lhs), Box::new(TFunc(Box::new($rhs), Box::new($out)))) };
}
Ok(match (*op.0).as_ref() {
"+" => binoptype!(TConst(Integer), TConst(Integer), TConst(Integer)),
"++" => binoptype!(TConst(StringT), TConst(StringT), TConst(StringT)),
"-" => binoptype!(TConst(Integer), TConst(Integer), TConst(Integer)),
"*" => binoptype!(TConst(Integer), TConst(Integer), TConst(Integer)),
"/" => binoptype!(TConst(Integer), TConst(Integer), TConst(Integer)),
"%" => binoptype!(TConst(Integer), TConst(Integer), TConst(Integer)),
_ => TConst(Bottom)
})
}
fn unify(&mut self, t1: Type, t2: Type) -> TypeCheckResult {
use self::Type::*;
use self::TypeVar::*;
println!("Calling unify with `{:?}` and `{:?}`", t1, t2);
match (&t1, &t2) {
(&TConst(ref c1), &TConst(ref c2)) if c1 == c2 => Ok(TConst(c1.clone())),
(&TFunc(ref t1, ref t2), &TFunc(ref t3, ref t4)) => {
let t5 = self.unify(*t1.clone().clone(), *t3.clone().clone())?;
let t6 = self.unify(*t2.clone().clone(), *t4.clone().clone())?;
Ok(TFunc(Box::new(t5), Box::new(t6)))
},
(&TVar(Univ(ref a)), &TVar(Univ(ref b))) => {
if a == b {
Ok(TVar(Univ(a.clone())))
} else {
Err(format!("Couldn't unify universal types {} and {}", a, b))
}
},
//the interesting case!!
(&TVar(Exist(ref a)), ref t2) => {
let x = self.evar_table.get(a).map(|x| x.clone());
match x {
Some(ref t1) => self.unify(t1.clone().clone(), t2.clone().clone()),
None => {
self.evar_table.insert(*a, t2.clone().clone());
Ok(t2.clone().clone())
} | } | random_line_split |
|
chinpnr_account_pull.py | 1474013', '6000060281607816', '6000060281871398',
'6000060281894104', '6000060281940983', '6000060281943249', '6000060281948468', '6000060281951239',
'6000060282077968', '6000060282137644', '6000060282182522', '6000060282311535', '6000060282710505',
'6000060282717438', '6000060282742464', '6000060282989858', '6000060283127582', '6000060283130426',
'6000060283534963', '6000060283674197', '6000060283766962', '6000060283907622', '6000060284026975',
'6000060284270807', '6000060284481606', '6000060284562617', '6000060284596038', '6000060284630143',
'6000060284785850', '6000060284935948', '6000060284839400', '6000060284931568', '6000060285006663',
'6000060285020576', '6000060285032126', '6000060285046175', '6000060285140278', '6000060285234195',
'6000060285338298', '6000060285405642', '6000060285407551', '6000060285416934', '6000060285740076',
'6000060285780870', '6000060285804863', '6000060285887505', '6000060285912666', '6000060285968865',
'6000060285986006', '6000060286048091', '6000060286091596', '6000060286117523', '6000060286187430',
'6000060286197465', '6000060286349444', '6000060286369920', '6000060286403660', '6000060286413551',
'6000060286417968', '6000060286426949', '6000060286533431', '6000060286556059', '6000060286595864',
'6000060286670372', '6000060286823653', '6000060286954351', '6000060286957811', '6000060286982865',
'6000060287011733', '6000060287029653', '6000060287235449', '6000060287231096', '6000060287352204',
'6000060287417868', '6000060287772938', '6000060287798974', '6000060287808918', '6000060287904635',
'6000060287977744', '6000060288128045', '6000060288346997', '6000060288530136', '6000060288602727',
'6000060288963837', '6000060289368328', '6000060289386415', '6000060289482294', '6000060289911927',
'6000060290281302', '6000060290300265', '6000060290550360', '6000060290686839', '6000060291077380',
| '6000060291243806', '6000060291340862', '6000060291431540', '6000060291483681', '6000060291553294',
'6000060291706959', '6000060292219430', '6000060292566439', '6000060292741605', '6000060293019252',
'6000060293381519', '6000060293320112', '6000060293384730', '6000060293387871', '6000060293694236',
'6000060293457750', '6000060293507340', '6000060293611888', '6000060293621190', '6000060295043630',
| random_line_split |
|
chinpnr_account_pull.py | (data):
# 使用cursor()方法获取操作游标
cursor = db.cursor()
# SQL 插入语句
sql = "INSERT INTO tb_chinapnr_account_detail(create_time, \
serial_number, usr_id, user_name, acct_type,debit_or_credit_mark,tran_amount,free_amount,acct_amount,in_usr_id,buss_type,des_note) \
VALUES ('%s', '%s', '%s', '%s', '%s','%s','%s','%s','%s','%s','%s','%s')" % \
(data[0], data[1], data[2], data[3], data[4], data[5], data[6].replace(',', ''), data[7].replace(',', ''),
data[8].replace(',', ''), data[9], data[10], data[11])
# try:
# 执行sql语句
cursor.execute(sql)
# 提交到数据库执行
db.commit()
# except:
# 发生错误时回滚
# db.rollback()
usrids = ['6000060269448244', '6000060269448119', '6000060269453923', '6000060269456948', '6000060269455093',
'6000060269455994', '6000060269459071', '6000060269455869', '6000060269456118', '6000060269456261',
'6000060269457616', '6000060269462708', '6000060269461736', '6000060269463618', '6000060269652085',
'6000060269469033', '6000060269480234', '6000060269480225', '6000060269488245', '6000060269554011',
'6000060269572475', '6000060269586521', '6000060269591533', '6000060269593773', '6000060269693585',
'6000060269697796', '6000060269696840', '6000060269699222', '6000060269764954', '6000060269743638',
'6000060269785094', '6000060269786761', '6000060269810654', '6000060269826745', '6000060269918708',
'6000060269935173', '6000060269938241', '6000060269943716', '6000060269968627', '6000060269971043',
'6000060269974255', '6000060269991218', '6000060269996017', '6000060270007753', '6000060269998792',
'6000060270012462', '6000060270016379', '6000060273437908', '6000060270080487', '6000060270084474',
'6000060270088461', '6000060270122389', '6000060270120452', '6000060270130888', '6000060270167777',
'6000060270178319', '6000060270182545', '6000060270187327', '6000060270193123', '6000060270194961',
'6000060270196585', '6000060270197334', '6000060270207724', '6000060270245666', '6000060270250454',
'6000060270290465', '6000060270326597', '6000060270329727', '6000060270457918', '6000060270711545',
'6000060270777172', '6000060270787884', '6000060270839686', '6000060270979347', '6000060271138986',
'6000060271413848', '6000060271429555', '6000060271431891', '6000060271441461', '6000060271607309',
'6000060271765842', '6000060272137958', '6000060272216676', '6000060272235138', '6000060272451778',
'6000060272579695', '6000060272620195', '6000060272734740', '6000060272779728', '6000060272799975',
'6000060272947208', '6000060273017933', '6000060273037378', '6000060273060715', '6000060273155882',
'6000060273210947', '6000060273239329', '6000060273302928', '6000060273307834', '600006027332921 | insert | identifier_name |
|
chinpnr_account_pull.py | 000060286369920', '6000060286403660', '6000060286413551',
'6000060286417968', '6000060286426949', '6000060286533431', '6000060286556059', '6000060286595864',
'6000060286670372', '6000060286823653', '6000060286954351', '6000060286957811', '6000060286982865',
'6000060287011733', '6000060287029653', '6000060287235449', '6000060287231096', '6000060287352204',
'6000060287417868', '6000060287772938', '6000060287798974', '6000060287808918', '6000060287904635',
'6000060287977744', '6000060288128045', '6000060288346997', '6000060288530136', '6000060288602727',
'6000060288963837', '6000060289368328', '6000060289386415', '6000060289482294', '6000060289911927',
'6000060290281302', '6000060290300265', '6000060290550360', '6000060290686839', '6000060291077380',
'6000060291243806', '6000060291340862', '6000060291431540', '6000060291483681', '6000060291553294',
'6000060291706959', '6000060292219430', '6000060292566439', '6000060292741605', '6000060293019252',
'6000060293381519', '6000060293320112', '6000060293384730', '6000060293387871', '6000060293694236',
'6000060293457750', '6000060293507340', '6000060293611888', '6000060293621190', '6000060295043630',
'6000060295245128', '6000060295298124', '6000060295371605', '6000060295427413', '6000060295767894',
'6000060295876437']
# usrids = ['6000060269448244', '6000060269448119', '6000060269652085']
import time
import requests
from lxml import html
browser = webdriver.Chrome()
browser.get("https://wealth.cloudpnr.com/p2padmin/")
input = browser.find_element_by_id("login_operator_id")
input.send_keys("[email protected]")
# input.send_keys(Keys.ENTER)
input = browser.find_element_by_id("login_password")
input.send_keys("972506")
# input.send_keys(Keys.ENTER)
str1 = input("Enter your input: ")
input = browser.find_element_by_id("captcha")
input.send_keys(str1)
input.send_keys(Keys.ENTER)
# 等待时间
wait = WebDriverWait(browser, 10)
wait.until(EC.presence_of_element_located((By.CLASS_NAME, "header-infos")))
# print(browser.current_url)
# print(browser.get_cookies())
# print(browser.page_source)
# time.sleep(10)
browser.get('https://wealth.cloudpnr.com/p2padmin/report/index/report/id/500005')
# tree = html.fromstring(browser.page_source)
# data = ''.join(tree.xpath('//span[contains(text(),"客户账户明细查询")]/text()'))
wait.until(EC.presence_of_element_located((By.CLASS_NAME, "main-content-title")))
# 点击查询
query = browser.find_element_by_xpath('//a[@class="btn btn-primary ajax-get-data"]')
# 查询开始时间
date_start_input = browser.find_element_by_name('date_from')
# 查询结束时间
date_end_input = browser.find_element_by_name('date_to')
# 客户号
cust_input = browser.find_element_by_name('custId')
for usrid in usrids:
num = 0s
cust_input.clear()
cust_input.send_keys(usrid)
queryDate = [['2018-03-12', '2018-06-10'], ['2018-06-11', '2018-07-31']]
for dateq in queryDate:
date_start_input.clear()
date_start_input.send_keys(dateq[0])
date_end_input.clear()
date_end_input.send_keys(dateq[1])
query.click()
# "btn ajax-get-data btn-disabled"
wait.until(EC.presence_of_element_located((By.XPATH, '//a[@class="btn ajax-get-data btn-primary"]')))
# 获取总页数
size = browser.find_element_by_xpath('//p[@class="page"]/span/strong').text
# print(size)
if int(size) > 0:
# 数据总页数
total = browser.find_element_by_xpath('//p[@class="page"]/input[@max]').get_attribute('max')
for i in range(1, int(total) + 1):
| if i != 1:
next = browser.find_element_by_xpath('//p[@class="page"]/a[@title="Next"]')
next.click()
wait.until(EC.presence_of_element_located(
(By.XPATH, '//p[@class="page"]/a[@class="current" and @title="' + str(i) + '"]')))
# pageindex = browser.find_element_by_xpath('//div[@class="table dis"]/table/tbody/tr')
trs = browser.find_elements_by_xpath('//div[@class="table dis"]/table/tbody/tr')
for tr in trs:
one = list()
tds = tr.find_elements_by_xpath('.//td')
for j in range(0, len(tds)):
if j > 0:
one.append(tds[j].text)
insert(one)
# print(e.text)
num += 1
# pageindex = browser.find_element_by_xpath('//p[@class="page"]/a[@class="current"]').text
# if i<total:
| conditional_block |
|
chinpnr_account_pull.py | 453923', '6000060269456948', '6000060269455093',
'6000060269455994', '6000060269459071', '6000060269455869', '6000060269456118', '6000060269456261',
'6000060269457616', '6000060269462708', '6000060269461736', '6000060269463618', '6000060269652085',
'6000060269469033', '6000060269480234', '6000060269480225', '6000060269488245', '6000060269554011',
'6000060269572475', '6000060269586521', '6000060269591533', '6000060269593773', '6000060269693585',
'6000060269697796', '6000060269696840', '6000060269699222', '6000060269764954', '6000060269743638',
'6000060269785094', '6000060269786761', '6000060269810654', '6000060269826745', '6000060269918708',
'6000060269935173', '6000060269938241', '6000060269943716', '6000060269968627', '6000060269971043',
'6000060269974255', '6000060269991218', '6000060269996017', '6000060270007753', '6000060269998792',
'6000060270012462', '6000060270016379', '6000060273437908', '6000060270080487', '6000060270084474',
'6000060270088461', '6000060270122389', '6000060270120452', '6000060270130888', '6000060270167777',
'6000060270178319', '6000060270182545', '6000060270187327', '6000060270193123', '6000060270194961',
'6000060270196585', '6000060270197334', '6000060270207724', '6000060270245666', '6000060270250454',
'6000060270290465', '6000060270326597', '6000060270329727', '6000060270457918', '6000060270711545',
'6000060270777172', '6000060270787884', '6000060270839686', '6000060270979347', '6000060271138986',
'6000060271413848', '6000060271429555', '6000060271431891', '6000060271441461', '6000060271607309',
'6000060271765842', '6000060272137958', '6000060272216676', '6000060272235138', '6000060272451778',
'6000060272579695', '6000060272620195', '6000060272734740', '6000060272779728', '6000060272799975',
'6000060272947208', '6000060273017933', '6000060273037378', '6000060273060715', '6000060273155882',
'6000060273210947', '6000060273239329', '6000060273302928', '6000060273307834', '6000060273329213',
'600006027350397 |
# SQL 插入语句
sql = "INSERT INTO tb_chinapnr_account_detail(create_time, \
serial_number, usr_id, user_name, acct_type,debit_or_credit_mark,tran_amount,free_amount,acct_amount,in_usr_id,buss_type,des_note) \
VALUES ('%s', '%s', '%s', '%s', '%s','%s','%s','%s','%s','%s','%s','%s')" % \
(data[0], data[1], data[2], data[3], data[4], data[5], data[6].replace(',', ''), data[7].replace(',', ''),
data[8].replace(',', ''), data[9], data[10], data[11])
# try:
# 执行sql语句
cursor.execute(sql)
# 提交到数据库执行
db.commit()
# except:
# 发生错误时回滚
# db.rollback()
usrids = ['6000060269448244', '6000060269448119', '6000060269 | identifier_body |
|
viewer.js | == "no")) {
this.playing = false;
}
this.updateButtons();
if (this.args.speed) {
var speed = parseFloat(this.args.speed);
if (!isNaN(speed)) this.speed = speed;
}
// Load game, if passed by url
var game = null;
if (this.args.web) { // Request game with ajax
game = "index.php?game="+this.args.web+"&p="+this.args.p+"&u=1";
}
else if (this.args.sub) |
else game = this.args.game;
if (!game) {
$("File").addEventListener("change", function(ev) {
if (ev.target.files.length > 0) {
Viewer.loadFromFile(ev.target.files[0]);
}
}, false);
this.showOverlay("Upload");
}
else this.loadFromURL(game);
},
showOverlay: function(id) {
var ov = $("Overlay");
for (var i = 0; i < ov.childNodes.length; ++i) {
var c = ov.childNodes.item(i);
if (c.nodeValue === null) {
c.style.display = (c.getAttribute("id") == id)? "block" : "none";
}
}
},
showError: function(msg, desc) {
var div = $("Error");
div.childNodes[1].textContent = msg;
if (desc) div.childNodes[5].innerHTML = desc;
this.showOverlay("Error");
},
loadFromFile: function(file) {
if (!file) return;
this.loadStart();
var reader = new FileReader();
reader.onload = function(ev) { Viewer.gameLoaded(ev.target.result); };
reader.readAsText(file);
},
loadFromURL: function(url) {
this.loadStart();
try {
ajaxGet(url, function(s) { Viewer.gameLoaded(s); });
} catch (e) {
this.showError("UNABLE TO LOAD GAME", e);
}
},
loadStart: function() {
this.loading = 1;
this.showOverlay("Loading");
},
gameLoaded: function(input) {
try {
var lines = input.replace("\r", "").split("\n");
if (!input || lines.length == 1) throw "404: Game Not Found!";
var v = splitWhitespace(lines[0]);
var gameClass = this.supportedGames[v[0]];
if (!gameClass) throw "Unsupported game: \""+lines[0]+"\"!";
this.args.version = v;
this.game = new gameClass(this.args, lines);
this.theme = this.game.renderer; //game.getTheme(this.args);
}
catch (ex) {
this.showError("Game load error", ex);
return;
}
this.theme.preload(this);
this.loaded();
},
loaded: function() {
if (--this.loading > 0) return;
this.renderer = new Renderer(this.gl, this.canvas);
this.theme.init(this.renderer, this.game);
this.resized();
document.body.addEventListener("keydown", function(ev) { Viewer.keyPressed(ev); }, false);
this.canvas.addEventListener("mousedown", function(ev) { Viewer.mouseDown(ev); }, false);
this.canvas.addEventListener("mouseup", function(ev) { Viewer.mouseUp(ev); }, false);
this.canvas.addEventListener("mousemove", function(ev) { Viewer.mouseMove(ev); }, false);
this.canvas.addEventListener("mouseout", function(ev) { Viewer.mouseOut(ev); }, false);
this.canvas.addEventListener("mousewheel", function(ev) { Viewer.mouseWheel(ev); }, false);
var root = $("Players");
for (var i = 0; i < this.game.nPlayers; ++i) {
var div = document.createElement("div");
div.className = "player";
var s =
'<div><span class="color"></span><span class="name"></span></div>'+
'<p>Score: <span class="score"></span></p>';
for (var j = 0; j < this.game.playerInfo.length; ++j) {
s += '<p>' + this.game.playerInfo[j][0] + ': <span></span></p>';
}
div.innerHTML = s;
root.appendChild(div);
this.infoDivs.push(div);
div.childNodes[0].childNodes[1].textContent = this.game.names[i];
if (this.game.names[i] == "Tonto") div.childNodes[0].childNodes[1].className += " bot";
var c = this.theme.playerColors[i];
div.childNodes[0].childNodes[0].style.backgroundColor = "rgb("+Math.floor(c[0]*255.0)+", "+Math.floor(c[1]*255.0)+", "+Math.floor(c[2]*255.0)+")";
}
// Ready
$("Overlay").style.display = "none";
if (this.music) this.music.play();
this.tick();
},
tickCallback: function(t) { Viewer.tick(t); },
tick: function(t) {
var dt = this.lastTick? t - this.lastTick : 0;
if (isNaN(t)) this.lastTick = 0;
else this.lastTick = t;
// Update info
var r = Math.max(0, Math.min(this.game.nRounds, Math.floor(this.time)));
this.divRound.childNodes[1].textContent = r + " / " + this.game.nRounds;
this.divRound.childNodes[0].style.width = (100 * Math.max(0, Math.min(1, this.time / this.game.nRounds))) + "%";
var round = this.game.rounds[Math.min(this.game.nRounds - 1, r)];
var winning = []; var maxScore = -1;
for (var i = 0; i < this.game.nPlayers; ++i) {
var div = this.infoDivs[i];
div.childNodes[1].childNodes[1].textContent = round.score[i];
for (var j = 0; j < this.game.playerInfo.length; ++j) {
div.childNodes[2 + j].childNodes[1].textContent = this.game.playerInfo[j][1](round, i);
}
if (round.score[i] > maxScore) { maxScore = round.score[i]; winning = [i]; }
else if (round.score[i] == maxScore) { winning.push(i); }
}
var msg = "";
if (r > 0) {
if (winning.length == 1) msg = this.game.names[winning[0]];
else {
msg = this.game.names[winning[0]];
for (var i = 1; i < winning.length; ++i) msg += " & " + this.game.names[winning[i]];
}
if (r >= this.game.nRounds) {
if (winning.length == 1) msg += " won!";
else msg += " tied!";
}
else {
if (winning.length == 1) msg += " is winning!";
else msg += " are tied!";
}
}
this.divNarration.textContent = msg;
this.theme.W = this.canvas.width;
this.theme.H = this.canvas.height;
this.theme.render(this.game, this.time);
if (this.playing) this.time += dt * this.speed / 1000;
// Schedule next tick
this.nextTick = window.requestAnimationFrame(this.tickCallback);
},
resized: function() {
this.canvas.width = window.innerWidth - 4;
this.canvas.height = window.innerHeight - 4;
},
keyPressed: function(ev) {
var code = ((ev.keyCode !== undefined)? ev.keyCode : ev.which);
switch (code) {
case 32: // Space
this.togglePlay(); break;
case 33: // Page Down
this.advance(-10); break;
case 34: // Page Up
this.advance(10); break;
case 35: // End
this.time = this.game.nRounds; break;
case 36: // Start
this.time = 0; break;
case 37: // Left
case 38: // Up
this.advance(-1); break;
case 39: // Right
case 40: // Down
this.advance(1); break;
case 72: // 'h'
this.showHelp(); break;
case 76: // 'l'
var newSpeed = prompt("New speed? (turns per second)");
if (newSpeed) {
newSpeed = parseFloat(newSpeed);
if (!isNaN(newSpeed)) this.speed = Math.max(0.1, Math.min(10.0, newSpeed));
}
break;
case 80: // 'p'
this.toggleFullscreen();
break;
default:
| { // Arguments passed by Jutge
if (location.host) game = location.protocol + "//" + location.host + "/";
else game = "https://battle-royale-eda.jutge.org/";
if (this.args.nbr) {
game += "?cmd=lliuraments&sub="+this.args.sub+"&nbr="+this.args.nbr+"&download=partida";
}
else game += "?cmd=partida&sub="+this.args.sub+"&download=partida";
} | conditional_block |
viewer.js | }, false);
this.canvas.addEventListener("mousemove", function(ev) { Viewer.mouseMove(ev); }, false);
this.canvas.addEventListener("mouseout", function(ev) { Viewer.mouseOut(ev); }, false);
this.canvas.addEventListener("mousewheel", function(ev) { Viewer.mouseWheel(ev); }, false);
var root = $("Players");
for (var i = 0; i < this.game.nPlayers; ++i) {
var div = document.createElement("div");
div.className = "player";
var s =
'<div><span class="color"></span><span class="name"></span></div>'+
'<p>Score: <span class="score"></span></p>';
for (var j = 0; j < this.game.playerInfo.length; ++j) {
s += '<p>' + this.game.playerInfo[j][0] + ': <span></span></p>';
}
div.innerHTML = s;
root.appendChild(div);
this.infoDivs.push(div);
div.childNodes[0].childNodes[1].textContent = this.game.names[i];
if (this.game.names[i] == "Tonto") div.childNodes[0].childNodes[1].className += " bot";
var c = this.theme.playerColors[i];
div.childNodes[0].childNodes[0].style.backgroundColor = "rgb("+Math.floor(c[0]*255.0)+", "+Math.floor(c[1]*255.0)+", "+Math.floor(c[2]*255.0)+")";
}
// Ready
$("Overlay").style.display = "none";
if (this.music) this.music.play();
this.tick();
},
tickCallback: function(t) { Viewer.tick(t); },
tick: function(t) {
var dt = this.lastTick? t - this.lastTick : 0;
if (isNaN(t)) this.lastTick = 0;
else this.lastTick = t;
// Update info
var r = Math.max(0, Math.min(this.game.nRounds, Math.floor(this.time)));
this.divRound.childNodes[1].textContent = r + " / " + this.game.nRounds;
this.divRound.childNodes[0].style.width = (100 * Math.max(0, Math.min(1, this.time / this.game.nRounds))) + "%";
var round = this.game.rounds[Math.min(this.game.nRounds - 1, r)];
var winning = []; var maxScore = -1;
for (var i = 0; i < this.game.nPlayers; ++i) {
var div = this.infoDivs[i];
div.childNodes[1].childNodes[1].textContent = round.score[i];
for (var j = 0; j < this.game.playerInfo.length; ++j) {
div.childNodes[2 + j].childNodes[1].textContent = this.game.playerInfo[j][1](round, i);
}
if (round.score[i] > maxScore) { maxScore = round.score[i]; winning = [i]; }
else if (round.score[i] == maxScore) { winning.push(i); }
}
var msg = "";
if (r > 0) {
if (winning.length == 1) msg = this.game.names[winning[0]];
else {
msg = this.game.names[winning[0]];
for (var i = 1; i < winning.length; ++i) msg += " & " + this.game.names[winning[i]];
}
if (r >= this.game.nRounds) {
if (winning.length == 1) msg += " won!";
else msg += " tied!";
}
else {
if (winning.length == 1) msg += " is winning!";
else msg += " are tied!";
}
}
this.divNarration.textContent = msg;
this.theme.W = this.canvas.width;
this.theme.H = this.canvas.height;
this.theme.render(this.game, this.time);
if (this.playing) this.time += dt * this.speed / 1000;
// Schedule next tick
this.nextTick = window.requestAnimationFrame(this.tickCallback);
},
resized: function() {
this.canvas.width = window.innerWidth - 4;
this.canvas.height = window.innerHeight - 4;
},
keyPressed: function(ev) {
var code = ((ev.keyCode !== undefined)? ev.keyCode : ev.which);
switch (code) {
case 32: // Space
this.togglePlay(); break;
case 33: // Page Down
this.advance(-10); break;
case 34: // Page Up
this.advance(10); break;
case 35: // End
this.time = this.game.nRounds; break;
case 36: // Start
this.time = 0; break;
case 37: // Left
case 38: // Up
this.advance(-1); break;
case 39: // Right
case 40: // Down
this.advance(1); break;
case 72: // 'h'
this.showHelp(); break;
case 76: // 'l'
var newSpeed = prompt("New speed? (turns per second)");
if (newSpeed) {
newSpeed = parseFloat(newSpeed);
if (!isNaN(newSpeed)) this.speed = Math.max(0.1, Math.min(10.0, newSpeed));
}
break;
case 80: // 'p'
this.toggleFullscreen();
break;
default:
if (this.theme && this.theme.keyPressed) this.theme.keyPressed(code);
}
},
mouseDown: function(ev) {
this.lastMouse[0] = ev.clientX;
this.lastMouse[1] = ev.clientY;
this.mousePressed = true;
},
mouseMove: function(ev) {
if (this.mousePressed && this.theme && this.theme.mouseMoved) {
var dx = ev.clientX - this.lastMouse[0];
var dy = ev.clientY - this.lastMouse[1];
this.lastMouse[0] = ev.clientX;
this.lastMouse[1] = ev.clientY;
this.theme.mouseMoved(dx, dy);
}
},
mouseUp: function(ev) {
this.mousePressed = false;
},
mouseOut: function(ev) {
this.mousePressed = false;
},
mouseWheel: function(ev) {
if (this.theme && this.theme.mouseWheel) this.theme.mouseWheel(ev.wheelDelta);
},
updateButtons: function() {
this.btnPlayPause.textContent = this.playing? "Pause" : "Play";
},
stop: function() {
this.pause();
this.time = 0;
this.updateButtons();
},
pause: function() {
this.playing = false;
this.updateButtons();
},
play: function() {
this.playing = true;
this.updateButtons();
},
togglePlay: function() {
if (this.playing) this.pause();
else this.play();
},
advance: function(t) {
this.pause();
this.time = Math.max(0, Math.min(this.game.nRounds, Math.round(this.time) + t));
},
setTime: function(t) {
var wasPlaying = this.playing;
this.pause();
this.time = this.game.nRounds * t;
if (wasPlaying) this.play();
},
inFullscreen: function() {
return !(!document.fullscreenElement && !document.mozFullScreenElement && !document.webkitFullscreenElement);
},
enterFullscreen: function() {
var el = document.body;
if (el.webkitRequestFullScreen) {
el.webkitRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT);
}
else if (el.mozRequestFullScreen) {
el.mozRequestFullScreen();
}
},
exitFullscreen: function() {
if (document.cancelFullScreen) document.cancelFullScreen();
else if (document.mozCancelFullScreen) document.mozCancelFullScreen();
else if (document.webkitCancelFullScreen) document.webkitCancelFullScreen();
},
toggleFullscreen: function() {
if (this.inFullscreen()) this.exitFullscreen();
else this.enterFullscreen();
},
loadFile: function(url) {
++this.loading;
var file = { content: "" };
try {
ajaxGet(url, function(s) {
file.content = s;
Viewer.loaded();
});
} catch (e) {
this.showError("UNABLE TO LOAD FILE ", url+"Could not load file \""+url+"\"<br/>"+e);
}
return file;
},
loadImage: function(url) {
++this.loading;
var img = new Image();
img.onload = function() { Viewer.loaded(); };
img.src = url;
return img;
},
loadModel: function(url) {
++this.loading;
var mdl = new OBJ();
try {
ajaxGet(url, function(s) {
mdl.load(s);
Viewer.loaded();
});
} catch (e) {
this.showError("UNABLE TO LOAD MODEL", "Could not load model \""+url+"\"<br/>"+e);
}
return mdl;
}, |
loadMusic: function(url) {
++this.loading;
this.stopMusic(); | random_line_split |
|
keyboard.rs | => Key::F3,
Code::F4 => Key::F4,
Code::F5 => Key::F5,
Code::F6 => Key::F6,
Code::F7 => Key::F7,
Code::F8 => Key::F8,
Code::F9 => Key::F9,
Code::F10 => Key::F10,
Code::NumLock => Key::NumLock,
Code::ScrollLock => Key::ScrollLock,
Code::Numpad0 => n(m, Key::Insert, "0"),
Code::Numpad1 => n(m, Key::End, "1"),
Code::Numpad2 => n(m, Key::ArrowDown, "2"),
Code::Numpad3 => n(m, Key::PageDown, "3"),
Code::Numpad4 => n(m, Key::ArrowLeft, "4"),
Code::Numpad5 => n(m, Key::Clear, "5"),
Code::Numpad6 => n(m, Key::ArrowRight, "6"),
Code::Numpad7 => n(m, Key::Home, "7"),
Code::Numpad8 => n(m, Key::ArrowUp, "8"),
Code::Numpad9 => n(m, Key::PageUp, "9"),
Code::NumpadSubtract => a("-"),
Code::NumpadAdd => a("+"),
Code::NumpadDecimal => n(m, Key::Delete, "."),
Code::IntlBackslash => s(m, "\\", "|"),
Code::F11 => Key::F11,
Code::F12 => Key::F12,
// This mapping is based on the picture in the w3c spec.
Code::IntlRo => a("\\"),
Code::Convert => Key::Convert,
Code::KanaMode => Key::KanaMode,
Code::NonConvert => Key::NonConvert,
Code::NumpadEnter => Key::Enter,
Code::ControlRight => Key::Control,
Code::NumpadDivide => a("/"),
Code::PrintScreen => Key::PrintScreen,
Code::AltRight => Key::Alt,
Code::Home => Key::Home,
Code::ArrowUp => Key::ArrowUp,
Code::PageUp => Key::PageUp,
Code::ArrowLeft => Key::ArrowLeft,
Code::ArrowRight => Key::ArrowRight,
Code::End => Key::End,
Code::ArrowDown => Key::ArrowDown,
Code::PageDown => Key::PageDown,
Code::Insert => Key::Insert,
Code::Delete => Key::Delete,
Code::AudioVolumeMute => Key::AudioVolumeMute,
Code::AudioVolumeDown => Key::AudioVolumeDown,
Code::AudioVolumeUp => Key::AudioVolumeUp,
Code::NumpadEqual => a("="),
Code::Pause => Key::Pause,
Code::NumpadComma => a(","),
Code::Lang1 => Key::HangulMode,
Code::Lang2 => Key::HanjaMode,
Code::IntlYen => a("¥"),
Code::MetaLeft => Key::Meta,
Code::MetaRight => Key::Meta,
Code::ContextMenu => Key::ContextMenu,
Code::BrowserStop => Key::BrowserStop,
Code::Again => Key::Again,
Code::Props => Key::Props,
Code::Undo => Key::Undo,
Code::Select => Key::Select,
Code::Copy => Key::Copy,
Code::Open => Key::Open,
Code::Paste => Key::Paste,
Code::Find => Key::Find,
Code::Cut => Key::Cut,
Code::Help => Key::Help,
Code::LaunchApp2 => Key::LaunchApplication2,
Code::WakeUp => Key::WakeUp,
Code::LaunchApp1 => Key::LaunchApplication1,
Code::LaunchMail => Key::LaunchMail,
Code::BrowserFavorites => Key::BrowserFavorites,
Code::BrowserBack => Key::BrowserBack,
Code::BrowserForward => Key::BrowserForward,
Code::Eject => Key::Eject,
Code::MediaTrackNext => Key::MediaTrackNext,
Code::MediaPlayPause => Key::MediaPlayPause,
Code::MediaTrackPrevious => Key::MediaTrackPrevious,
Code::MediaStop => Key::MediaStop,
Code::MediaSelect => Key::LaunchMediaPlayer,
Code::BrowserHome => Key::BrowserHome,
Code::BrowserRefresh => Key::BrowserRefresh,
Code::BrowserSearch => Key::BrowserSearch,
_ => Key::Unidentified,
}
}
#[cfg(target_os = "linux")]
/// Map hardware keycode to code.
///
/// In theory, the hardware keycode is device dependent, but in
/// practice it's probably pretty reliable.
///
/// The logic is based on NativeKeyToDOMCodeName.h in Mozilla.
fn hardware_keycode_to_code(hw_keycode: u16) -> Code {
match hw_keycode {
0x0009 => Code::Escape,
0x000A => Code::Digit1,
0x000B => Code::Digit2,
0x000C => Code::Digit3,
0x000D => Code::Digit4,
0x000E => Code::Digit5,
0x000F => Code::Digit6,
0x0010 => Code::Digit7,
0x0011 => Code::Digit8,
0x0012 => Code::Digit9,
0x0013 => Code::Digit0,
0x0014 => Code::Minus,
0x0015 => Code::Equal,
0x0016 => Code::Backspace,
0x0017 => Code::Tab,
0x0018 => Code::KeyQ,
0x0019 => Code::KeyW,
0x001A => Code::KeyE,
0x001B => Code::KeyR,
0x001C => Code::KeyT,
0x001D => Code::KeyY,
0x001E => Code::KeyU,
0x001F => Code::KeyI,
0x0020 => Code::KeyO,
0x0021 => Code::KeyP,
0x0022 => Code::BracketLeft,
0x0023 => Code::BracketRight,
0x0024 => Code::Enter,
0x0025 => Code::ControlLeft,
0x0026 => Code::KeyA,
0x0027 => Code::KeyS,
0x0028 => Code::KeyD,
0x0029 => Code::KeyF,
0x002A => Code::KeyG,
0x002B => Code::KeyH,
0x002C => Code::KeyJ,
0x002D => Code::KeyK,
0x002E => Code::KeyL,
0x002F => Code::Semicolon,
0x0030 => Code::Quote,
0x0031 => Code::Backquote,
0x0032 => Code::ShiftLeft,
0x0033 => Code::Backslash,
0x0034 => Code::KeyZ,
0x0035 => Code::KeyX,
0x0036 => Code::KeyC,
0x0037 => Code::KeyV,
0x0038 => Code::KeyB,
0x0039 => Code::KeyN,
0x003A => Code::KeyM,
0x003B => Code::Comma,
0x003C => Code::Period,
0x003D => Code::Slash,
0x003E => Code::ShiftRight,
0x003F => Code::NumpadMultiply,
0x0040 => Code::AltLeft,
0x0041 => Code::Space,
0x0042 => Code::CapsLock,
0x0043 => Code::F1,
0x0044 => Code::F2,
0x0045 => Code::F3,
0x0046 => Code::F4,
0x0047 => Code::F5,
0x0048 => Code::F6, | 0x0049 => Code::F7,
0x004A => Code::F8,
0x004B => Code::F9,
0x004C => Code::F10, | random_line_split |
|
keyboard.rs | (code: Code, m: Modifiers) -> Key {
fn a(s: &str) -> Key {
Key::Character(s.into())
}
fn s(mods: Modifiers, base: &str, shifted: &str) -> Key {
if mods.contains(Modifiers::SHIFT) {
Key::Character(shifted.into())
} else {
Key::Character(base.into())
}
}
fn n(mods: Modifiers, base: Key, num: &str) -> Key {
if mods.contains(Modifiers::NUM_LOCK) != mods.contains(Modifiers::SHIFT) {
Key::Character(num.into())
} else {
base
}
}
match code {
Code::KeyA => s(m, "a", "A"),
Code::KeyB => s(m, "b", "B"),
Code::KeyC => s(m, "c", "C"),
Code::KeyD => s(m, "d", "D"),
Code::KeyE => s(m, "e", "E"),
Code::KeyF => s(m, "f", "F"),
Code::KeyG => s(m, "g", "G"),
Code::KeyH => s(m, "h", "H"),
Code::KeyI => s(m, "i", "I"),
Code::KeyJ => s(m, "j", "J"),
Code::KeyK => s(m, "k", "K"),
Code::KeyL => s(m, "l", "L"),
Code::KeyM => s(m, "m", "M"),
Code::KeyN => s(m, "n", "N"),
Code::KeyO => s(m, "o", "O"),
Code::KeyP => s(m, "p", "P"),
Code::KeyQ => s(m, "q", "Q"),
Code::KeyR => s(m, "r", "R"),
Code::KeyS => s(m, "s", "S"),
Code::KeyT => s(m, "t", "T"),
Code::KeyU => s(m, "u", "U"),
Code::KeyV => s(m, "v", "V"),
Code::KeyW => s(m, "w", "W"),
Code::KeyX => s(m, "x", "X"),
Code::KeyY => s(m, "y", "Y"),
Code::KeyZ => s(m, "z", "Z"),
Code::Digit0 => s(m, "0", ")"),
Code::Digit1 => s(m, "1", "!"),
Code::Digit2 => s(m, "2", "@"),
Code::Digit3 => s(m, "3", "#"),
Code::Digit4 => s(m, "4", "$"),
Code::Digit5 => s(m, "5", "%"),
Code::Digit6 => s(m, "6", "^"),
Code::Digit7 => s(m, "7", "&"),
Code::Digit8 => s(m, "8", "*"),
Code::Digit9 => s(m, "9", "("),
Code::Backquote => s(m, "`", "~"),
Code::Minus => s(m, "-", "_"),
Code::Equal => s(m, "=", "+"),
Code::BracketLeft => s(m, "[", "{"),
Code::BracketRight => s(m, "]", "}"),
Code::Backslash => s(m, "\\", "|"),
Code::Semicolon => s(m, ";", ":"),
Code::Quote => s(m, "'", "\""),
Code::Comma => s(m, ",", "<"),
Code::Period => s(m, ".", ">"),
Code::Slash => s(m, "/", "?"),
Code::Space => a(" "),
Code::Escape => Key::Escape,
Code::Backspace => Key::Backspace,
Code::Tab => Key::Tab,
Code::Enter => Key::Enter,
Code::ControlLeft => Key::Control,
Code::ShiftLeft => Key::Shift,
Code::ShiftRight => Key::Shift,
Code::NumpadMultiply => a("*"),
Code::AltLeft => Key::Alt,
Code::CapsLock => Key::CapsLock,
Code::F1 => Key::F1,
Code::F2 => Key::F2,
Code::F3 => Key::F3,
Code::F4 => Key::F4,
Code::F5 => Key::F5,
Code::F6 => Key::F6,
Code::F7 => Key::F7,
Code::F8 => Key::F8,
Code::F9 => Key::F9,
Code::F10 => Key::F10,
Code::NumLock => Key::NumLock,
Code::ScrollLock => Key::ScrollLock,
Code::Numpad0 => n(m, Key::Insert, "0"),
Code::Numpad1 => n(m, Key::End, "1"),
Code::Numpad2 => n(m, Key::ArrowDown, "2"),
Code::Numpad3 => n(m, Key::PageDown, "3"),
Code::Numpad4 => n(m, Key::ArrowLeft, "4"),
Code::Numpad5 => n(m, Key::Clear, "5"),
Code::Numpad6 => n(m, Key::ArrowRight, "6"),
Code::Numpad7 => n(m, Key::Home, "7"),
Code::Numpad8 => n(m, Key::ArrowUp, "8"),
Code::Numpad9 => n(m, Key::PageUp, "9"),
Code::NumpadSubtract => a("-"),
Code::NumpadAdd => a("+"),
Code::NumpadDecimal => n(m, Key::Delete, "."),
Code::IntlBackslash => s(m, "\\", "|"),
Code::F11 => Key::F11,
Code::F12 => Key::F12,
// This mapping is based on the picture in the w3c spec.
Code::IntlRo => a("\\"),
Code::Convert => Key::Convert,
Code::KanaMode => Key::KanaMode,
Code::NonConvert => Key::NonConvert,
Code::NumpadEnter => Key::Enter,
Code::ControlRight => Key::Control,
Code::NumpadDivide => a("/"),
Code::PrintScreen => Key::PrintScreen,
Code::AltRight => Key::Alt,
Code::Home => Key::Home,
Code::ArrowUp => Key::ArrowUp,
Code::PageUp => Key::PageUp,
Code::ArrowLeft => Key::ArrowLeft,
Code::ArrowRight => Key::ArrowRight,
Code::End => Key::End,
Code::ArrowDown => Key::ArrowDown,
Code::PageDown => Key::PageDown,
Code::Insert => Key::Insert,
Code::Delete => Key::Delete,
Code::AudioVolumeMute => Key::AudioVolumeMute,
Code::AudioVolumeDown => Key::AudioVolumeDown,
Code::AudioVolumeUp => Key::AudioVolumeUp,
Code::NumpadEqual => a("="),
Code::Pause => Key::Pause,
Code::NumpadComma => a(","),
Code::Lang1 => Key::HangulMode,
Code::Lang2 => Key::HanjaMode,
Code::IntlYen => a("¥"),
Code::MetaLeft => Key::Meta,
Code::MetaRight => Key::Meta,
Code::ContextMenu => Key::ContextMenu,
Code::BrowserStop => Key::BrowserStop,
Code::Again => Key::Again,
Code::Props => Key::Props,
Code::Undo => Key::Undo,
Code::Select => Key::Select,
Code::Copy => Key::Copy,
Code::Open => Key::Open,
Code::Paste => Key::Paste,
Code::Find => Key::Find,
Code::Cut => Key::Cut,
Code::Help => Key::Help,
Code::LaunchApp2 => Key::LaunchApplication2,
Code::WakeUp => Key::WakeUp,
Code::LaunchApp1 => Key::LaunchApplication1,
Code::LaunchMail => Key::LaunchMail,
Code::BrowserFavorites => Key::BrowserFavorites,
Code::BrowserBack => Key::BrowserBack,
Code::BrowserForward => Key::BrowserForward,
Code::Eject => Key::Eject,
Code::MediaTrackNext => Key::MediaTrackNext,
Code::MediaPlayPause => Key::MediaPlayPause,
Code::MediaTrackPrevious => Key::MediaTrackPrevious,
Code::MediaStop => Key::MediaStop,
Code::MediaSelect => Key::LaunchMediaPlayer,
Code::BrowserHome => Key::BrowserHome,
Code::BrowserRefresh => Key::BrowserRefresh,
Code::BrowserSearch => Key::BrowserSearch,
_ => Key::Unidentified,
}
}
#[cfg(target_os = "linux")]
/// Map hardware keycode to code.
///
/// In theory, the hardware keycode is device dependent, but in
/// practice it's probably pretty reliable.
///
/// The logic is based on NativeKeyToDOMCodeName.h in Mozilla.
fn hardware_keycode_to_code(hw_keycode: u16) -> Code {
match | code_to_key | identifier_name |
|
keyboard.rs |
fn n(mods: Modifiers, base: Key, num: &str) -> Key {
if mods.contains(Modifiers::NUM_LOCK) != mods.contains(Modifiers::SHIFT) {
Key::Character(num.into())
} else {
base
}
}
match code {
Code::KeyA => s(m, "a", "A"),
Code::KeyB => s(m, "b", "B"),
Code::KeyC => s(m, "c", "C"),
Code::KeyD => s(m, "d", "D"),
Code::KeyE => s(m, "e", "E"),
Code::KeyF => s(m, "f", "F"),
Code::KeyG => s(m, "g", "G"),
Code::KeyH => s(m, "h", "H"),
Code::KeyI => s(m, "i", "I"),
Code::KeyJ => s(m, "j", "J"),
Code::KeyK => s(m, "k", "K"),
Code::KeyL => s(m, "l", "L"),
Code::KeyM => s(m, "m", "M"),
Code::KeyN => s(m, "n", "N"),
Code::KeyO => s(m, "o", "O"),
Code::KeyP => s(m, "p", "P"),
Code::KeyQ => s(m, "q", "Q"),
Code::KeyR => s(m, "r", "R"),
Code::KeyS => s(m, "s", "S"),
Code::KeyT => s(m, "t", "T"),
Code::KeyU => s(m, "u", "U"),
Code::KeyV => s(m, "v", "V"),
Code::KeyW => s(m, "w", "W"),
Code::KeyX => s(m, "x", "X"),
Code::KeyY => s(m, "y", "Y"),
Code::KeyZ => s(m, "z", "Z"),
Code::Digit0 => s(m, "0", ")"),
Code::Digit1 => s(m, "1", "!"),
Code::Digit2 => s(m, "2", "@"),
Code::Digit3 => s(m, "3", "#"),
Code::Digit4 => s(m, "4", "$"),
Code::Digit5 => s(m, "5", "%"),
Code::Digit6 => s(m, "6", "^"),
Code::Digit7 => s(m, "7", "&"),
Code::Digit8 => s(m, "8", "*"),
Code::Digit9 => s(m, "9", "("),
Code::Backquote => s(m, "`", "~"),
Code::Minus => s(m, "-", "_"),
Code::Equal => s(m, "=", "+"),
Code::BracketLeft => s(m, "[", "{"),
Code::BracketRight => s(m, "]", "}"),
Code::Backslash => s(m, "\\", "|"),
Code::Semicolon => s(m, ";", ":"),
Code::Quote => s(m, "'", "\""),
Code::Comma => s(m, ",", "<"),
Code::Period => s(m, ".", ">"),
Code::Slash => s(m, "/", "?"),
Code::Space => a(" "),
Code::Escape => Key::Escape,
Code::Backspace => Key::Backspace,
Code::Tab => Key::Tab,
Code::Enter => Key::Enter,
Code::ControlLeft => Key::Control,
Code::ShiftLeft => Key::Shift,
Code::ShiftRight => Key::Shift,
Code::NumpadMultiply => a("*"),
Code::AltLeft => Key::Alt,
Code::CapsLock => Key::CapsLock,
Code::F1 => Key::F1,
Code::F2 => Key::F2,
Code::F3 => Key::F3,
Code::F4 => Key::F4,
Code::F5 => Key::F5,
Code::F6 => Key::F6,
Code::F7 => Key::F7,
Code::F8 => Key::F8,
Code::F9 => Key::F9,
Code::F10 => Key::F10,
Code::NumLock => Key::NumLock,
Code::ScrollLock => Key::ScrollLock,
Code::Numpad0 => n(m, Key::Insert, "0"),
Code::Numpad1 => n(m, Key::End, "1"),
Code::Numpad2 => n(m, Key::ArrowDown, "2"),
Code::Numpad3 => n(m, Key::PageDown, "3"),
Code::Numpad4 => n(m, Key::ArrowLeft, "4"),
Code::Numpad5 => n(m, Key::Clear, "5"),
Code::Numpad6 => n(m, Key::ArrowRight, "6"),
Code::Numpad7 => n(m, Key::Home, "7"),
Code::Numpad8 => n(m, Key::ArrowUp, "8"),
Code::Numpad9 => n(m, Key::PageUp, "9"),
Code::NumpadSubtract => a("-"),
Code::NumpadAdd => a("+"),
Code::NumpadDecimal => n(m, Key::Delete, "."),
Code::IntlBackslash => s(m, "\\", "|"),
Code::F11 => Key::F11,
Code::F12 => Key::F12,
// This mapping is based on the picture in the w3c spec.
Code::IntlRo => a("\\"),
Code::Convert => Key::Convert,
Code::KanaMode => Key::KanaMode,
Code::NonConvert => Key::NonConvert,
Code::NumpadEnter => Key::Enter,
Code::ControlRight => Key::Control,
Code::NumpadDivide => a("/"),
Code::PrintScreen => Key::PrintScreen,
Code::AltRight => Key::Alt,
Code::Home => Key::Home,
Code::ArrowUp => Key::ArrowUp,
Code::PageUp => Key::PageUp,
Code::ArrowLeft => Key::ArrowLeft,
Code::ArrowRight => Key::ArrowRight,
Code::End => Key::End,
Code::ArrowDown => Key::ArrowDown,
Code::PageDown => Key::PageDown,
Code::Insert => Key::Insert,
Code::Delete => Key::Delete,
Code::AudioVolumeMute => Key::AudioVolumeMute,
Code::AudioVolumeDown => Key::AudioVolumeDown,
Code::AudioVolumeUp => Key::AudioVolumeUp,
Code::NumpadEqual => a("="),
Code::Pause => Key::Pause,
Code::NumpadComma => a(","),
Code::Lang1 => Key::HangulMode,
Code::Lang2 => Key::HanjaMode,
Code::IntlYen => a("¥"),
Code::MetaLeft => Key::Meta,
Code::MetaRight => Key::Meta,
Code::ContextMenu => Key::ContextMenu,
Code::BrowserStop => Key::BrowserStop,
Code::Again => Key::Again,
Code::Props => Key::Props,
Code::Undo => Key::Undo,
Code::Select => Key::Select,
Code::Copy => Key::Copy,
Code::Open => Key::Open,
Code::Paste => Key::Paste,
Code::Find => Key::Find,
Code::Cut => Key::Cut,
Code::Help => Key::Help,
Code::LaunchApp2 => Key::LaunchApplication2,
Code::WakeUp => Key::WakeUp,
Code::LaunchApp1 => Key::LaunchApplication1,
Code::LaunchMail => Key::LaunchMail,
Code::BrowserFavorites => Key::BrowserFavorites,
Code::BrowserBack => Key::BrowserBack,
Code::BrowserForward => Key::BrowserForward,
Code::Eject => Key::Eject,
Code::MediaTrackNext => Key::MediaTrackNext,
Code::MediaPlayPause => Key::MediaPlayPause,
Code::MediaTrackPrevious => Key::MediaTrackPrevious,
Code::MediaStop => Key::MediaStop,
Code::MediaSelect => Key::LaunchMediaPlayer,
Code::BrowserHome => Key::BrowserHome,
Code::BrowserRefresh => Key::BrowserRefresh,
Code::BrowserSearch => Key::BrowserSearch,
_ => Key::Unidentified,
}
}
#[cfg(target_os = "linux")]
/// Map hardware keycode to code.
///
/// In theory, the hardware keycode is device dependent, but in
/// practice it's probably pretty reliable.
///
/// The logic is based on NativeKeyToDOMCodeName.h in Mozilla.
fn hardware_keycode_to_code(hw_keycode: u16) -> Code {
match hw_keycode {
0x0009 => Code::Escape,
0x000A => Code::Digit1,
0x000B => Code::Digit2,
0x000C => Code | {
if mods.contains(Modifiers::SHIFT) {
Key::Character(shifted.into())
} else {
Key::Character(base.into())
}
} | identifier_body |
|
motion-export-dialog.component.ts | '@angular/material/dialog';
import { auditTime, Observable } from 'rxjs';
import { Permission } from 'src/app/domain/definitions/permission';
import {
ChangeRecoMode,
LineNumberingMode,
MOTION_PDF_OPTIONS,
PERSONAL_NOTE_ID
} from 'src/app/domain/models/motions/motions.constants';
import { StorageService } from 'src/app/gateways/storage.service';
import { ViewMotionCommentSection } from 'src/app/site/pages/meetings/pages/motions';
import { MeetingSettingsService } from 'src/app/site/pages/meetings/services/meeting-settings.service';
import { BaseUiComponent } from 'src/app/ui/base/base-ui-component';
import { MotionCommentSectionControllerService } from '../../../../modules/comments/services/motion-comment-section-controller.service';
import { ExportFileFormat, motionImportExportHeaderOrder, noMetaData } from '../../../../services/export/definitions';
import { MotionExportInfo } from '../../../../services/export/motion-export.service/motion-export.service';
@Component({
selector: `os-motion-export-dialog`,
templateUrl: `./motion-export-dialog.component.html`,
styleUrls: [`./motion-export-dialog.component.scss`],
encapsulation: ViewEncapsulation.None
})
export class MotionExportDialogComponent extends BaseUiComponent implements OnInit {
/**
* import PERSONAL_NOTE_ID for use in template
*/
public PERSONAL_NOTE_ID = PERSONAL_NOTE_ID;
public readonly permission = Permission;
/**
* For using the enum constants from the template.
*/
public lnMode = LineNumberingMode;
/**
* For using the enum constants from the template.
*/
public crMode = ChangeRecoMode;
/**
* to use the format in the template
*/
public fileFormat = ExportFileFormat;
/**
* The form that contains the export information.
*/
public exportForm!: UntypedFormGroup;
/**
* Store the subject to the ViewMotionCommentSection
*/
private commentsSubject: Observable<ViewMotionCommentSection[]>;
/**
* The default export values in contrast to the restored values
*/
private defaults: MotionExportInfo = {
format: ExportFileFormat.PDF,
content: [`text`, `reason`],
pdfOptions: [
MOTION_PDF_OPTIONS.Toc,
MOTION_PDF_OPTIONS.Header,
MOTION_PDF_OPTIONS.Page,
MOTION_PDF_OPTIONS.AddBreaks
],
metaInfo: [`submitters`, `state`, `recommendation`, `category`, `tags`, `block`, `polls`, `referring_motions`]
};
/**
* Determine the export order of the meta data
*/
public metaInfoExportOrder: string[];
/**
* @returns a list of available commentSections
*/
public get commentsToExport(): ViewMotionCommentSection[] {
return this.commentRepo.getViewModelList();
}
/**
* To deactivate the export-as-diff button
*/
@ViewChild(`diffVersionButton`, { static: true })
public diffVersionButton!: MatButtonToggle;
/**
* To deactivate the voting result button
*/
@ViewChild(`votingResultButton`, { static: true })
public votingResultButton!: MatButtonToggle;
/**
* To deactivate the referring motions button
*/
@ViewChild(`referringMotionsButton`, { static: true })
public referringMotionsButton!: MatButtonToggle;
/**
* To deactivate the speakers button.
*/
@ViewChild(`speakersButton`)
public speakersButton!: MatButtonToggle;
/**
* To deactivate the toc button.
*/
@ViewChild(MOTION_PDF_OPTIONS.Toc)
public tocButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.AddBreaks)
public addBreaksButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.ContinuousText)
public continuousTextButton!: MatButtonToggle;
/**
* Constructor
* Sets the default values for the lineNumberingMode and changeRecoMode and creates the form.
* This uses "instant" over observables to prevent on-fly-changes by auto update while
* the dialog is open.
*/
public constructor(
public formBuilder: UntypedFormBuilder,
public dialogRef: MatDialogRef<MotionExportDialogComponent>,
public meetingSettingsService: MeetingSettingsService,
public commentRepo: MotionCommentSectionControllerService,
private store: StorageService
) {
super();
this.defaults.lnMode = this.meetingSettingsService.instant(`motions_default_line_numbering`)!;
this.defaults.crMode = this.meetingSettingsService.instant(`motions_recommendation_text_mode`)!;
this.commentsSubject = this.commentRepo.getViewModelListObservable();
if (this.meetingSettingsService.instant(`motions_show_sequential_number`)) {
this.defaults.metaInfo!.push(`id`);
}
// Get the export order, exclude everything that does not count as meta-data
this.metaInfoExportOrder = motionImportExportHeaderOrder.filter(
metaData => !noMetaData.some(noMeta => metaData === noMeta)
);
this.createForm();
}
/**
* Init.
* Observes the form for changes to react dynamically
*/
public ngOnInit(): void {
this.subscriptions.push(
this.exportForm.valueChanges.pipe(auditTime(500)).subscribe((value: MotionExportInfo) => {
this.store.set(`motion_export_selection`, value);
}),
this.exportForm
.get(`format`)!
.valueChanges.subscribe((value: ExportFileFormat) => this.onFormatChange(value))
);
}
/**
* React to changes on the file format
* @param format
*/
private onFormatChange(format: ExportFileFormat): void {
// XLSX cannot have "content"
if (format === ExportFileFormat.XLSX) {
this.disableControl(`content`);
this.changeStateOfButton(this.speakersButton, false);
} else {
this.enableControl(`content`);
this.changeStateOfButton(this.speakersButton, true);
}
if (format === ExportFileFormat.CSV || format === ExportFileFormat.XLSX) {
this.disableControl(`lnMode`);
this.disableControl(`crMode`);
this.disableControl(`pdfOptions`);
// remove the selection of "votingResult"
if (format === ExportFileFormat.CSV) {
this.disableMetaInfoControl(`polls`, `speakers`);
} else {
this.disableMetaInfoControl(`polls`);
}
this.votingResultButton.disabled = true;
this.referringMotionsButton.disabled = true;
}
if (format === ExportFileFormat.PDF) {
this.enableControl(`lnMode`);
this.enableControl(`crMode`);
this.enableControl(`pdfOptions`);
this.votingResultButton.disabled = false;
this.referringMotionsButton.disabled = false;
}
}
public onChange(event: MatButtonToggleChange): void |
/**
* Function to change the state of the property `disabled` of a given button.
*
* Ensures, that the button exists.
*
* @param button The button whose state will change.
* @param nextState The next state the button will assume.
*/
private changeStateOfButton(button: MatButtonToggle, nextState: boolean): void {
if (button) {
button.disabled = nextState;
}
}
/**
* Helper function to easier enable a control
* @param name
*/
private enableControl(name: string): void {
this.exportForm.get(name)!.enable();
}
/**
* Helper function to easier disable a control
*
* @param name
*/
private disableControl(name: string): void {
this.exportForm.get(name)!.disable();
this.exportForm.get(name)!.setValue(this.getOffState(name));
}
/**
* Determine what "off means in certain states"
*
* @param control
*/
private getOffState(control: string): string | null {
switch (control) {
case `lnMode`:
return this.lnMode.None;
case `crMode`:
return this.crMode.Original;
default:
return null;
}
}
/**
* Function to deactivate at least one field of the meta-info.
*
* @param fields All fields to deactivate.
*/
private disableMetaInfoControl(...fields: string[]): void {
let metaInfoVal: string[] = this.exportForm.get(`metaInfo`)!.value;
if (metaInfoVal) {
metaInfoVal = metaInfoVal.filter(info => !fields.includes(info));
this.exportForm.get(`metaInfo`)!.setValue(metaInfoVal);
}
}
/**
* Creates the form with default values
*/
public createForm(): void {
this.exportForm = this.formBuilder.group({
format: [],
lnMode: [],
crMode: [],
content: [],
metaInfo: [],
pdfOptions: [],
comments: []
});
// restore selection or set default
this.store.get<MotionExportInfo>(`motion_export_selection`).then(restored => {
if (restored) {
this.exportForm.patchValue(restored);
} else {
this.exportForm.patchValue(this.defaults);
}
});
}
/**
* Just close the | {
if (event.value.includes(MOTION_PDF_OPTIONS.ContinuousText)) {
this.tocButton.checked = false;
this.addBreaksButton.checked = false;
}
} | identifier_body |
motion-export-dialog.component.ts | from '@angular/material/dialog';
import { auditTime, Observable } from 'rxjs';
import { Permission } from 'src/app/domain/definitions/permission';
import {
ChangeRecoMode,
LineNumberingMode,
MOTION_PDF_OPTIONS,
PERSONAL_NOTE_ID
} from 'src/app/domain/models/motions/motions.constants';
import { StorageService } from 'src/app/gateways/storage.service';
import { ViewMotionCommentSection } from 'src/app/site/pages/meetings/pages/motions';
import { MeetingSettingsService } from 'src/app/site/pages/meetings/services/meeting-settings.service';
import { BaseUiComponent } from 'src/app/ui/base/base-ui-component';
import { MotionCommentSectionControllerService } from '../../../../modules/comments/services/motion-comment-section-controller.service';
import { ExportFileFormat, motionImportExportHeaderOrder, noMetaData } from '../../../../services/export/definitions';
import { MotionExportInfo } from '../../../../services/export/motion-export.service/motion-export.service';
@Component({
selector: `os-motion-export-dialog`,
templateUrl: `./motion-export-dialog.component.html`,
styleUrls: [`./motion-export-dialog.component.scss`],
encapsulation: ViewEncapsulation.None
})
export class MotionExportDialogComponent extends BaseUiComponent implements OnInit {
/**
* import PERSONAL_NOTE_ID for use in template
*/
public PERSONAL_NOTE_ID = PERSONAL_NOTE_ID;
public readonly permission = Permission;
/**
* For using the enum constants from the template.
*/
public lnMode = LineNumberingMode;
/**
* For using the enum constants from the template.
*/
public crMode = ChangeRecoMode;
/**
* to use the format in the template
*/
public fileFormat = ExportFileFormat;
/**
* The form that contains the export information.
*/
public exportForm!: UntypedFormGroup;
/**
* Store the subject to the ViewMotionCommentSection
*/
private commentsSubject: Observable<ViewMotionCommentSection[]>;
/**
* The default export values in contrast to the restored values
*/
private defaults: MotionExportInfo = {
format: ExportFileFormat.PDF,
content: [`text`, `reason`],
pdfOptions: [
MOTION_PDF_OPTIONS.Toc,
MOTION_PDF_OPTIONS.Header,
MOTION_PDF_OPTIONS.Page,
MOTION_PDF_OPTIONS.AddBreaks
],
metaInfo: [`submitters`, `state`, `recommendation`, `category`, `tags`, `block`, `polls`, `referring_motions`]
};
/**
* Determine the export order of the meta data
*/
public metaInfoExportOrder: string[];
/**
* @returns a list of available commentSections
*/
public get commentsToExport(): ViewMotionCommentSection[] {
return this.commentRepo.getViewModelList();
}
/**
* To deactivate the export-as-diff button
*/
@ViewChild(`diffVersionButton`, { static: true })
public diffVersionButton!: MatButtonToggle;
/**
* To deactivate the voting result button
*/
@ViewChild(`votingResultButton`, { static: true })
public votingResultButton!: MatButtonToggle;
/**
* To deactivate the referring motions button
*/
@ViewChild(`referringMotionsButton`, { static: true })
public referringMotionsButton!: MatButtonToggle;
/**
* To deactivate the speakers button.
*/
@ViewChild(`speakersButton`)
public speakersButton!: MatButtonToggle;
/**
* To deactivate the toc button.
*/
@ViewChild(MOTION_PDF_OPTIONS.Toc)
public tocButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.AddBreaks)
public addBreaksButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.ContinuousText)
public continuousTextButton!: MatButtonToggle;
/**
* Constructor
* Sets the default values for the lineNumberingMode and changeRecoMode and creates the form.
* This uses "instant" over observables to prevent on-fly-changes by auto update while
* the dialog is open.
*/
public constructor(
public formBuilder: UntypedFormBuilder,
public dialogRef: MatDialogRef<MotionExportDialogComponent>,
public meetingSettingsService: MeetingSettingsService,
public commentRepo: MotionCommentSectionControllerService,
private store: StorageService
) {
super();
this.defaults.lnMode = this.meetingSettingsService.instant(`motions_default_line_numbering`)!;
this.defaults.crMode = this.meetingSettingsService.instant(`motions_recommendation_text_mode`)!;
this.commentsSubject = this.commentRepo.getViewModelListObservable();
if (this.meetingSettingsService.instant(`motions_show_sequential_number`)) {
this.defaults.metaInfo!.push(`id`);
}
// Get the export order, exclude everything that does not count as meta-data
this.metaInfoExportOrder = motionImportExportHeaderOrder.filter(
metaData => !noMetaData.some(noMeta => metaData === noMeta)
);
this.createForm();
}
/**
* Init.
* Observes the form for changes to react dynamically
*/
public ngOnInit(): void {
this.subscriptions.push(
this.exportForm.valueChanges.pipe(auditTime(500)).subscribe((value: MotionExportInfo) => {
this.store.set(`motion_export_selection`, value);
}),
this.exportForm
.get(`format`)!
.valueChanges.subscribe((value: ExportFileFormat) => this.onFormatChange(value))
);
}
/**
* React to changes on the file format
* @param format
*/
private onFormatChange(format: ExportFileFormat): void {
// XLSX cannot have "content"
if (format === ExportFileFormat.XLSX) | else {
this.enableControl(`content`);
this.changeStateOfButton(this.speakersButton, true);
}
if (format === ExportFileFormat.CSV || format === ExportFileFormat.XLSX) {
this.disableControl(`lnMode`);
this.disableControl(`crMode`);
this.disableControl(`pdfOptions`);
// remove the selection of "votingResult"
if (format === ExportFileFormat.CSV) {
this.disableMetaInfoControl(`polls`, `speakers`);
} else {
this.disableMetaInfoControl(`polls`);
}
this.votingResultButton.disabled = true;
this.referringMotionsButton.disabled = true;
}
if (format === ExportFileFormat.PDF) {
this.enableControl(`lnMode`);
this.enableControl(`crMode`);
this.enableControl(`pdfOptions`);
this.votingResultButton.disabled = false;
this.referringMotionsButton.disabled = false;
}
}
public onChange(event: MatButtonToggleChange): void {
if (event.value.includes(MOTION_PDF_OPTIONS.ContinuousText)) {
this.tocButton.checked = false;
this.addBreaksButton.checked = false;
}
}
/**
* Function to change the state of the property `disabled` of a given button.
*
* Ensures, that the button exists.
*
* @param button The button whose state will change.
* @param nextState The next state the button will assume.
*/
private changeStateOfButton(button: MatButtonToggle, nextState: boolean): void {
if (button) {
button.disabled = nextState;
}
}
/**
* Helper function to easier enable a control
* @param name
*/
private enableControl(name: string): void {
this.exportForm.get(name)!.enable();
}
/**
* Helper function to easier disable a control
*
* @param name
*/
private disableControl(name: string): void {
this.exportForm.get(name)!.disable();
this.exportForm.get(name)!.setValue(this.getOffState(name));
}
/**
* Determine what "off means in certain states"
*
* @param control
*/
private getOffState(control: string): string | null {
switch (control) {
case `lnMode`:
return this.lnMode.None;
case `crMode`:
return this.crMode.Original;
default:
return null;
}
}
/**
* Function to deactivate at least one field of the meta-info.
*
* @param fields All fields to deactivate.
*/
private disableMetaInfoControl(...fields: string[]): void {
let metaInfoVal: string[] = this.exportForm.get(`metaInfo`)!.value;
if (metaInfoVal) {
metaInfoVal = metaInfoVal.filter(info => !fields.includes(info));
this.exportForm.get(`metaInfo`)!.setValue(metaInfoVal);
}
}
/**
* Creates the form with default values
*/
public createForm(): void {
this.exportForm = this.formBuilder.group({
format: [],
lnMode: [],
crMode: [],
content: [],
metaInfo: [],
pdfOptions: [],
comments: []
});
// restore selection or set default
this.store.get<MotionExportInfo>(`motion_export_selection`).then(restored => {
if (restored) {
this.exportForm.patchValue(restored);
} else {
this.exportForm.patchValue(this.defaults);
}
});
}
/**
* Just close the | {
this.disableControl(`content`);
this.changeStateOfButton(this.speakersButton, false);
} | conditional_block |
motion-export-dialog.component.ts | from '@angular/material/dialog';
import { auditTime, Observable } from 'rxjs';
import { Permission } from 'src/app/domain/definitions/permission';
import {
ChangeRecoMode,
LineNumberingMode,
MOTION_PDF_OPTIONS,
PERSONAL_NOTE_ID
} from 'src/app/domain/models/motions/motions.constants';
import { StorageService } from 'src/app/gateways/storage.service';
import { ViewMotionCommentSection } from 'src/app/site/pages/meetings/pages/motions';
import { MeetingSettingsService } from 'src/app/site/pages/meetings/services/meeting-settings.service';
import { BaseUiComponent } from 'src/app/ui/base/base-ui-component';
import { MotionCommentSectionControllerService } from '../../../../modules/comments/services/motion-comment-section-controller.service';
import { ExportFileFormat, motionImportExportHeaderOrder, noMetaData } from '../../../../services/export/definitions';
import { MotionExportInfo } from '../../../../services/export/motion-export.service/motion-export.service'; | @Component({
selector: `os-motion-export-dialog`,
templateUrl: `./motion-export-dialog.component.html`,
styleUrls: [`./motion-export-dialog.component.scss`],
encapsulation: ViewEncapsulation.None
})
export class MotionExportDialogComponent extends BaseUiComponent implements OnInit {
/**
* import PERSONAL_NOTE_ID for use in template
*/
public PERSONAL_NOTE_ID = PERSONAL_NOTE_ID;
public readonly permission = Permission;
/**
* For using the enum constants from the template.
*/
public lnMode = LineNumberingMode;
/**
* For using the enum constants from the template.
*/
public crMode = ChangeRecoMode;
/**
* to use the format in the template
*/
public fileFormat = ExportFileFormat;
/**
* The form that contains the export information.
*/
public exportForm!: UntypedFormGroup;
/**
* Store the subject to the ViewMotionCommentSection
*/
private commentsSubject: Observable<ViewMotionCommentSection[]>;
/**
* The default export values in contrast to the restored values
*/
private defaults: MotionExportInfo = {
format: ExportFileFormat.PDF,
content: [`text`, `reason`],
pdfOptions: [
MOTION_PDF_OPTIONS.Toc,
MOTION_PDF_OPTIONS.Header,
MOTION_PDF_OPTIONS.Page,
MOTION_PDF_OPTIONS.AddBreaks
],
metaInfo: [`submitters`, `state`, `recommendation`, `category`, `tags`, `block`, `polls`, `referring_motions`]
};
/**
* Determine the export order of the meta data
*/
public metaInfoExportOrder: string[];
/**
* @returns a list of available commentSections
*/
public get commentsToExport(): ViewMotionCommentSection[] {
return this.commentRepo.getViewModelList();
}
/**
* To deactivate the export-as-diff button
*/
@ViewChild(`diffVersionButton`, { static: true })
public diffVersionButton!: MatButtonToggle;
/**
* To deactivate the voting result button
*/
@ViewChild(`votingResultButton`, { static: true })
public votingResultButton!: MatButtonToggle;
/**
* To deactivate the referring motions button
*/
@ViewChild(`referringMotionsButton`, { static: true })
public referringMotionsButton!: MatButtonToggle;
/**
* To deactivate the speakers button.
*/
@ViewChild(`speakersButton`)
public speakersButton!: MatButtonToggle;
/**
* To deactivate the toc button.
*/
@ViewChild(MOTION_PDF_OPTIONS.Toc)
public tocButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.AddBreaks)
public addBreaksButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.ContinuousText)
public continuousTextButton!: MatButtonToggle;
/**
* Constructor
* Sets the default values for the lineNumberingMode and changeRecoMode and creates the form.
* This uses "instant" over observables to prevent on-fly-changes by auto update while
* the dialog is open.
*/
public constructor(
public formBuilder: UntypedFormBuilder,
public dialogRef: MatDialogRef<MotionExportDialogComponent>,
public meetingSettingsService: MeetingSettingsService,
public commentRepo: MotionCommentSectionControllerService,
private store: StorageService
) {
super();
this.defaults.lnMode = this.meetingSettingsService.instant(`motions_default_line_numbering`)!;
this.defaults.crMode = this.meetingSettingsService.instant(`motions_recommendation_text_mode`)!;
this.commentsSubject = this.commentRepo.getViewModelListObservable();
if (this.meetingSettingsService.instant(`motions_show_sequential_number`)) {
this.defaults.metaInfo!.push(`id`);
}
// Get the export order, exclude everything that does not count as meta-data
this.metaInfoExportOrder = motionImportExportHeaderOrder.filter(
metaData => !noMetaData.some(noMeta => metaData === noMeta)
);
this.createForm();
}
/**
* Init.
* Observes the form for changes to react dynamically
*/
public ngOnInit(): void {
this.subscriptions.push(
this.exportForm.valueChanges.pipe(auditTime(500)).subscribe((value: MotionExportInfo) => {
this.store.set(`motion_export_selection`, value);
}),
this.exportForm
.get(`format`)!
.valueChanges.subscribe((value: ExportFileFormat) => this.onFormatChange(value))
);
}
/**
* React to changes on the file format
* @param format
*/
private onFormatChange(format: ExportFileFormat): void {
// XLSX cannot have "content"
if (format === ExportFileFormat.XLSX) {
this.disableControl(`content`);
this.changeStateOfButton(this.speakersButton, false);
} else {
this.enableControl(`content`);
this.changeStateOfButton(this.speakersButton, true);
}
if (format === ExportFileFormat.CSV || format === ExportFileFormat.XLSX) {
this.disableControl(`lnMode`);
this.disableControl(`crMode`);
this.disableControl(`pdfOptions`);
// remove the selection of "votingResult"
if (format === ExportFileFormat.CSV) {
this.disableMetaInfoControl(`polls`, `speakers`);
} else {
this.disableMetaInfoControl(`polls`);
}
this.votingResultButton.disabled = true;
this.referringMotionsButton.disabled = true;
}
if (format === ExportFileFormat.PDF) {
this.enableControl(`lnMode`);
this.enableControl(`crMode`);
this.enableControl(`pdfOptions`);
this.votingResultButton.disabled = false;
this.referringMotionsButton.disabled = false;
}
}
public onChange(event: MatButtonToggleChange): void {
if (event.value.includes(MOTION_PDF_OPTIONS.ContinuousText)) {
this.tocButton.checked = false;
this.addBreaksButton.checked = false;
}
}
/**
* Function to change the state of the property `disabled` of a given button.
*
* Ensures, that the button exists.
*
* @param button The button whose state will change.
* @param nextState The next state the button will assume.
*/
private changeStateOfButton(button: MatButtonToggle, nextState: boolean): void {
if (button) {
button.disabled = nextState;
}
}
/**
* Helper function to easier enable a control
* @param name
*/
private enableControl(name: string): void {
this.exportForm.get(name)!.enable();
}
/**
* Helper function to easier disable a control
*
* @param name
*/
private disableControl(name: string): void {
this.exportForm.get(name)!.disable();
this.exportForm.get(name)!.setValue(this.getOffState(name));
}
/**
* Determine what "off means in certain states"
*
* @param control
*/
private getOffState(control: string): string | null {
switch (control) {
case `lnMode`:
return this.lnMode.None;
case `crMode`:
return this.crMode.Original;
default:
return null;
}
}
/**
* Function to deactivate at least one field of the meta-info.
*
* @param fields All fields to deactivate.
*/
private disableMetaInfoControl(...fields: string[]): void {
let metaInfoVal: string[] = this.exportForm.get(`metaInfo`)!.value;
if (metaInfoVal) {
metaInfoVal = metaInfoVal.filter(info => !fields.includes(info));
this.exportForm.get(`metaInfo`)!.setValue(metaInfoVal);
}
}
/**
* Creates the form with default values
*/
public createForm(): void {
this.exportForm = this.formBuilder.group({
format: [],
lnMode: [],
crMode: [],
content: [],
metaInfo: [],
pdfOptions: [],
comments: []
});
// restore selection or set default
this.store.get<MotionExportInfo>(`motion_export_selection`).then(restored => {
if (restored) {
this.exportForm.patchValue(restored);
} else {
this.exportForm.patchValue(this.defaults);
}
});
}
/**
* Just close the dialog | random_line_split |
|
motion-export-dialog.component.ts | Time, Observable } from 'rxjs';
import { Permission } from 'src/app/domain/definitions/permission';
import {
ChangeRecoMode,
LineNumberingMode,
MOTION_PDF_OPTIONS,
PERSONAL_NOTE_ID
} from 'src/app/domain/models/motions/motions.constants';
import { StorageService } from 'src/app/gateways/storage.service';
import { ViewMotionCommentSection } from 'src/app/site/pages/meetings/pages/motions';
import { MeetingSettingsService } from 'src/app/site/pages/meetings/services/meeting-settings.service';
import { BaseUiComponent } from 'src/app/ui/base/base-ui-component';
import { MotionCommentSectionControllerService } from '../../../../modules/comments/services/motion-comment-section-controller.service';
import { ExportFileFormat, motionImportExportHeaderOrder, noMetaData } from '../../../../services/export/definitions';
import { MotionExportInfo } from '../../../../services/export/motion-export.service/motion-export.service';
@Component({
selector: `os-motion-export-dialog`,
templateUrl: `./motion-export-dialog.component.html`,
styleUrls: [`./motion-export-dialog.component.scss`],
encapsulation: ViewEncapsulation.None
})
export class MotionExportDialogComponent extends BaseUiComponent implements OnInit {
/**
* import PERSONAL_NOTE_ID for use in template
*/
public PERSONAL_NOTE_ID = PERSONAL_NOTE_ID;
public readonly permission = Permission;
/**
* For using the enum constants from the template.
*/
public lnMode = LineNumberingMode;
/**
* For using the enum constants from the template.
*/
public crMode = ChangeRecoMode;
/**
* to use the format in the template
*/
public fileFormat = ExportFileFormat;
/**
* The form that contains the export information.
*/
public exportForm!: UntypedFormGroup;
/**
* Store the subject to the ViewMotionCommentSection
*/
private commentsSubject: Observable<ViewMotionCommentSection[]>;
/**
* The default export values in contrast to the restored values
*/
private defaults: MotionExportInfo = {
format: ExportFileFormat.PDF,
content: [`text`, `reason`],
pdfOptions: [
MOTION_PDF_OPTIONS.Toc,
MOTION_PDF_OPTIONS.Header,
MOTION_PDF_OPTIONS.Page,
MOTION_PDF_OPTIONS.AddBreaks
],
metaInfo: [`submitters`, `state`, `recommendation`, `category`, `tags`, `block`, `polls`, `referring_motions`]
};
/**
* Determine the export order of the meta data
*/
public metaInfoExportOrder: string[];
/**
* @returns a list of available commentSections
*/
public get commentsToExport(): ViewMotionCommentSection[] {
return this.commentRepo.getViewModelList();
}
/**
* To deactivate the export-as-diff button
*/
@ViewChild(`diffVersionButton`, { static: true })
public diffVersionButton!: MatButtonToggle;
/**
* To deactivate the voting result button
*/
@ViewChild(`votingResultButton`, { static: true })
public votingResultButton!: MatButtonToggle;
/**
* To deactivate the referring motions button
*/
@ViewChild(`referringMotionsButton`, { static: true })
public referringMotionsButton!: MatButtonToggle;
/**
* To deactivate the speakers button.
*/
@ViewChild(`speakersButton`)
public speakersButton!: MatButtonToggle;
/**
* To deactivate the toc button.
*/
@ViewChild(MOTION_PDF_OPTIONS.Toc)
public tocButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.AddBreaks)
public addBreaksButton!: MatButtonToggle;
@ViewChild(MOTION_PDF_OPTIONS.ContinuousText)
public continuousTextButton!: MatButtonToggle;
/**
* Constructor
* Sets the default values for the lineNumberingMode and changeRecoMode and creates the form.
* This uses "instant" over observables to prevent on-fly-changes by auto update while
* the dialog is open.
*/
public constructor(
public formBuilder: UntypedFormBuilder,
public dialogRef: MatDialogRef<MotionExportDialogComponent>,
public meetingSettingsService: MeetingSettingsService,
public commentRepo: MotionCommentSectionControllerService,
private store: StorageService
) {
super();
this.defaults.lnMode = this.meetingSettingsService.instant(`motions_default_line_numbering`)!;
this.defaults.crMode = this.meetingSettingsService.instant(`motions_recommendation_text_mode`)!;
this.commentsSubject = this.commentRepo.getViewModelListObservable();
if (this.meetingSettingsService.instant(`motions_show_sequential_number`)) {
this.defaults.metaInfo!.push(`id`);
}
// Get the export order, exclude everything that does not count as meta-data
this.metaInfoExportOrder = motionImportExportHeaderOrder.filter(
metaData => !noMetaData.some(noMeta => metaData === noMeta)
);
this.createForm();
}
/**
* Init.
* Observes the form for changes to react dynamically
*/
public ngOnInit(): void {
this.subscriptions.push(
this.exportForm.valueChanges.pipe(auditTime(500)).subscribe((value: MotionExportInfo) => {
this.store.set(`motion_export_selection`, value);
}),
this.exportForm
.get(`format`)!
.valueChanges.subscribe((value: ExportFileFormat) => this.onFormatChange(value))
);
}
/**
* React to changes on the file format
* @param format
*/
private onFormatChange(format: ExportFileFormat): void {
// XLSX cannot have "content"
if (format === ExportFileFormat.XLSX) {
this.disableControl(`content`);
this.changeStateOfButton(this.speakersButton, false);
} else {
this.enableControl(`content`);
this.changeStateOfButton(this.speakersButton, true);
}
if (format === ExportFileFormat.CSV || format === ExportFileFormat.XLSX) {
this.disableControl(`lnMode`);
this.disableControl(`crMode`);
this.disableControl(`pdfOptions`);
// remove the selection of "votingResult"
if (format === ExportFileFormat.CSV) {
this.disableMetaInfoControl(`polls`, `speakers`);
} else {
this.disableMetaInfoControl(`polls`);
}
this.votingResultButton.disabled = true;
this.referringMotionsButton.disabled = true;
}
if (format === ExportFileFormat.PDF) {
this.enableControl(`lnMode`);
this.enableControl(`crMode`);
this.enableControl(`pdfOptions`);
this.votingResultButton.disabled = false;
this.referringMotionsButton.disabled = false;
}
}
public onChange(event: MatButtonToggleChange): void {
if (event.value.includes(MOTION_PDF_OPTIONS.ContinuousText)) {
this.tocButton.checked = false;
this.addBreaksButton.checked = false;
}
}
/**
* Function to change the state of the property `disabled` of a given button.
*
* Ensures, that the button exists.
*
* @param button The button whose state will change.
* @param nextState The next state the button will assume.
*/
private changeStateOfButton(button: MatButtonToggle, nextState: boolean): void {
if (button) {
button.disabled = nextState;
}
}
/**
* Helper function to easier enable a control
* @param name
*/
private enableControl(name: string): void {
this.exportForm.get(name)!.enable();
}
/**
* Helper function to easier disable a control
*
* @param name
*/
private disableControl(name: string): void {
this.exportForm.get(name)!.disable();
this.exportForm.get(name)!.setValue(this.getOffState(name));
}
/**
* Determine what "off means in certain states"
*
* @param control
*/
private getOffState(control: string): string | null {
switch (control) {
case `lnMode`:
return this.lnMode.None;
case `crMode`:
return this.crMode.Original;
default:
return null;
}
}
/**
* Function to deactivate at least one field of the meta-info.
*
* @param fields All fields to deactivate.
*/
private disableMetaInfoControl(...fields: string[]): void {
let metaInfoVal: string[] = this.exportForm.get(`metaInfo`)!.value;
if (metaInfoVal) {
metaInfoVal = metaInfoVal.filter(info => !fields.includes(info));
this.exportForm.get(`metaInfo`)!.setValue(metaInfoVal);
}
}
/**
* Creates the form with default values
*/
public createForm(): void {
this.exportForm = this.formBuilder.group({
format: [],
lnMode: [],
crMode: [],
content: [],
metaInfo: [],
pdfOptions: [],
comments: []
});
// restore selection or set default
this.store.get<MotionExportInfo>(`motion_export_selection`).then(restored => {
if (restored) {
this.exportForm.patchValue(restored);
} else {
this.exportForm.patchValue(this.defaults);
}
});
}
/**
* Just close the dialog
*/
public | onCloseClick | identifier_name |
|
watched_bitfield.rs | : String,
/// The length from the beginning of the `BitField8` to the last
/// watched video.
anchor_length: usize,
bitfield: BitField8,
}
impl Display for WatchedField {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{}:{}:{}",
self.anchor_video, self.anchor_length, self.bitfield
)
}
}
impl From<WatchedBitField> for WatchedField {
fn from(watched_bit_field: WatchedBitField) -> Self {
let last_id = watched_bit_field.bitfield.last_index_of(true).unwrap_or(0);
let last_video_id = watched_bit_field
.video_ids
.get(last_id)
.map_or_else(|| "undefined".to_string(), |id| id.clone());
Self {
anchor_video: last_video_id,
anchor_length: last_id + 1,
bitfield: watched_bit_field.bitfield,
}
}
}
impl FromStr for WatchedField {
type Err = Error;
fn from_str(string: &str) -> Result<Self, Self::Err> {
// serialized is formed by {id}:{len}:{serializedBuf}, but since {id} might contain : we have to pop gradually and then keep the rest
let mut components = string.split(':').collect::<Vec<&str>>();
if components.len() < 3 {
return Err(Error("Not enough components".to_string()));
}
let bitfield_buf = components
.pop()
.ok_or("Cannot obtain the serialized data")?
.to_string();
let anchor_length = components
.pop()
.ok_or("Cannot obtain the length field")?
.parse::<usize>()?;
let anchor_video_id = components.join(":");
let bitfield = BitField8::try_from((bitfield_buf, None))?;
Ok(Self {
bitfield,
anchor_video: anchor_video_id,
anchor_length,
})
}
}
/// Tracks which videos have been watched.
///
/// Serialized in the format `{id}:{len}:{serializedBuf}` but since `{id}`
/// might contain `:` we pop gradually and then keep the rest.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct WatchedBitField {
bitfield: BitField8,
video_ids: Vec<String>,
}
impl WatchedBitField {
pub fn construct_from_array(arr: Vec<bool>, video_ids: Vec<String>) -> WatchedBitField {
let mut bitfield = BitField8::new(video_ids.len());
for (i, val) in arr.iter().enumerate() {
bitfield.set(i, *val);
}
WatchedBitField {
bitfield,
video_ids,
}
}
pub fn new(bitfield: BitField8, video_ids: Vec<String>) -> WatchedBitField {
Self {
bitfield,
video_ids,
}
}
pub fn construct_with_videos(
watched_field: WatchedField,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// We can shift the bitmap in any direction, as long as we can find the anchor video
if let Some(anchor_video_idx) = video_ids
.iter()
.position(|s| s == &watched_field.anchor_video)
{
// TODO: replace with `usize` and `checked_sub` when more tests are added for negative ids
let offset = watched_field.anchor_length as i32 - anchor_video_idx as i32 - 1;
let bitfield =
BitField8::new_with_values(watched_field.bitfield.values, Some(video_ids.len()));
// in case of an previous empty array, this will be 0
if offset != 0 {
// Resize the buffer
let mut resized_wbf = WatchedBitField {
bitfield: BitField8::new(video_ids.len()),
video_ids: video_ids.clone(),
};
// rewrite the old buf into the new one, applying the offset
for i in 0..video_ids.len() {
// TODO: Check what will happen if we change it to `usize`
let id_in_prev = i as i32 + offset;
if id_in_prev >= 0 && (id_in_prev as usize) < bitfield.length {
resized_wbf.set(i, bitfield.get(id_in_prev as usize));
}
}
Ok(resized_wbf)
} else {
Ok(WatchedBitField {
bitfield,
video_ids,
})
}
} else {
// videoId could not be found, return a totally blank buf
Ok(WatchedBitField {
bitfield: BitField8::new(video_ids.len()),
video_ids,
})
}
}
pub fn construct_and_resize(
serialized: &str,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// note: videoIds.length could only be >= from serialized lastLength
// should we assert?
// we might also wanna assert that the bitfield.length for the returned wb is the same sa videoIds.length
let watched_field = serialized.parse()?;
Self::construct_with_videos(watched_field, video_ids)
}
pub fn get(&self, idx: usize) -> bool {
self.bitfield.get(idx)
}
pub fn get_video(&self, video_id: &str) -> bool {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.get(pos)
} else {
false
}
}
pub fn set(&mut self, idx: usize, v: bool) {
self.bitfield.set(idx, v);
}
pub fn set_video(&mut self, video_id: &str, v: bool) {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.set(pos, v);
}
}
}
impl fmt::Display for WatchedBitField {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let packed = String::try_from(&self.bitfield).expect("bitfield failed to compress");
let last_id = self.bitfield.last_index_of(true).unwrap_or(0);
let last_video_id = self
.video_ids
.get(last_id)
.map_or("undefined", |id| id.as_str());
write!(f, "{}:{}:{}", last_video_id, last_id + 1, packed)
}
}
impl From<WatchedBitField> for BitField8 {
fn from(watched: WatchedBitField) -> Self |
}
/// Module containing all the impls of the `serde` feature
#[cfg(feature = "serde")]
mod serde {
use std::str::FromStr;
use serde::{de, Serialize};
use super::WatchedField;
impl<'de> serde::Deserialize<'de> for WatchedField {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let serialized = String::deserialize(deserializer)?;
WatchedField::from_str(&serialized).map_err(de::Error::custom)
}
}
impl Serialize for WatchedField {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.to_string())
}
}
}
#[cfg(test)]
mod tests {
use crate::{BitField8, WatchedBitField, WatchedField};
#[test]
fn parse_and_modify() {
let videos = [
"tt2934286:1:1",
"tt2934286:1:2",
"tt2934286:1:3",
"tt2934286:1:4",
"tt2934286:1:5",
"tt2934286:1:6",
"tt2934286:1:7",
"tt2934286:1:8",
"tt2934286:1:9",
];
let watched = "tt2934286:1:5:5:eJyTZwAAAEAAIA==";
let mut wb = WatchedBitField::construct_and_resize(
watched,
videos.iter().map(|v| v.to_string()).collect(),
)
.unwrap();
assert!(wb.get_video("tt2934286:1:5"));
assert!(!wb.get_video("tt2934286:1:6"));
assert_eq!(watched, wb.to_string());
wb.set_video("tt2934286:1:6", true);
assert!(wb.get_video("tt2934286:1:6"));
}
#[test]
fn construct_from_array() {
let arr = vec![false; 500];
let mut video_ids = vec![];
for i in 1..500 {
video_ids.push(format!("tt29342 | {
watched.bitfield
} | identifier_body |
watched_bitfield.rs | video_ids: Vec<String>,
}
impl WatchedBitField {
pub fn construct_from_array(arr: Vec<bool>, video_ids: Vec<String>) -> WatchedBitField {
let mut bitfield = BitField8::new(video_ids.len());
for (i, val) in arr.iter().enumerate() {
bitfield.set(i, *val);
}
WatchedBitField {
bitfield,
video_ids,
}
}
pub fn new(bitfield: BitField8, video_ids: Vec<String>) -> WatchedBitField {
Self {
bitfield,
video_ids,
}
}
pub fn construct_with_videos(
watched_field: WatchedField,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// We can shift the bitmap in any direction, as long as we can find the anchor video
if let Some(anchor_video_idx) = video_ids
.iter()
.position(|s| s == &watched_field.anchor_video)
{
// TODO: replace with `usize` and `checked_sub` when more tests are added for negative ids
let offset = watched_field.anchor_length as i32 - anchor_video_idx as i32 - 1;
let bitfield =
BitField8::new_with_values(watched_field.bitfield.values, Some(video_ids.len()));
// in case of an previous empty array, this will be 0
if offset != 0 {
// Resize the buffer
let mut resized_wbf = WatchedBitField {
bitfield: BitField8::new(video_ids.len()),
video_ids: video_ids.clone(),
};
// rewrite the old buf into the new one, applying the offset
for i in 0..video_ids.len() {
// TODO: Check what will happen if we change it to `usize`
let id_in_prev = i as i32 + offset;
if id_in_prev >= 0 && (id_in_prev as usize) < bitfield.length {
resized_wbf.set(i, bitfield.get(id_in_prev as usize));
}
}
Ok(resized_wbf)
} else {
Ok(WatchedBitField {
bitfield,
video_ids,
})
}
} else {
// videoId could not be found, return a totally blank buf
Ok(WatchedBitField {
bitfield: BitField8::new(video_ids.len()),
video_ids,
})
}
}
pub fn construct_and_resize(
serialized: &str,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// note: videoIds.length could only be >= from serialized lastLength
// should we assert?
// we might also wanna assert that the bitfield.length for the returned wb is the same sa videoIds.length
let watched_field = serialized.parse()?;
Self::construct_with_videos(watched_field, video_ids)
}
pub fn get(&self, idx: usize) -> bool {
self.bitfield.get(idx)
}
pub fn get_video(&self, video_id: &str) -> bool {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.get(pos)
} else {
false
}
}
pub fn set(&mut self, idx: usize, v: bool) {
self.bitfield.set(idx, v);
}
pub fn set_video(&mut self, video_id: &str, v: bool) {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.set(pos, v);
}
}
}
impl fmt::Display for WatchedBitField {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let packed = String::try_from(&self.bitfield).expect("bitfield failed to compress");
let last_id = self.bitfield.last_index_of(true).unwrap_or(0);
let last_video_id = self
.video_ids
.get(last_id)
.map_or("undefined", |id| id.as_str());
write!(f, "{}:{}:{}", last_video_id, last_id + 1, packed)
}
}
impl From<WatchedBitField> for BitField8 {
fn from(watched: WatchedBitField) -> Self {
watched.bitfield
}
}
/// Module containing all the impls of the `serde` feature
#[cfg(feature = "serde")]
mod serde {
use std::str::FromStr;
use serde::{de, Serialize};
use super::WatchedField;
impl<'de> serde::Deserialize<'de> for WatchedField {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let serialized = String::deserialize(deserializer)?;
WatchedField::from_str(&serialized).map_err(de::Error::custom)
}
}
impl Serialize for WatchedField {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.to_string())
}
}
}
#[cfg(test)]
mod tests {
use crate::{BitField8, WatchedBitField, WatchedField};
#[test]
fn parse_and_modify() {
let videos = [
"tt2934286:1:1",
"tt2934286:1:2",
"tt2934286:1:3",
"tt2934286:1:4",
"tt2934286:1:5",
"tt2934286:1:6",
"tt2934286:1:7",
"tt2934286:1:8",
"tt2934286:1:9",
];
let watched = "tt2934286:1:5:5:eJyTZwAAAEAAIA==";
let mut wb = WatchedBitField::construct_and_resize(
watched,
videos.iter().map(|v| v.to_string()).collect(),
)
.unwrap();
assert!(wb.get_video("tt2934286:1:5"));
assert!(!wb.get_video("tt2934286:1:6"));
assert_eq!(watched, wb.to_string());
wb.set_video("tt2934286:1:6", true);
assert!(wb.get_video("tt2934286:1:6"));
}
#[test]
fn construct_from_array() {
let arr = vec![false; 500];
let mut video_ids = vec![];
for i in 1..500 {
video_ids.push(format!("tt2934286:1:{}", i));
}
let mut wb = WatchedBitField::construct_from_array(arr, video_ids.clone());
// All should be false
for (i, val) in video_ids.iter().enumerate() {
assert!(!wb.get(i));
assert!(!wb.get_video(val));
}
// Set half to true
for (i, _val) in video_ids.iter().enumerate() {
wb.set(i, i % 2 == 0);
}
// Serialize and deserialize to new structure
let watched = wb.to_string();
let wb2 = WatchedBitField::construct_and_resize(
&watched,
video_ids.iter().map(|v| v.to_string()).collect(),
)
.unwrap();
// Half should still be true
for (i, val) in video_ids.iter().enumerate() {
assert_eq!(wb2.get(i), i % 2 == 0);
assert_eq!(wb2.get_video(val), i % 2 == 0);
}
}
#[test]
fn to_string_empty() {
let watched = WatchedBitField::construct_from_array(vec![], vec![]);
let serialized = watched.to_string();
assert_eq!(serialized, "undefined:1:eJwDAAAAAAE=");
}
#[test]
#[cfg(feature = "serde")]
fn test_watched_field_de_serialize() {
let string = "tt7767422:3:8:24:eJz7//8/AAX9Av4=";
let json_value = serde_json::json!(string);
let expected = string.parse::<WatchedField>().expect("Should parse field");
let actual_from_json = serde_json::from_value::<WatchedField>(json_value.clone())
.expect("Should deserialize ");
assert_eq!(expected, actual_from_json);
assert_eq!("eJz7//8/AAX9Av4=", &actual_from_json.bitfield.to_string());
assert_eq!(24, actual_from_json.anchor_length);
assert_eq!("tt7767422:3:8", actual_from_json.anchor_video);
let actual_to_json = serde_json::to_value(&expected).expect("Should serialize");
assert_eq!(json_value, actual_to_json);
}
#[test]
fn | deserialize_empty | identifier_name |
|
watched_bitfield.rs | : String,
/// The length from the beginning of the `BitField8` to the last
/// watched video.
anchor_length: usize,
bitfield: BitField8,
}
impl Display for WatchedField {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{}:{}:{}",
self.anchor_video, self.anchor_length, self.bitfield
)
}
}
impl From<WatchedBitField> for WatchedField {
fn from(watched_bit_field: WatchedBitField) -> Self {
let last_id = watched_bit_field.bitfield.last_index_of(true).unwrap_or(0);
let last_video_id = watched_bit_field
.video_ids
.get(last_id)
.map_or_else(|| "undefined".to_string(), |id| id.clone());
Self {
anchor_video: last_video_id,
anchor_length: last_id + 1,
bitfield: watched_bit_field.bitfield,
}
}
}
impl FromStr for WatchedField {
type Err = Error;
fn from_str(string: &str) -> Result<Self, Self::Err> {
// serialized is formed by {id}:{len}:{serializedBuf}, but since {id} might contain : we have to pop gradually and then keep the rest
let mut components = string.split(':').collect::<Vec<&str>>();
if components.len() < 3 {
return Err(Error("Not enough components".to_string()));
}
let bitfield_buf = components
.pop()
.ok_or("Cannot obtain the serialized data")?
.to_string();
let anchor_length = components
.pop()
.ok_or("Cannot obtain the length field")?
.parse::<usize>()?;
let anchor_video_id = components.join(":");
let bitfield = BitField8::try_from((bitfield_buf, None))?;
Ok(Self {
bitfield,
anchor_video: anchor_video_id,
anchor_length,
})
}
}
/// Tracks which videos have been watched.
///
/// Serialized in the format `{id}:{len}:{serializedBuf}` but since `{id}`
/// might contain `:` we pop gradually and then keep the rest.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct WatchedBitField {
bitfield: BitField8,
video_ids: Vec<String>,
}
impl WatchedBitField {
pub fn construct_from_array(arr: Vec<bool>, video_ids: Vec<String>) -> WatchedBitField {
let mut bitfield = BitField8::new(video_ids.len());
for (i, val) in arr.iter().enumerate() {
bitfield.set(i, *val);
}
WatchedBitField {
bitfield,
video_ids,
}
}
pub fn new(bitfield: BitField8, video_ids: Vec<String>) -> WatchedBitField {
Self {
bitfield,
video_ids,
}
}
pub fn construct_with_videos(
watched_field: WatchedField,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// We can shift the bitmap in any direction, as long as we can find the anchor video
if let Some(anchor_video_idx) = video_ids
.iter()
.position(|s| s == &watched_field.anchor_video)
{
// TODO: replace with `usize` and `checked_sub` when more tests are added for negative ids
let offset = watched_field.anchor_length as i32 - anchor_video_idx as i32 - 1;
let bitfield =
BitField8::new_with_values(watched_field.bitfield.values, Some(video_ids.len()));
// in case of an previous empty array, this will be 0
if offset != 0 {
// Resize the buffer
let mut resized_wbf = WatchedBitField {
bitfield: BitField8::new(video_ids.len()),
video_ids: video_ids.clone(),
};
// rewrite the old buf into the new one, applying the offset
for i in 0..video_ids.len() {
// TODO: Check what will happen if we change it to `usize`
let id_in_prev = i as i32 + offset;
if id_in_prev >= 0 && (id_in_prev as usize) < bitfield.length {
resized_wbf.set(i, bitfield.get(id_in_prev as usize));
}
}
Ok(resized_wbf)
} else {
Ok(WatchedBitField {
bitfield,
video_ids,
})
}
} else {
// videoId could not be found, return a totally blank buf
Ok(WatchedBitField {
bitfield: BitField8::new(video_ids.len()),
video_ids,
})
}
}
pub fn construct_and_resize(
serialized: &str,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// note: videoIds.length could only be >= from serialized lastLength
// should we assert?
// we might also wanna assert that the bitfield.length for the returned wb is the same sa videoIds.length
let watched_field = serialized.parse()?;
Self::construct_with_videos(watched_field, video_ids)
}
pub fn get(&self, idx: usize) -> bool {
self.bitfield.get(idx)
}
pub fn get_video(&self, video_id: &str) -> bool {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.get(pos)
} else |
}
pub fn set(&mut self, idx: usize, v: bool) {
self.bitfield.set(idx, v);
}
pub fn set_video(&mut self, video_id: &str, v: bool) {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.set(pos, v);
}
}
}
impl fmt::Display for WatchedBitField {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let packed = String::try_from(&self.bitfield).expect("bitfield failed to compress");
let last_id = self.bitfield.last_index_of(true).unwrap_or(0);
let last_video_id = self
.video_ids
.get(last_id)
.map_or("undefined", |id| id.as_str());
write!(f, "{}:{}:{}", last_video_id, last_id + 1, packed)
}
}
impl From<WatchedBitField> for BitField8 {
fn from(watched: WatchedBitField) -> Self {
watched.bitfield
}
}
/// Module containing all the impls of the `serde` feature
#[cfg(feature = "serde")]
mod serde {
use std::str::FromStr;
use serde::{de, Serialize};
use super::WatchedField;
impl<'de> serde::Deserialize<'de> for WatchedField {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let serialized = String::deserialize(deserializer)?;
WatchedField::from_str(&serialized).map_err(de::Error::custom)
}
}
impl Serialize for WatchedField {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.to_string())
}
}
}
#[cfg(test)]
mod tests {
use crate::{BitField8, WatchedBitField, WatchedField};
#[test]
fn parse_and_modify() {
let videos = [
"tt2934286:1:1",
"tt2934286:1:2",
"tt2934286:1:3",
"tt2934286:1:4",
"tt2934286:1:5",
"tt2934286:1:6",
"tt2934286:1:7",
"tt2934286:1:8",
"tt2934286:1:9",
];
let watched = "tt2934286:1:5:5:eJyTZwAAAEAAIA==";
let mut wb = WatchedBitField::construct_and_resize(
watched,
videos.iter().map(|v| v.to_string()).collect(),
)
.unwrap();
assert!(wb.get_video("tt2934286:1:5"));
assert!(!wb.get_video("tt2934286:1:6"));
assert_eq!(watched, wb.to_string());
wb.set_video("tt2934286:1:6", true);
assert!(wb.get_video("tt2934286:1:6"));
}
#[test]
fn construct_from_array() {
let arr = vec![false; 500];
let mut video_ids = vec![];
for i in 1..500 {
video_ids.push(format!("tt29342 | {
false
} | conditional_block |
watched_bitfield.rs | _video: String,
/// The length from the beginning of the `BitField8` to the last
/// watched video.
anchor_length: usize,
bitfield: BitField8,
}
impl Display for WatchedField {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{}:{}:{}",
self.anchor_video, self.anchor_length, self.bitfield
)
}
}
impl From<WatchedBitField> for WatchedField {
fn from(watched_bit_field: WatchedBitField) -> Self {
let last_id = watched_bit_field.bitfield.last_index_of(true).unwrap_or(0);
let last_video_id = watched_bit_field
.video_ids
.get(last_id)
.map_or_else(|| "undefined".to_string(), |id| id.clone());
Self {
anchor_video: last_video_id,
anchor_length: last_id + 1,
bitfield: watched_bit_field.bitfield,
}
}
}
impl FromStr for WatchedField {
type Err = Error;
fn from_str(string: &str) -> Result<Self, Self::Err> {
// serialized is formed by {id}:{len}:{serializedBuf}, but since {id} might contain : we have to pop gradually and then keep the rest
let mut components = string.split(':').collect::<Vec<&str>>();
if components.len() < 3 {
return Err(Error("Not enough components".to_string()));
}
let bitfield_buf = components
.pop()
.ok_or("Cannot obtain the serialized data")?
.to_string();
let anchor_length = components
.pop()
.ok_or("Cannot obtain the length field")?
.parse::<usize>()?;
let anchor_video_id = components.join(":");
let bitfield = BitField8::try_from((bitfield_buf, None))?;
Ok(Self {
bitfield,
anchor_video: anchor_video_id,
anchor_length,
})
}
}
/// Tracks which videos have been watched.
///
/// Serialized in the format `{id}:{len}:{serializedBuf}` but since `{id}`
/// might contain `:` we pop gradually and then keep the rest.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct WatchedBitField {
bitfield: BitField8,
video_ids: Vec<String>,
}
impl WatchedBitField {
pub fn construct_from_array(arr: Vec<bool>, video_ids: Vec<String>) -> WatchedBitField {
let mut bitfield = BitField8::new(video_ids.len());
for (i, val) in arr.iter().enumerate() {
bitfield.set(i, *val);
}
WatchedBitField {
bitfield,
video_ids,
}
}
pub fn new(bitfield: BitField8, video_ids: Vec<String>) -> WatchedBitField {
Self {
bitfield,
video_ids,
}
}
pub fn construct_with_videos(
watched_field: WatchedField,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// We can shift the bitmap in any direction, as long as we can find the anchor video
if let Some(anchor_video_idx) = video_ids
.iter()
.position(|s| s == &watched_field.anchor_video)
{
// TODO: replace with `usize` and `checked_sub` when more tests are added for negative ids
let offset = watched_field.anchor_length as i32 - anchor_video_idx as i32 - 1;
let bitfield =
BitField8::new_with_values(watched_field.bitfield.values, Some(video_ids.len()));
// in case of an previous empty array, this will be 0
if offset != 0 {
// Resize the buffer
let mut resized_wbf = WatchedBitField { | for i in 0..video_ids.len() {
// TODO: Check what will happen if we change it to `usize`
let id_in_prev = i as i32 + offset;
if id_in_prev >= 0 && (id_in_prev as usize) < bitfield.length {
resized_wbf.set(i, bitfield.get(id_in_prev as usize));
}
}
Ok(resized_wbf)
} else {
Ok(WatchedBitField {
bitfield,
video_ids,
})
}
} else {
// videoId could not be found, return a totally blank buf
Ok(WatchedBitField {
bitfield: BitField8::new(video_ids.len()),
video_ids,
})
}
}
pub fn construct_and_resize(
serialized: &str,
video_ids: Vec<String>,
) -> Result<WatchedBitField, Error> {
// note: videoIds.length could only be >= from serialized lastLength
// should we assert?
// we might also wanna assert that the bitfield.length for the returned wb is the same sa videoIds.length
let watched_field = serialized.parse()?;
Self::construct_with_videos(watched_field, video_ids)
}
pub fn get(&self, idx: usize) -> bool {
self.bitfield.get(idx)
}
pub fn get_video(&self, video_id: &str) -> bool {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.get(pos)
} else {
false
}
}
pub fn set(&mut self, idx: usize, v: bool) {
self.bitfield.set(idx, v);
}
pub fn set_video(&mut self, video_id: &str, v: bool) {
if let Some(pos) = self.video_ids.iter().position(|s| *s == video_id) {
self.bitfield.set(pos, v);
}
}
}
impl fmt::Display for WatchedBitField {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let packed = String::try_from(&self.bitfield).expect("bitfield failed to compress");
let last_id = self.bitfield.last_index_of(true).unwrap_or(0);
let last_video_id = self
.video_ids
.get(last_id)
.map_or("undefined", |id| id.as_str());
write!(f, "{}:{}:{}", last_video_id, last_id + 1, packed)
}
}
impl From<WatchedBitField> for BitField8 {
fn from(watched: WatchedBitField) -> Self {
watched.bitfield
}
}
/// Module containing all the impls of the `serde` feature
#[cfg(feature = "serde")]
mod serde {
use std::str::FromStr;
use serde::{de, Serialize};
use super::WatchedField;
impl<'de> serde::Deserialize<'de> for WatchedField {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let serialized = String::deserialize(deserializer)?;
WatchedField::from_str(&serialized).map_err(de::Error::custom)
}
}
impl Serialize for WatchedField {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.to_string())
}
}
}
#[cfg(test)]
mod tests {
use crate::{BitField8, WatchedBitField, WatchedField};
#[test]
fn parse_and_modify() {
let videos = [
"tt2934286:1:1",
"tt2934286:1:2",
"tt2934286:1:3",
"tt2934286:1:4",
"tt2934286:1:5",
"tt2934286:1:6",
"tt2934286:1:7",
"tt2934286:1:8",
"tt2934286:1:9",
];
let watched = "tt2934286:1:5:5:eJyTZwAAAEAAIA==";
let mut wb = WatchedBitField::construct_and_resize(
watched,
videos.iter().map(|v| v.to_string()).collect(),
)
.unwrap();
assert!(wb.get_video("tt2934286:1:5"));
assert!(!wb.get_video("tt2934286:1:6"));
assert_eq!(watched, wb.to_string());
wb.set_video("tt2934286:1:6", true);
assert!(wb.get_video("tt2934286:1:6"));
}
#[test]
fn construct_from_array() {
let arr = vec![false; 500];
let mut video_ids = vec![];
for i in 1..500 {
video_ids.push(format!("tt2934286 | bitfield: BitField8::new(video_ids.len()),
video_ids: video_ids.clone(),
};
// rewrite the old buf into the new one, applying the offset | random_line_split |
pisco_redsequence.py | 5,0.01) #just for the line plot in the 3rd plot
redshift_range=np.arange(0.10,0.8,0.05) #for the actual data
number=[]
if color=='sloan_g-sloan_r':
redshift_range=np.arange(0.10,0.36,0.05)
elif color=='sloan_r-sloan_i':
redshift_range=np.arange(0.10,0.71,0.05)
for redshift in redshift_range:
if color=='sloan_g-sloan_r':
# i_band_cut=20.5
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
elif color=='sloan_r-sloan_i':
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
aa=red_band<i_band_cut
loc=[(all_x<i_band_cut)&\
(total < rs_models[color][round(redshift+0.025,2)].rs_color(all_x))&\
(total > rs_models[color][round(redshift-0.025,2)].rs_color(all_x))][0]
number.append(np.sum(loc))
ax.plot(red_band[aa],rs_models[color][round(redshift,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls='-')
ax.plot(red_band[aa],rs_models[color][round(redshift+0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.plot(red_band[aa],rs_models[color][round(redshift-0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.set_xlim(16,25)
if color == 'sloan_g-sloan_i':
ax.set_ylim(0,4)
elif color == 'sloan_g-sloan_r':
ax.set_ylim(0.0,2.5)
else:
ax.set_ylim(-0.5,1.75)
ax.set_xlabel(band_x)
ax.set_ylabel(color)
return np.array(redshift_range),np.array(number)
def color_sloan(color, mags):
| i_band0=-20.5
color_err=0.15
band_1, band_2 = color.split("-")
band_1_idx=filters.index(band_1)
band_2_idx=filters.index(band_2)
rs_models=dict()
rs_models[color]=dict()
for z, m in zip(zs,mags):
#mag_1=m[band_1_idx]
mag_2=m[band_2_idx]
mag_1=blue_model(color,mags,z,mag_2)
this_model=RSModel(z, mag_1, mag_2, slope_fit)
rs_models[color][this_model.z]=this_model
return slope_fit,i_band0,color_err,rs_models,band_1,band_2
# adding the slope for different color set that we are interested in (01_rsz_test,fit_gr_ri01.ipyn)
def blue_model(color,mags,redshift,red_mag):
#g-r
if color=='sloan_g-sloan_r':
blue_mag=(0.787302458781+2.9352*redshift)+red_mag
elif color=='sloan_r-sloan_i':
if redshift <= 0.36:
blue_mag=(0.348871987852+0.75340856*redshift)+red_mag
else:
blue_mag=(-0.210727367027+2.2836974*redshift)+red_mag
else:
print 'This color has not been implemented.'
return blue_mag
def histogram_plot(xranf,numberf,df,ax=None,line=False,cbar=False):
l2=6
ax.set_xlim(0,0.8)
ic2,ic3=0,0
numbers=numberf[:6]
numbers2=numberf[l2:]
ax.bar(xranf[:6],numbers,width=0.05,color='red',alpha=0.5,align='center')
ax.bar(xranf[l2:],numbers2,width=0.05,alpha=0.5,align='center')
if cbar:
cbar=fig.colorbar(s_m, ax=ax)
cbar.set_label("redshift")
if line:
if dff_sdss.loc[ind].redshift!=-1:
ax.axvline(dff_sdss.redshift[ind],ls='--',color='#66cc00',lw=2.,label='qso z=%.2f'%dff_sdss.redshift[ind])
ax.axvline(xranf[:6][ic2],ls='--',color='black',lw=2.,label='red_seq g-r z=%.2f'%xranf[:6][ic2])
ax.axvline(xranf[l2:][ic3],ls='--',color='purple',lw=2.,label='red_seq r-i z=%.2f'%xranf[l2:][ic3])
ax.legend(loc='best',frameon=False)
sigma,sigma2,sigma3=0.,0.,0.
if line:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3,dff_sdss.redshift[ind],sigma])
else:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3])
def save_rgb_image_extra(field, f026):
cmd = "ds9 -zscale -crosshair %f %f wcs fk5 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_2.eps -exit" % \
(f026.RA0.values[0], f026.DEC0.values[0], field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
cmd = "ds9 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_3.eps -exit" % \
(field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
print 'finished saving final/img%s.eps' % field
def find_offset(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
band=[x.split(' ')[0][-1] for x in content[5:-1]]
corr=[float(x.split(' ')[1]) for x in content[5:-1]]
ecorr=[float(x.split(' ')[3]) for x in content[5:-1]]
return zip(band,corr,ecorr), corr
def find_num(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
num_2mass=content[0].split(' ')[3]
num_star=content[3].split(' ')[1]
chisq=content[2].split(' ')[1]
return num_2mass,num_star,chisq
##--------
if __name__ == "__main__":
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filters=['sloan_r','sloan_i','sloan_z','sloan_g']
| if color=='sloan_r-sloan_z':
slope_r_m_i=-0.0192138872893
slope_r_m_z=(1.584 * slope_r_m_i)
slope_fit=[slope_r_m_z, 0]
i_band0=-20.
elif color=='sloan_g-sloan_i':
slope_v_m_i=-0.029
slope_g_m_i=(1.481 * slope_v_m_i)
slope_fit=[slope_g_m_i, 0]
i_band0=-20.
elif color=='sloan_r-sloan_i':
slope_rc_m_ic=-0.0192138872893
slope_r_m_i=(1.007 * slope_rc_m_ic)
slope_fit=[slope_r_m_i, 0]
i_band0=-20.5
color_err=0.18
elif color=='sloan_g-sloan_r':
slope_v_m_r=-0.0133824600874
slope_g_m_r=(1.646 * slope_v_m_r)
slope_fit=[slope_g_m_r, 0] | identifier_body |
pisco_redsequence.py | 5,0.01) #just for the line plot in the 3rd plot
redshift_range=np.arange(0.10,0.8,0.05) #for the actual data
number=[]
if color=='sloan_g-sloan_r':
redshift_range=np.arange(0.10,0.36,0.05)
elif color=='sloan_r-sloan_i':
redshift_range=np.arange(0.10,0.71,0.05)
for redshift in redshift_range:
if color=='sloan_g-sloan_r':
# i_band_cut=20.5
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
elif color=='sloan_r-sloan_i':
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
aa=red_band<i_band_cut
loc=[(all_x<i_band_cut)&\
(total < rs_models[color][round(redshift+0.025,2)].rs_color(all_x))&\
(total > rs_models[color][round(redshift-0.025,2)].rs_color(all_x))][0]
number.append(np.sum(loc))
ax.plot(red_band[aa],rs_models[color][round(redshift,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls='-')
ax.plot(red_band[aa],rs_models[color][round(redshift+0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.plot(red_band[aa],rs_models[color][round(redshift-0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.set_xlim(16,25)
if color == 'sloan_g-sloan_i':
ax.set_ylim(0,4)
elif color == 'sloan_g-sloan_r':
ax.set_ylim(0.0,2.5)
else:
ax.set_ylim(-0.5,1.75)
ax.set_xlabel(band_x)
ax.set_ylabel(color)
return np.array(redshift_range),np.array(number)
def color_sloan(color, mags):
if color=='sloan_r-sloan_z':
slope_r_m_i=-0.0192138872893
slope_r_m_z=(1.584 * slope_r_m_i)
slope_fit=[slope_r_m_z, 0]
i_band0=-20.
elif color=='sloan_g-sloan_i':
slope_v_m_i=-0.029
slope_g_m_i=(1.481 * slope_v_m_i)
slope_fit=[slope_g_m_i, 0]
i_band0=-20.
elif color=='sloan_r-sloan_i':
slope_rc_m_ic=-0.0192138872893
slope_r_m_i=(1.007 * slope_rc_m_ic)
slope_fit=[slope_r_m_i, 0]
i_band0=-20.5
color_err=0.18
elif color=='sloan_g-sloan_r':
slope_v_m_r=-0.0133824600874
slope_g_m_r=(1.646 * slope_v_m_r)
slope_fit=[slope_g_m_r, 0]
i_band0=-20.5
color_err=0.15
band_1, band_2 = color.split("-")
band_1_idx=filters.index(band_1)
band_2_idx=filters.index(band_2)
rs_models=dict()
rs_models[color]=dict()
for z, m in zip(zs,mags):
#mag_1=m[band_1_idx]
mag_2=m[band_2_idx]
mag_1=blue_model(color,mags,z,mag_2)
this_model=RSModel(z, mag_1, mag_2, slope_fit)
rs_models[color][this_model.z]=this_model
return slope_fit,i_band0,color_err,rs_models,band_1,band_2
# adding the slope for different color set that we are interested in (01_rsz_test,fit_gr_ri01.ipyn)
def blue_model(color,mags,redshift,red_mag):
#g-r
if color=='sloan_g-sloan_r':
blue_mag=(0.787302458781+2.9352*redshift)+red_mag
elif color=='sloan_r-sloan_i':
if redshift <= 0.36:
blue_mag=(0.348871987852+0.75340856*redshift)+red_mag
else:
blue_mag=(-0.210727367027+2.2836974*redshift)+red_mag
else:
print 'This color has not been implemented.'
return blue_mag
def histogram_plot(xranf,numberf,df,ax=None,line=False,cbar=False):
l2=6
ax.set_xlim(0,0.8)
ic2,ic3=0,0
numbers=numberf[:6]
numbers2=numberf[l2:]
ax.bar(xranf[:6],numbers,width=0.05,color='red',alpha=0.5,align='center')
ax.bar(xranf[l2:],numbers2,width=0.05,alpha=0.5,align='center')
if cbar:
cbar=fig.colorbar(s_m, ax=ax)
cbar.set_label("redshift")
if line:
if dff_sdss.loc[ind].redshift!=-1:
ax.axvline(dff_sdss.redshift[ind],ls='--',color='#66cc00',lw=2.,label='qso z=%.2f'%dff_sdss.redshift[ind])
ax.axvline(xranf[:6][ic2],ls='--',color='black',lw=2.,label='red_seq g-r z=%.2f'%xranf[:6][ic2])
ax.axvline(xranf[l2:][ic3],ls='--',color='purple',lw=2.,label='red_seq r-i z=%.2f'%xranf[l2:][ic3])
ax.legend(loc='best',frameon=False)
sigma,sigma2,sigma3=0.,0.,0.
if line:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3,dff_sdss.redshift[ind],sigma])
else:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3])
def save_rgb_image_extra(field, f026):
cmd = "ds9 -zscale -crosshair %f %f wcs fk5 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_2.eps -exit" % \
(f026.RA0.values[0], f026.DEC0.values[0], field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
cmd = "ds9 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_3.eps -exit" % \
(field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
print 'finished saving final/img%s.eps' % field
def | (fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
band=[x.split(' ')[0][-1] for x in content[5:-1]]
corr=[float(x.split(' ')[1]) for x in content[5:-1]]
ecorr=[float(x.split(' ')[3]) for x in content[5:-1]]
return zip(band,corr,ecorr), corr
def find_num(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
num_2mass=content[0].split(' ')[3]
num_star=content[3].split(' ')[1]
chisq=content[2].split(' ')[1]
return num_2mass,num_star,chisq
##--------
if __name__ == "__main__":
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filters=['sloan_r','sloan_i','sloan_z','sloan_g']
| find_offset | identifier_name |
pisco_redsequence.py | 5,0.01) #just for the line plot in the 3rd plot
redshift_range=np.arange(0.10,0.8,0.05) #for the actual data
number=[]
if color=='sloan_g-sloan_r':
redshift_range=np.arange(0.10,0.36,0.05)
elif color=='sloan_r-sloan_i':
redshift_range=np.arange(0.10,0.71,0.05)
for redshift in redshift_range:
if color=='sloan_g-sloan_r':
# i_band_cut=20.5
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
elif color=='sloan_r-sloan_i':
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
aa=red_band<i_band_cut
loc=[(all_x<i_band_cut)&\
(total < rs_models[color][round(redshift+0.025,2)].rs_color(all_x))&\
(total > rs_models[color][round(redshift-0.025,2)].rs_color(all_x))][0]
number.append(np.sum(loc))
ax.plot(red_band[aa],rs_models[color][round(redshift,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls='-')
ax.plot(red_band[aa],rs_models[color][round(redshift+0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.plot(red_band[aa],rs_models[color][round(redshift-0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.set_xlim(16,25)
if color == 'sloan_g-sloan_i':
ax.set_ylim(0,4)
elif color == 'sloan_g-sloan_r':
ax.set_ylim(0.0,2.5)
else:
ax.set_ylim(-0.5,1.75)
ax.set_xlabel(band_x)
ax.set_ylabel(color)
return np.array(redshift_range),np.array(number)
def color_sloan(color, mags):
if color=='sloan_r-sloan_z':
slope_r_m_i=-0.0192138872893
slope_r_m_z=(1.584 * slope_r_m_i)
slope_fit=[slope_r_m_z, 0]
i_band0=-20.
elif color=='sloan_g-sloan_i':
slope_v_m_i=-0.029
slope_g_m_i=(1.481 * slope_v_m_i)
slope_fit=[slope_g_m_i, 0]
i_band0=-20.
elif color=='sloan_r-sloan_i':
slope_rc_m_ic=-0.0192138872893
slope_r_m_i=(1.007 * slope_rc_m_ic)
slope_fit=[slope_r_m_i, 0]
i_band0=-20.5
color_err=0.18
elif color=='sloan_g-sloan_r':
slope_v_m_r=-0.0133824600874
slope_g_m_r=(1.646 * slope_v_m_r)
slope_fit=[slope_g_m_r, 0]
i_band0=-20.5
color_err=0.15
band_1, band_2 = color.split("-")
band_1_idx=filters.index(band_1)
band_2_idx=filters.index(band_2)
rs_models=dict()
rs_models[color]=dict()
for z, m in zip(zs,mags):
#mag_1=m[band_1_idx]
mag_2=m[band_2_idx]
mag_1=blue_model(color,mags,z,mag_2)
this_model=RSModel(z, mag_1, mag_2, slope_fit)
rs_models[color][this_model.z]=this_model
return slope_fit,i_band0,color_err,rs_models,band_1,band_2
# adding the slope for different color set that we are interested in (01_rsz_test,fit_gr_ri01.ipyn)
def blue_model(color,mags,redshift,red_mag):
#g-r
if color=='sloan_g-sloan_r':
|
elif color=='sloan_r-sloan_i':
if redshift <= 0.36:
blue_mag=(0.348871987852+0.75340856*redshift)+red_mag
else:
blue_mag=(-0.210727367027+2.2836974*redshift)+red_mag
else:
print 'This color has not been implemented.'
return blue_mag
def histogram_plot(xranf,numberf,df,ax=None,line=False,cbar=False):
l2=6
ax.set_xlim(0,0.8)
ic2,ic3=0,0
numbers=numberf[:6]
numbers2=numberf[l2:]
ax.bar(xranf[:6],numbers,width=0.05,color='red',alpha=0.5,align='center')
ax.bar(xranf[l2:],numbers2,width=0.05,alpha=0.5,align='center')
if cbar:
cbar=fig.colorbar(s_m, ax=ax)
cbar.set_label("redshift")
if line:
if dff_sdss.loc[ind].redshift!=-1:
ax.axvline(dff_sdss.redshift[ind],ls='--',color='#66cc00',lw=2.,label='qso z=%.2f'%dff_sdss.redshift[ind])
ax.axvline(xranf[:6][ic2],ls='--',color='black',lw=2.,label='red_seq g-r z=%.2f'%xranf[:6][ic2])
ax.axvline(xranf[l2:][ic3],ls='--',color='purple',lw=2.,label='red_seq r-i z=%.2f'%xranf[l2:][ic3])
ax.legend(loc='best',frameon=False)
sigma,sigma2,sigma3=0.,0.,0.
if line:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3,dff_sdss.redshift[ind],sigma])
else:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3])
def save_rgb_image_extra(field, f026):
cmd = "ds9 -zscale -crosshair %f %f wcs fk5 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_2.eps -exit" % \
(f026.RA0.values[0], f026.DEC0.values[0], field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
cmd = "ds9 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_3.eps -exit" % \
(field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
print 'finished saving final/img%s.eps' % field
def find_offset(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
band=[x.split(' ')[0][-1] for x in content[5:-1]]
corr=[float(x.split(' ')[1]) for x in content[5:-1]]
ecorr=[float(x.split(' ')[3]) for x in content[5:-1]]
return zip(band,corr,ecorr), corr
def find_num(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
num_2mass=content[0].split(' ')[3]
num_star=content[3].split(' ')[1]
chisq=content[2].split(' ')[1]
return num_2mass,num_star,chisq
##--------
if __name__ == "__main__":
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filters=['sloan_r','sloan_i','sloan_z','sloan_g']
| blue_mag=(0.787302458781+2.9352*redshift)+red_mag | conditional_block |
pisco_redsequence.py | 5,0.01) #just for the line plot in the 3rd plot
redshift_range=np.arange(0.10,0.8,0.05) #for the actual data
number=[]
if color=='sloan_g-sloan_r':
redshift_range=np.arange(0.10,0.36,0.05)
elif color=='sloan_r-sloan_i':
redshift_range=np.arange(0.10,0.71,0.05)
for redshift in redshift_range:
if color=='sloan_g-sloan_r':
# i_band_cut=20.5
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
elif color=='sloan_r-sloan_i':
i_band_cut=i_band0+5.*np.log10(ex.d_L(redshift)*1e6)-5.
aa=red_band<i_band_cut
loc=[(all_x<i_band_cut)&\
(total < rs_models[color][round(redshift+0.025,2)].rs_color(all_x))&\
(total > rs_models[color][round(redshift-0.025,2)].rs_color(all_x))][0]
number.append(np.sum(loc))
ax.plot(red_band[aa],rs_models[color][round(redshift,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls='-')
ax.plot(red_band[aa],rs_models[color][round(redshift+0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.plot(red_band[aa],rs_models[color][round(redshift-0.025,2)].rs_color(red_band[aa]),\
color=s_m.to_rgba(round(redshift,2)),ls=':')
ax.set_xlim(16,25)
if color == 'sloan_g-sloan_i':
ax.set_ylim(0,4)
elif color == 'sloan_g-sloan_r':
ax.set_ylim(0.0,2.5)
else:
ax.set_ylim(-0.5,1.75)
ax.set_xlabel(band_x)
ax.set_ylabel(color)
return np.array(redshift_range),np.array(number)
def color_sloan(color, mags):
if color=='sloan_r-sloan_z':
slope_r_m_i=-0.0192138872893
slope_r_m_z=(1.584 * slope_r_m_i)
slope_fit=[slope_r_m_z, 0]
i_band0=-20.
elif color=='sloan_g-sloan_i':
slope_v_m_i=-0.029
slope_g_m_i=(1.481 * slope_v_m_i)
slope_fit=[slope_g_m_i, 0]
i_band0=-20.
elif color=='sloan_r-sloan_i':
slope_rc_m_ic=-0.0192138872893
slope_r_m_i=(1.007 * slope_rc_m_ic)
slope_fit=[slope_r_m_i, 0]
i_band0=-20.5
color_err=0.18
elif color=='sloan_g-sloan_r':
slope_v_m_r=-0.0133824600874
slope_g_m_r=(1.646 * slope_v_m_r)
slope_fit=[slope_g_m_r, 0]
i_band0=-20.5
color_err=0.15
band_1, band_2 = color.split("-")
band_1_idx=filters.index(band_1)
band_2_idx=filters.index(band_2)
rs_models=dict()
rs_models[color]=dict()
for z, m in zip(zs,mags):
#mag_1=m[band_1_idx]
mag_2=m[band_2_idx]
mag_1=blue_model(color,mags,z,mag_2)
this_model=RSModel(z, mag_1, mag_2, slope_fit)
rs_models[color][this_model.z]=this_model
return slope_fit,i_band0,color_err,rs_models,band_1,band_2
# adding the slope for different color set that we are interested in (01_rsz_test,fit_gr_ri01.ipyn)
def blue_model(color,mags,redshift,red_mag):
#g-r
if color=='sloan_g-sloan_r':
blue_mag=(0.787302458781+2.9352*redshift)+red_mag
elif color=='sloan_r-sloan_i':
if redshift <= 0.36:
blue_mag=(0.348871987852+0.75340856*redshift)+red_mag | print 'This color has not been implemented.'
return blue_mag
def histogram_plot(xranf,numberf,df,ax=None,line=False,cbar=False):
l2=6
ax.set_xlim(0,0.8)
ic2,ic3=0,0
numbers=numberf[:6]
numbers2=numberf[l2:]
ax.bar(xranf[:6],numbers,width=0.05,color='red',alpha=0.5,align='center')
ax.bar(xranf[l2:],numbers2,width=0.05,alpha=0.5,align='center')
if cbar:
cbar=fig.colorbar(s_m, ax=ax)
cbar.set_label("redshift")
if line:
if dff_sdss.loc[ind].redshift!=-1:
ax.axvline(dff_sdss.redshift[ind],ls='--',color='#66cc00',lw=2.,label='qso z=%.2f'%dff_sdss.redshift[ind])
ax.axvline(xranf[:6][ic2],ls='--',color='black',lw=2.,label='red_seq g-r z=%.2f'%xranf[:6][ic2])
ax.axvline(xranf[l2:][ic3],ls='--',color='purple',lw=2.,label='red_seq r-i z=%.2f'%xranf[l2:][ic3])
ax.legend(loc='best',frameon=False)
sigma,sigma2,sigma3=0.,0.,0.
if line:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3,dff_sdss.redshift[ind],sigma])
else:
return np.array([xranf[:6][ic2],sigma2,xranf[l2:][ic3],sigma3])
def save_rgb_image_extra(field, f026):
cmd = "ds9 -zscale -crosshair %f %f wcs fk5 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_2.eps -exit" % \
(f026.RA0.values[0], f026.DEC0.values[0], field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
cmd = "ds9 -rgb -red final/coadd_c%s_i.fits -green final/coadd_c%s_r.fits -blue final/coadd_c%s_g.fits -zoom out -saveimage final/img%s_3.eps -exit" % \
(field, field, field, field)
print cmd
sub = subprocess.check_call(shlex.split(cmd))
print 'finished saving final/img%s.eps' % field
def find_offset(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
band=[x.split(' ')[0][-1] for x in content[5:-1]]
corr=[float(x.split(' ')[1]) for x in content[5:-1]]
ecorr=[float(x.split(' ')[3]) for x in content[5:-1]]
return zip(band,corr,ecorr), corr
def find_num(fname):
with open(fname) as f:
content = f.readlines()
content = [x.strip() for x in content]
num_2mass=content[0].split(' ')[3]
num_star=content[3].split(' ')[1]
chisq=content[2].split(' ')[1]
return num_2mass,num_star,chisq
##--------
if __name__ == "__main__":
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filters=['sloan_r','sloan_i','sloan_z','sloan_g']
z | else:
blue_mag=(-0.210727367027+2.2836974*redshift)+red_mag
else: | random_line_split |
main.rs | fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
&self.view[x + self.width * y]
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Orientation {
Up,
Down,
Left,
Right,
}
impl TryFrom<u8> for Orientation {
type Error = Error;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
b'^' => Ok(Orientation::Up),
b'v' => Ok(Orientation::Down),
b'<' => Ok(Orientation::Left),
b'>' => Ok(Orientation::Right),
_ => bail!("unknown orientation {value}"),
}
}
}
impl Orientation {
fn delta(&self) -> (isize, isize) {
match self {
Orientation::Up => (0, -1),
Orientation::Down => (0, 1),
Orientation::Left => (-1, 0),
Orientation::Right => (1, 0),
}
}
fn angle(&self) -> isize {
match self {
Orientation::Up => 90,
Orientation::Down => 270,
Orientation::Left => 180,
Orientation::Right => 0,
}
}
fn orient(&self, to: Orientation) -> Vec<Command> {
let diff_angle = to.angle() - self.angle();
let diff_angle = if diff_angle < 0 {
diff_angle + 360
} else {
diff_angle
};
match diff_angle {
0 => vec![],
90 => vec![Command::Left],
180 => vec![Command::Left, Command::Left],
270 => vec![Command::Right],
_ => panic!("unrecognized angle: {diff_angle}"),
}
}
fn is_opposite(&self, to: Orientation) -> bool {
match self {
Orientation::Up => to == Orientation::Down,
Orientation::Down => to == Orientation::Up,
Orientation::Left => to == Orientation::Right,
Orientation::Right => to == Orientation::Left,
}
}
}
impl View {
fn neighbours(
&self,
pos: (usize, usize),
) -> impl Iterator<Item = (Orientation, (usize, usize))> {
let width = self.width;
let height = self.height;
[
Orientation::Up,
Orientation::Down,
Orientation::Left,
Orientation::Right,
]
.into_iter()
.filter_map(move |o| {
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (o, (x, y))))
})
.filter(move |(_, (x, y))| *x < width && *y < height)
}
fn forward(&self, pos: (usize, usize), o: Orientation) -> Option<(usize, usize)> {
let width = self.width;
let height = self.height;
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (x, y)))
.filter(move |(x, y)| *x < width && *y < height)
}
fn compute_route(&self) -> Result<Route, Error> {
let mut route = vec![];
let pos = self
.view
.iter()
.position(|c| *c != b'.' && *c != b'#')
.unwrap();
let mut cur_pos = (pos % self.width, pos / self.width);
let mut o = Orientation::try_from(self[cur_pos])?;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' {
route.append(&mut o.orient(n.0));
o = n.0;
break;
}
}
loop {
// move forward until either None or self[pos] != b'#'
let mut steps = 0;
while let Some(p) = self.forward(cur_pos, o) {
if self[p] != b'#' {
break;
}
steps += 1;
cur_pos = p;
}
route.push(Command::Forward(steps));
let mut found_turn = false;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' && !o.is_opposite(n.0) { | o = n.0;
break;
}
}
if !found_turn {
break;
}
}
let route = Route(route);
Ok(route)
}
}
fn part_01(input: &str) -> Result<usize, Error> {
let mut aligment_parameters = 0;
let view: View = input.parse()?;
for y in 1..view.height - 1 {
for x in 1..view.width - 1 {
if view[(x, y)] == b'#'
&& view[(x - 1, y)] == b'#'
&& view[(x + 1, y)] == b'#'
&& view[(x, y - 1)] == b'#'
&& view[(x, y + 1)] == b'#'
{
aligment_parameters += x * y;
}
}
}
Ok(aligment_parameters)
}
impl Display for View {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for (idx, c) in self.view.iter().enumerate() {
if idx > 0 && idx % self.width == 0 {
writeln!(f)?;
}
write!(f, "{}", *c as char)?;
}
Ok(())
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Command {
Right,
Left,
Forward(usize),
}
impl Display for Command {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Command::Right => write!(f, "R"),
Command::Left => write!(f, "L"),
Command::Forward(d) => write!(f, "{d}"),
}
}
}
struct Route(Vec<Command>);
impl Display for Route {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(c) = self.0.first() {
write!(f, "{c}")?;
}
for c in self.0.iter().skip(1) {
write!(f, ",{c}")?;
}
Ok(())
}
}
fn strip_commas(mut input: &str) -> &str {
input = if let Some(i) = input.strip_prefix(',') {
i
} else {
input
};
if let Some(i) = input.strip_suffix(',') {
i
} else {
input
}
}
impl Route {
// return (main, A, B, C)
fn compress_route(&self) -> (String, String, String, String) {
// we need a pattern at the begining,
// one at the end, and the rest
// for a, scan from start,
// then split string at a, and do same for b
// on remaining string
// if what's left are identical, call that c, and if the prog is
// compressed down to less than 20 chars, return that
// complexity due to commas
let complete = format!("{self}");
for a in complete
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = complete
.split(&a)
.map(strip_commas)
.filter(|f| !f.is_empty())
.collect();
// looking for a prefix in the first frament:
if let Some(first) = fragments.first() {
for b in first
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = fragments
.iter()
.flat_map(|f| f.split(&b))
.map(strip_commas)
.filter(|f| !f.is_empty() && f != &",")
.collect();
if let Some(&c) = fragments.first() {
let c = c.to_owned();
if fragments
.iter()
.all(|f| f.split(&c).all(|f| f == "," || f.is_empty()))
{
let prog = complete.replace(&a | found_turn = true;
route.append(&mut o.orient(n.0)); | random_line_split |
main.rs | fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
&self.view[x + self.width * y]
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Orientation {
Up,
Down,
Left,
Right,
}
impl TryFrom<u8> for Orientation {
type Error = Error;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
b'^' => Ok(Orientation::Up),
b'v' => Ok(Orientation::Down),
b'<' => Ok(Orientation::Left),
b'>' => Ok(Orientation::Right),
_ => bail!("unknown orientation {value}"),
}
}
}
impl Orientation {
fn delta(&self) -> (isize, isize) {
match self {
Orientation::Up => (0, -1),
Orientation::Down => (0, 1),
Orientation::Left => (-1, 0),
Orientation::Right => (1, 0),
}
}
fn angle(&self) -> isize {
match self {
Orientation::Up => 90,
Orientation::Down => 270,
Orientation::Left => 180,
Orientation::Right => 0,
}
}
fn orient(&self, to: Orientation) -> Vec<Command> {
let diff_angle = to.angle() - self.angle();
let diff_angle = if diff_angle < 0 {
diff_angle + 360
} else {
diff_angle
};
match diff_angle {
0 => vec![],
90 => vec![Command::Left],
180 => vec![Command::Left, Command::Left],
270 => vec![Command::Right],
_ => panic!("unrecognized angle: {diff_angle}"),
}
}
fn is_opposite(&self, to: Orientation) -> bool {
match self {
Orientation::Up => to == Orientation::Down,
Orientation::Down => to == Orientation::Up,
Orientation::Left => to == Orientation::Right,
Orientation::Right => to == Orientation::Left,
}
}
}
impl View {
fn neighbours(
&self,
pos: (usize, usize),
) -> impl Iterator<Item = (Orientation, (usize, usize))> |
fn forward(&self, pos: (usize, usize), o: Orientation) -> Option<(usize, usize)> {
let width = self.width;
let height = self.height;
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (x, y)))
.filter(move |(x, y)| *x < width && *y < height)
}
fn compute_route(&self) -> Result<Route, Error> {
let mut route = vec![];
let pos = self
.view
.iter()
.position(|c| *c != b'.' && *c != b'#')
.unwrap();
let mut cur_pos = (pos % self.width, pos / self.width);
let mut o = Orientation::try_from(self[cur_pos])?;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' {
route.append(&mut o.orient(n.0));
o = n.0;
break;
}
}
loop {
// move forward until either None or self[pos] != b'#'
let mut steps = 0;
while let Some(p) = self.forward(cur_pos, o) {
if self[p] != b'#' {
break;
}
steps += 1;
cur_pos = p;
}
route.push(Command::Forward(steps));
let mut found_turn = false;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' && !o.is_opposite(n.0) {
found_turn = true;
route.append(&mut o.orient(n.0));
o = n.0;
break;
}
}
if !found_turn {
break;
}
}
let route = Route(route);
Ok(route)
}
}
fn part_01(input: &str) -> Result<usize, Error> {
let mut aligment_parameters = 0;
let view: View = input.parse()?;
for y in 1..view.height - 1 {
for x in 1..view.width - 1 {
if view[(x, y)] == b'#'
&& view[(x - 1, y)] == b'#'
&& view[(x + 1, y)] == b'#'
&& view[(x, y - 1)] == b'#'
&& view[(x, y + 1)] == b'#'
{
aligment_parameters += x * y;
}
}
}
Ok(aligment_parameters)
}
impl Display for View {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for (idx, c) in self.view.iter().enumerate() {
if idx > 0 && idx % self.width == 0 {
writeln!(f)?;
}
write!(f, "{}", *c as char)?;
}
Ok(())
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Command {
Right,
Left,
Forward(usize),
}
impl Display for Command {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Command::Right => write!(f, "R"),
Command::Left => write!(f, "L"),
Command::Forward(d) => write!(f, "{d}"),
}
}
}
struct Route(Vec<Command>);
impl Display for Route {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(c) = self.0.first() {
write!(f, "{c}")?;
}
for c in self.0.iter().skip(1) {
write!(f, ",{c}")?;
}
Ok(())
}
}
fn strip_commas(mut input: &str) -> &str {
input = if let Some(i) = input.strip_prefix(',') {
i
} else {
input
};
if let Some(i) = input.strip_suffix(',') {
i
} else {
input
}
}
impl Route {
// return (main, A, B, C)
fn compress_route(&self) -> (String, String, String, String) {
// we need a pattern at the begining,
// one at the end, and the rest
// for a, scan from start,
// then split string at a, and do same for b
// on remaining string
// if what's left are identical, call that c, and if the prog is
// compressed down to less than 20 chars, return that
// complexity due to commas
let complete = format!("{self}");
for a in complete
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = complete
.split(&a)
.map(strip_commas)
.filter(|f| !f.is_empty())
.collect();
// looking for a prefix in the first frament:
if let Some(first) = fragments.first() {
for b in first
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = fragments
.iter()
.flat_map(|f| f.split(&b))
.map(strip_commas)
.filter(|f| !f.is_empty() && f != &",")
.collect();
if let Some(&c) = fragments.first() {
let c = c.to_owned();
if fragments
.iter()
.all(|f| f.split(&c).all(|f| f == "," || f.is_empty()))
{
let prog = complete.replace(& | {
let width = self.width;
let height = self.height;
[
Orientation::Up,
Orientation::Down,
Orientation::Left,
Orientation::Right,
]
.into_iter()
.filter_map(move |o| {
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (o, (x, y))))
})
.filter(move |(_, (x, y))| *x < width && *y < height)
} | identifier_body |
main.rs | fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
&self.view[x + self.width * y]
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Orientation {
Up,
Down,
Left,
Right,
}
impl TryFrom<u8> for Orientation {
type Error = Error;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
b'^' => Ok(Orientation::Up),
b'v' => Ok(Orientation::Down),
b'<' => Ok(Orientation::Left),
b'>' => Ok(Orientation::Right),
_ => bail!("unknown orientation {value}"),
}
}
}
impl Orientation {
fn delta(&self) -> (isize, isize) {
match self {
Orientation::Up => (0, -1),
Orientation::Down => (0, 1),
Orientation::Left => (-1, 0),
Orientation::Right => (1, 0),
}
}
fn angle(&self) -> isize {
match self {
Orientation::Up => 90,
Orientation::Down => 270,
Orientation::Left => 180,
Orientation::Right => 0,
}
}
fn orient(&self, to: Orientation) -> Vec<Command> {
let diff_angle = to.angle() - self.angle();
let diff_angle = if diff_angle < 0 {
diff_angle + 360
} else {
diff_angle
};
match diff_angle {
0 => vec![],
90 => vec![Command::Left],
180 => vec![Command::Left, Command::Left],
270 => vec![Command::Right],
_ => panic!("unrecognized angle: {diff_angle}"),
}
}
fn is_opposite(&self, to: Orientation) -> bool {
match self {
Orientation::Up => to == Orientation::Down,
Orientation::Down => to == Orientation::Up,
Orientation::Left => to == Orientation::Right,
Orientation::Right => to == Orientation::Left,
}
}
}
impl View {
fn neighbours(
&self,
pos: (usize, usize),
) -> impl Iterator<Item = (Orientation, (usize, usize))> {
let width = self.width;
let height = self.height;
[
Orientation::Up,
Orientation::Down,
Orientation::Left,
Orientation::Right,
]
.into_iter()
.filter_map(move |o| {
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (o, (x, y))))
})
.filter(move |(_, (x, y))| *x < width && *y < height)
}
fn | (&self, pos: (usize, usize), o: Orientation) -> Option<(usize, usize)> {
let width = self.width;
let height = self.height;
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (x, y)))
.filter(move |(x, y)| *x < width && *y < height)
}
fn compute_route(&self) -> Result<Route, Error> {
let mut route = vec![];
let pos = self
.view
.iter()
.position(|c| *c != b'.' && *c != b'#')
.unwrap();
let mut cur_pos = (pos % self.width, pos / self.width);
let mut o = Orientation::try_from(self[cur_pos])?;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' {
route.append(&mut o.orient(n.0));
o = n.0;
break;
}
}
loop {
// move forward until either None or self[pos] != b'#'
let mut steps = 0;
while let Some(p) = self.forward(cur_pos, o) {
if self[p] != b'#' {
break;
}
steps += 1;
cur_pos = p;
}
route.push(Command::Forward(steps));
let mut found_turn = false;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' && !o.is_opposite(n.0) {
found_turn = true;
route.append(&mut o.orient(n.0));
o = n.0;
break;
}
}
if !found_turn {
break;
}
}
let route = Route(route);
Ok(route)
}
}
fn part_01(input: &str) -> Result<usize, Error> {
let mut aligment_parameters = 0;
let view: View = input.parse()?;
for y in 1..view.height - 1 {
for x in 1..view.width - 1 {
if view[(x, y)] == b'#'
&& view[(x - 1, y)] == b'#'
&& view[(x + 1, y)] == b'#'
&& view[(x, y - 1)] == b'#'
&& view[(x, y + 1)] == b'#'
{
aligment_parameters += x * y;
}
}
}
Ok(aligment_parameters)
}
impl Display for View {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for (idx, c) in self.view.iter().enumerate() {
if idx > 0 && idx % self.width == 0 {
writeln!(f)?;
}
write!(f, "{}", *c as char)?;
}
Ok(())
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Command {
Right,
Left,
Forward(usize),
}
impl Display for Command {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Command::Right => write!(f, "R"),
Command::Left => write!(f, "L"),
Command::Forward(d) => write!(f, "{d}"),
}
}
}
struct Route(Vec<Command>);
impl Display for Route {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(c) = self.0.first() {
write!(f, "{c}")?;
}
for c in self.0.iter().skip(1) {
write!(f, ",{c}")?;
}
Ok(())
}
}
fn strip_commas(mut input: &str) -> &str {
input = if let Some(i) = input.strip_prefix(',') {
i
} else {
input
};
if let Some(i) = input.strip_suffix(',') {
i
} else {
input
}
}
impl Route {
// return (main, A, B, C)
fn compress_route(&self) -> (String, String, String, String) {
// we need a pattern at the begining,
// one at the end, and the rest
// for a, scan from start,
// then split string at a, and do same for b
// on remaining string
// if what's left are identical, call that c, and if the prog is
// compressed down to less than 20 chars, return that
// complexity due to commas
let complete = format!("{self}");
for a in complete
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = complete
.split(&a)
.map(strip_commas)
.filter(|f| !f.is_empty())
.collect();
// looking for a prefix in the first frament:
if let Some(first) = fragments.first() {
for b in first
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = fragments
.iter()
.flat_map(|f| f.split(&b))
.map(strip_commas)
.filter(|f| !f.is_empty() && f != &",")
.collect();
if let Some(&c) = fragments.first() {
let c = c.to_owned();
if fragments
.iter()
.all(|f| f.split(&c).all(|f| f == "," || f.is_empty()))
{
let prog = complete.replace(& | forward | identifier_name |
main.rs |
} else {
view.push(o);
}
}
let height = view.len() / width;
Ok(View {
view,
width,
height,
})
}
}
impl Index<(usize, usize)> for View {
type Output = u8;
fn index(&self, (x, y): (usize, usize)) -> &Self::Output {
&self.view[x + self.width * y]
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Orientation {
Up,
Down,
Left,
Right,
}
impl TryFrom<u8> for Orientation {
type Error = Error;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
b'^' => Ok(Orientation::Up),
b'v' => Ok(Orientation::Down),
b'<' => Ok(Orientation::Left),
b'>' => Ok(Orientation::Right),
_ => bail!("unknown orientation {value}"),
}
}
}
impl Orientation {
fn delta(&self) -> (isize, isize) {
match self {
Orientation::Up => (0, -1),
Orientation::Down => (0, 1),
Orientation::Left => (-1, 0),
Orientation::Right => (1, 0),
}
}
fn angle(&self) -> isize {
match self {
Orientation::Up => 90,
Orientation::Down => 270,
Orientation::Left => 180,
Orientation::Right => 0,
}
}
fn orient(&self, to: Orientation) -> Vec<Command> {
let diff_angle = to.angle() - self.angle();
let diff_angle = if diff_angle < 0 {
diff_angle + 360
} else {
diff_angle
};
match diff_angle {
0 => vec![],
90 => vec![Command::Left],
180 => vec![Command::Left, Command::Left],
270 => vec![Command::Right],
_ => panic!("unrecognized angle: {diff_angle}"),
}
}
fn is_opposite(&self, to: Orientation) -> bool {
match self {
Orientation::Up => to == Orientation::Down,
Orientation::Down => to == Orientation::Up,
Orientation::Left => to == Orientation::Right,
Orientation::Right => to == Orientation::Left,
}
}
}
impl View {
fn neighbours(
&self,
pos: (usize, usize),
) -> impl Iterator<Item = (Orientation, (usize, usize))> {
let width = self.width;
let height = self.height;
[
Orientation::Up,
Orientation::Down,
Orientation::Left,
Orientation::Right,
]
.into_iter()
.filter_map(move |o| {
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (o, (x, y))))
})
.filter(move |(_, (x, y))| *x < width && *y < height)
}
fn forward(&self, pos: (usize, usize), o: Orientation) -> Option<(usize, usize)> {
let width = self.width;
let height = self.height;
let d = o.delta();
pos.0
.checked_add_signed(d.0)
.and_then(|x| pos.1.checked_add_signed(d.1).map(|y| (x, y)))
.filter(move |(x, y)| *x < width && *y < height)
}
fn compute_route(&self) -> Result<Route, Error> {
let mut route = vec![];
let pos = self
.view
.iter()
.position(|c| *c != b'.' && *c != b'#')
.unwrap();
let mut cur_pos = (pos % self.width, pos / self.width);
let mut o = Orientation::try_from(self[cur_pos])?;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' {
route.append(&mut o.orient(n.0));
o = n.0;
break;
}
}
loop {
// move forward until either None or self[pos] != b'#'
let mut steps = 0;
while let Some(p) = self.forward(cur_pos, o) {
if self[p] != b'#' {
break;
}
steps += 1;
cur_pos = p;
}
route.push(Command::Forward(steps));
let mut found_turn = false;
for n in self.neighbours(cur_pos) {
if self[n.1] == b'#' && !o.is_opposite(n.0) {
found_turn = true;
route.append(&mut o.orient(n.0));
o = n.0;
break;
}
}
if !found_turn {
break;
}
}
let route = Route(route);
Ok(route)
}
}
fn part_01(input: &str) -> Result<usize, Error> {
let mut aligment_parameters = 0;
let view: View = input.parse()?;
for y in 1..view.height - 1 {
for x in 1..view.width - 1 {
if view[(x, y)] == b'#'
&& view[(x - 1, y)] == b'#'
&& view[(x + 1, y)] == b'#'
&& view[(x, y - 1)] == b'#'
&& view[(x, y + 1)] == b'#'
{
aligment_parameters += x * y;
}
}
}
Ok(aligment_parameters)
}
impl Display for View {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for (idx, c) in self.view.iter().enumerate() {
if idx > 0 && idx % self.width == 0 {
writeln!(f)?;
}
write!(f, "{}", *c as char)?;
}
Ok(())
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
enum Command {
Right,
Left,
Forward(usize),
}
impl Display for Command {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Command::Right => write!(f, "R"),
Command::Left => write!(f, "L"),
Command::Forward(d) => write!(f, "{d}"),
}
}
}
struct Route(Vec<Command>);
impl Display for Route {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(c) = self.0.first() {
write!(f, "{c}")?;
}
for c in self.0.iter().skip(1) {
write!(f, ",{c}")?;
}
Ok(())
}
}
fn strip_commas(mut input: &str) -> &str {
input = if let Some(i) = input.strip_prefix(',') {
i
} else {
input
};
if let Some(i) = input.strip_suffix(',') {
i
} else {
input
}
}
impl Route {
// return (main, A, B, C)
fn compress_route(&self) -> (String, String, String, String) {
// we need a pattern at the begining,
// one at the end, and the rest
// for a, scan from start,
// then split string at a, and do same for b
// on remaining string
// if what's left are identical, call that c, and if the prog is
// compressed down to less than 20 chars, return that
// complexity due to commas
let complete = format!("{self}");
for a in complete
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = complete
.split(&a)
.map(strip_commas)
.filter(|f| !f.is_empty())
.collect();
// looking for a prefix in the first frament:
if let Some(first) = fragments.first() {
for b in first
.split(',')
.scan(String::new(), |s, c| {
if !s.is_empty() {
*s = format!("{s},{c}");
} else {
*s = c.to_owned();
}
Some(s.clone())
})
.take_while(|s| s.len() <= 20)
{
let fragments: Vec<_> = fragments
.iter()
.flat_map(|f| f.split(&b))
.map(strip_commas)
.filter(|f| !f.is_empty() && f != | {
width = view.len();
} | conditional_block |
|
val.rs | ` half of `Val` used to send the result of an asynchronous
/// computation to the consumer of `Val`.
///
/// This is created by the `pair` function.
pub struct Complete<T, E> {
inner: Arc<Inner<T, E>>,
cancellation: Cell<bool>,
}
/// A future representing the cancellation in interest by the consumer of
/// `Val`.
///
/// If a `Val` is dropped without ever attempting to read the value, then it
/// becomes impossible to ever receive the result of the underlying
/// computation. This indicates that there is no interest in the computation
/// and it may be cancelled.
///
/// In this case, this future will be completed. The asynchronous computation
/// is able to listen for this completion and abort work early.
pub struct Cancellation {
inner: Arc<SyncFuture>,
}
// Currently implemented with a mutex, but this is only to get something
// working. This should be rewritten to use a lock free strategy.
struct Inner<T, E> {
state: Mutex<State<T, E>>,
}
enum State<T, E> {
Init {
consumer: Option<Callback>,
cancellation: Option<Callback>
},
Completed(Option<Result<T, E>>),
Cancelled,
Consumed,
}
type Callback = Box<FnBox>;
/// Create and return a new `Complete` / `Val` pair.
///
/// `Complete` is used to send the result of an asynchronous computation to the
/// consumer of `Val`.
pub fn pair<T, E>() -> (Complete<T, E>, Val<T, E>) {
let inner = Arc::new(Inner {
state: Mutex::new(State::Init {
consumer: None,
cancellation: None,
}),
});
let tx = Complete {
inner: inner.clone(),
cancellation: Cell::new(false),
};
let rx = Val {
inner: inner,
};
(tx, rx)
}
/*
*
* ===== Val =====
*
*/
impl<T, E> Future for Val<T, E>
where T: Send + 'static,
E: Send + 'static,
{
type Item = T;
type Error = E;
fn poll(&mut self, task: &mut Task) -> Poll<T, E> {
self.inner.poll(task)
}
fn schedule(&mut self, task: &mut Task) {
self.inner.schedule(task)
}
}
impl<T, E> Drop for Val<T, E> {
fn drop(&mut self) {
self.inner.cancel();
}
}
/*
*
* ===== Complete =====
*
*/
impl<T, E> Complete<T, E>
where T: Send + 'static,
E: Send + 'static,
{
/// Successfully complete the associated `Val` with the given value.
pub fn complete(self, val: T) {
self.inner.complete(Some(Ok(val)), false);
}
/// Complete the associated `Val` with the given error
pub fn error(self, err: E) {
self.inner.complete(Some(Err(err)), false);
}
/// Abort the computation. This will cause the associated `Val` to panic on
/// a call to `poll`.
pub fn abort(self) {
self.inner.complete(None, false);
}
/// Returns a `Future` representing the consuming end cancelling interest
/// in the future.
///
/// This function can only be called once.
///
/// # Panics
///
/// A second call to this function will result in a panic.
pub fn cancellation(&self) -> Cancellation {
if self.cancellation.get() {
panic!("cancellation future already obtained");
}
self.cancellation.set(true);
Cancellation { inner: self.inner.clone() }
}
}
impl<T, E> Drop for Complete<T, E> {
fn drop(&mut self) {
self.inner.complete(None, true);
}
}
/*
*
* ===== Cancellation =====
*
*/
impl Future for Cancellation {
type Item = bool;
type Error = ();
fn | (&mut self, task: &mut Task) -> Poll<bool, ()> {
self.inner.poll(task)
}
fn schedule(&mut self, task: &mut Task) {
self.inner.schedule(task)
}
}
/*
*
* ===== Inner =====
*
*/
impl<T, E> Inner<T, E> {
/// Complete the future with the given result
fn complete(&self, res: Option<Result<T, E>>, panic: bool) {
let mut state = match self.state.lock() {
Ok(s) => s,
Err(_) => {
if panic { panic!("failed to lock mutex") };
return;
}
};
let cb;
match state.take() {
Init { consumer, .. } => cb = consumer,
s => {
if res.is_some() {
panic!("attempting to complete already completed future");
} else {
*state = s;
return;
}
}
}
*state = Completed(res);
drop(state);
if let Some(cb) = cb {
cb.call_box(); // Invoke callback
}
}
/// Cancel interest in the future
fn cancel(&self) {
let mut state = match self.state.lock() {
Ok(s) => s,
Err(_) => return,
};
let cb;
match state.take() {
Init { cancellation, .. } => cb = cancellation,
Completed(_) | Cancelled | Consumed => {
return; // Cannot cancel from these states
}
}
*state = Cancelled;
drop(state);
if let Some(cb) = cb {
cb.call_box(); // Invoke callback
}
}
/// Poll the inner state for a value
fn poll(&self, _: &mut Task) -> Poll<T, E> {
let mut state = self.state.lock().unwrap();
if state.is_complete() {
match state.take() {
Completed(Some(Ok(v))) => Poll::Ok(v),
Completed(Some(Err(e))) => Poll::Err(e),
Completed(None) => panic!("Complete dropped without producing a value"),
Consumed => panic!("Val already consumed"),
_ => unreachable!(),
}
} else {
Poll::NotReady
}
}
/// Associate completion with the given task
fn schedule(&self, task: &mut Task) {
let mut state = self.state.lock().unwrap();
if state.in_flight() {
let handle = task.handle().clone();
state.set_consumer_cb(Box::new(move || handle.notify()));
} else {
task.handle().notify();
}
}
}
// A little hacky, but implementing Future on Inner allows losing the generics
// on Cancellation
trait SyncFuture: Send + Sync + 'static {
fn poll(&self, task: &mut Task) -> Poll<bool, ()>;
fn schedule(&self, task: &mut Task);
}
impl<T, E> SyncFuture for Inner<T, E>
where T: Send + 'static,
E: Send + 'static,
{
fn poll(&self, _: &mut Task) -> Poll<bool, ()> {
let state = self.state.lock().unwrap();
match *state {
Init { .. } => Poll::NotReady,
Cancelled => Poll::Ok(true),
_ => Poll::Ok(false),
}
}
fn schedule(&self, task: &mut Task) {
let mut state = self.state.lock().unwrap();
if state.in_flight() {
let handle = task.handle().clone();
state.set_cancellation_cb(Box::new(move || handle.notify()));
} else {
task.handle().notify();
}
}
}
impl<T, E> State<T, E> {
fn in_flight(&self) -> bool {
match *self {
Init { .. } => true,
_ => false,
}
}
/// Returns true if in a completed state.
fn is_complete(&self) -> bool {
match *self {
Completed(_) | Consumed => true,
_ => false,
}
}
fn set_consumer_cb(&mut self, cb: Callback) {
match *self {
Init { ref mut consumer, .. } => *consumer = Some(cb),
_ => panic!("unexpected state"),
}
}
fn set_cancellation_cb(&mut self, cb: Callback) {
match *self {
Init { ref mut cancellation, .. } => *cancellation = Some(cb),
_ => panic!("unexpected state"),
}
}
/// Sets the current state to Consumed and returns the original value
fn take(&mut self) -> State<T, E> {
mem::replace(self, State::Consumed)
}
}
trait FnBox: Send + 'static {
fn call_box(self: Box<Self>);
}
impl<F> FnBox for F
where F: FnOnce() + Send + 'static
{
fn call_box(self: Box<F>) {
(*self)()
}
}
#[cfg(test)]
mod test {
use super::*;
use futures::Future;
use std::sync::mpsc;
#[test]
fn test_complete_after_listen() {
let (c, val) = pair::<u32, ()>();
let (tx, rx) = mpsc::channel();
val.then(move |res| {
tx.send(res.unwrap()).unwrap();
res
}).forget();
c.complete(123);
assert_eq!(123, rx.recv().unwrap());
}
#[ | poll | identifier_name |
val.rs | the cancellation in interest by the consumer of
/// `Val`.
///
/// If a `Val` is dropped without ever attempting to read the value, then it
/// becomes impossible to ever receive the result of the underlying
/// computation. This indicates that there is no interest in the computation
/// and it may be cancelled.
///
/// In this case, this future will be completed. The asynchronous computation
/// is able to listen for this completion and abort work early.
pub struct Cancellation {
inner: Arc<SyncFuture>,
}
// Currently implemented with a mutex, but this is only to get something
// working. This should be rewritten to use a lock free strategy.
struct Inner<T, E> {
state: Mutex<State<T, E>>,
}
enum State<T, E> {
Init {
consumer: Option<Callback>,
cancellation: Option<Callback>
},
Completed(Option<Result<T, E>>),
Cancelled,
Consumed,
}
type Callback = Box<FnBox>;
/// Create and return a new `Complete` / `Val` pair.
///
/// `Complete` is used to send the result of an asynchronous computation to the
/// consumer of `Val`.
pub fn pair<T, E>() -> (Complete<T, E>, Val<T, E>) {
let inner = Arc::new(Inner {
state: Mutex::new(State::Init {
consumer: None,
cancellation: None,
}),
});
let tx = Complete {
inner: inner.clone(),
cancellation: Cell::new(false),
};
let rx = Val {
inner: inner,
};
(tx, rx)
}
/*
*
* ===== Val =====
*
*/
impl<T, E> Future for Val<T, E>
where T: Send + 'static,
E: Send + 'static,
{
type Item = T;
type Error = E;
fn poll(&mut self, task: &mut Task) -> Poll<T, E> {
self.inner.poll(task)
}
fn schedule(&mut self, task: &mut Task) {
self.inner.schedule(task)
}
}
impl<T, E> Drop for Val<T, E> {
fn drop(&mut self) {
self.inner.cancel();
}
}
/*
*
* ===== Complete =====
*
*/
impl<T, E> Complete<T, E>
where T: Send + 'static,
E: Send + 'static,
{
/// Successfully complete the associated `Val` with the given value.
pub fn complete(self, val: T) {
self.inner.complete(Some(Ok(val)), false);
}
/// Complete the associated `Val` with the given error
pub fn error(self, err: E) {
self.inner.complete(Some(Err(err)), false);
}
/// Abort the computation. This will cause the associated `Val` to panic on
/// a call to `poll`.
pub fn abort(self) {
self.inner.complete(None, false);
}
/// Returns a `Future` representing the consuming end cancelling interest
/// in the future.
///
/// This function can only be called once.
///
/// # Panics
///
/// A second call to this function will result in a panic.
pub fn cancellation(&self) -> Cancellation {
if self.cancellation.get() {
panic!("cancellation future already obtained");
}
self.cancellation.set(true);
Cancellation { inner: self.inner.clone() }
}
}
impl<T, E> Drop for Complete<T, E> {
fn drop(&mut self) {
self.inner.complete(None, true);
}
}
/*
*
* ===== Cancellation =====
*
*/
impl Future for Cancellation {
type Item = bool;
type Error = ();
fn poll(&mut self, task: &mut Task) -> Poll<bool, ()> {
self.inner.poll(task)
}
fn schedule(&mut self, task: &mut Task) {
self.inner.schedule(task)
}
}
/*
*
* ===== Inner =====
*
*/
impl<T, E> Inner<T, E> {
/// Complete the future with the given result
fn complete(&self, res: Option<Result<T, E>>, panic: bool) {
let mut state = match self.state.lock() {
Ok(s) => s,
Err(_) => {
if panic { panic!("failed to lock mutex") };
return;
}
};
let cb;
match state.take() {
Init { consumer, .. } => cb = consumer,
s => {
if res.is_some() {
panic!("attempting to complete already completed future");
} else {
*state = s;
return;
}
}
}
*state = Completed(res);
drop(state);
if let Some(cb) = cb {
cb.call_box(); // Invoke callback
}
}
/// Cancel interest in the future
fn cancel(&self) {
let mut state = match self.state.lock() {
Ok(s) => s,
Err(_) => return,
};
let cb;
match state.take() {
Init { cancellation, .. } => cb = cancellation,
Completed(_) | Cancelled | Consumed => {
return; // Cannot cancel from these states
}
}
*state = Cancelled;
drop(state);
if let Some(cb) = cb {
cb.call_box(); // Invoke callback
}
}
/// Poll the inner state for a value
fn poll(&self, _: &mut Task) -> Poll<T, E> {
let mut state = self.state.lock().unwrap();
if state.is_complete() {
match state.take() {
Completed(Some(Ok(v))) => Poll::Ok(v),
Completed(Some(Err(e))) => Poll::Err(e),
Completed(None) => panic!("Complete dropped without producing a value"),
Consumed => panic!("Val already consumed"),
_ => unreachable!(),
}
} else {
Poll::NotReady
}
}
/// Associate completion with the given task
fn schedule(&self, task: &mut Task) {
let mut state = self.state.lock().unwrap();
if state.in_flight() {
let handle = task.handle().clone();
state.set_consumer_cb(Box::new(move || handle.notify()));
} else {
task.handle().notify();
}
}
}
// A little hacky, but implementing Future on Inner allows losing the generics
// on Cancellation
trait SyncFuture: Send + Sync + 'static {
fn poll(&self, task: &mut Task) -> Poll<bool, ()>;
fn schedule(&self, task: &mut Task);
}
impl<T, E> SyncFuture for Inner<T, E>
where T: Send + 'static,
E: Send + 'static,
{
fn poll(&self, _: &mut Task) -> Poll<bool, ()> {
let state = self.state.lock().unwrap();
match *state {
Init { .. } => Poll::NotReady,
Cancelled => Poll::Ok(true),
_ => Poll::Ok(false),
}
}
fn schedule(&self, task: &mut Task) {
let mut state = self.state.lock().unwrap();
if state.in_flight() {
let handle = task.handle().clone();
state.set_cancellation_cb(Box::new(move || handle.notify()));
} else {
task.handle().notify();
}
}
}
impl<T, E> State<T, E> {
fn in_flight(&self) -> bool {
match *self {
Init { .. } => true,
_ => false,
}
}
/// Returns true if in a completed state.
fn is_complete(&self) -> bool {
match *self {
Completed(_) | Consumed => true,
_ => false,
}
}
fn set_consumer_cb(&mut self, cb: Callback) {
match *self {
Init { ref mut consumer, .. } => *consumer = Some(cb),
_ => panic!("unexpected state"),
}
}
fn set_cancellation_cb(&mut self, cb: Callback) {
match *self {
Init { ref mut cancellation, .. } => *cancellation = Some(cb),
_ => panic!("unexpected state"),
}
}
/// Sets the current state to Consumed and returns the original value
fn take(&mut self) -> State<T, E> {
mem::replace(self, State::Consumed)
}
}
trait FnBox: Send + 'static {
fn call_box(self: Box<Self>);
}
impl<F> FnBox for F
where F: FnOnce() + Send + 'static
{
fn call_box(self: Box<F>) {
(*self)()
}
}
#[cfg(test)]
mod test {
use super::*;
use futures::Future;
use std::sync::mpsc;
#[test]
fn test_complete_after_listen() {
let (c, val) = pair::<u32, ()>();
let (tx, rx) = mpsc::channel();
val.then(move |res| {
tx.send(res.unwrap()).unwrap();
res
}).forget();
c.complete(123);
assert_eq!(123, rx.recv().unwrap());
}
#[test]
fn test_complete_before_listen() {
let (c, val) = pair::<u32, ()>();
let (tx, rx) = mpsc::channel();
c.complete(123); |
val.then(move |res| {
tx.send(res.unwrap()).unwrap();
res | random_line_split |
|
val.rs | ` half of `Val` used to send the result of an asynchronous
/// computation to the consumer of `Val`.
///
/// This is created by the `pair` function.
pub struct Complete<T, E> {
inner: Arc<Inner<T, E>>,
cancellation: Cell<bool>,
}
/// A future representing the cancellation in interest by the consumer of
/// `Val`.
///
/// If a `Val` is dropped without ever attempting to read the value, then it
/// becomes impossible to ever receive the result of the underlying
/// computation. This indicates that there is no interest in the computation
/// and it may be cancelled.
///
/// In this case, this future will be completed. The asynchronous computation
/// is able to listen for this completion and abort work early.
pub struct Cancellation {
inner: Arc<SyncFuture>,
}
// Currently implemented with a mutex, but this is only to get something
// working. This should be rewritten to use a lock free strategy.
struct Inner<T, E> {
state: Mutex<State<T, E>>,
}
enum State<T, E> {
Init {
consumer: Option<Callback>,
cancellation: Option<Callback>
},
Completed(Option<Result<T, E>>),
Cancelled,
Consumed,
}
type Callback = Box<FnBox>;
/// Create and return a new `Complete` / `Val` pair.
///
/// `Complete` is used to send the result of an asynchronous computation to the
/// consumer of `Val`.
pub fn pair<T, E>() -> (Complete<T, E>, Val<T, E>) {
let inner = Arc::new(Inner {
state: Mutex::new(State::Init {
consumer: None,
cancellation: None,
}),
});
let tx = Complete {
inner: inner.clone(),
cancellation: Cell::new(false),
};
let rx = Val {
inner: inner,
};
(tx, rx)
}
/*
*
* ===== Val =====
*
*/
impl<T, E> Future for Val<T, E>
where T: Send + 'static,
E: Send + 'static,
{
type Item = T;
type Error = E;
fn poll(&mut self, task: &mut Task) -> Poll<T, E> {
self.inner.poll(task)
}
fn schedule(&mut self, task: &mut Task) {
self.inner.schedule(task)
}
}
impl<T, E> Drop for Val<T, E> {
fn drop(&mut self) {
self.inner.cancel();
}
}
/*
*
* ===== Complete =====
*
*/
impl<T, E> Complete<T, E>
where T: Send + 'static,
E: Send + 'static,
{
/// Successfully complete the associated `Val` with the given value.
pub fn complete(self, val: T) {
self.inner.complete(Some(Ok(val)), false);
}
/// Complete the associated `Val` with the given error
pub fn error(self, err: E) |
/// Abort the computation. This will cause the associated `Val` to panic on
/// a call to `poll`.
pub fn abort(self) {
self.inner.complete(None, false);
}
/// Returns a `Future` representing the consuming end cancelling interest
/// in the future.
///
/// This function can only be called once.
///
/// # Panics
///
/// A second call to this function will result in a panic.
pub fn cancellation(&self) -> Cancellation {
if self.cancellation.get() {
panic!("cancellation future already obtained");
}
self.cancellation.set(true);
Cancellation { inner: self.inner.clone() }
}
}
impl<T, E> Drop for Complete<T, E> {
fn drop(&mut self) {
self.inner.complete(None, true);
}
}
/*
*
* ===== Cancellation =====
*
*/
impl Future for Cancellation {
type Item = bool;
type Error = ();
fn poll(&mut self, task: &mut Task) -> Poll<bool, ()> {
self.inner.poll(task)
}
fn schedule(&mut self, task: &mut Task) {
self.inner.schedule(task)
}
}
/*
*
* ===== Inner =====
*
*/
impl<T, E> Inner<T, E> {
/// Complete the future with the given result
fn complete(&self, res: Option<Result<T, E>>, panic: bool) {
let mut state = match self.state.lock() {
Ok(s) => s,
Err(_) => {
if panic { panic!("failed to lock mutex") };
return;
}
};
let cb;
match state.take() {
Init { consumer, .. } => cb = consumer,
s => {
if res.is_some() {
panic!("attempting to complete already completed future");
} else {
*state = s;
return;
}
}
}
*state = Completed(res);
drop(state);
if let Some(cb) = cb {
cb.call_box(); // Invoke callback
}
}
/// Cancel interest in the future
fn cancel(&self) {
let mut state = match self.state.lock() {
Ok(s) => s,
Err(_) => return,
};
let cb;
match state.take() {
Init { cancellation, .. } => cb = cancellation,
Completed(_) | Cancelled | Consumed => {
return; // Cannot cancel from these states
}
}
*state = Cancelled;
drop(state);
if let Some(cb) = cb {
cb.call_box(); // Invoke callback
}
}
/// Poll the inner state for a value
fn poll(&self, _: &mut Task) -> Poll<T, E> {
let mut state = self.state.lock().unwrap();
if state.is_complete() {
match state.take() {
Completed(Some(Ok(v))) => Poll::Ok(v),
Completed(Some(Err(e))) => Poll::Err(e),
Completed(None) => panic!("Complete dropped without producing a value"),
Consumed => panic!("Val already consumed"),
_ => unreachable!(),
}
} else {
Poll::NotReady
}
}
/// Associate completion with the given task
fn schedule(&self, task: &mut Task) {
let mut state = self.state.lock().unwrap();
if state.in_flight() {
let handle = task.handle().clone();
state.set_consumer_cb(Box::new(move || handle.notify()));
} else {
task.handle().notify();
}
}
}
// A little hacky, but implementing Future on Inner allows losing the generics
// on Cancellation
trait SyncFuture: Send + Sync + 'static {
fn poll(&self, task: &mut Task) -> Poll<bool, ()>;
fn schedule(&self, task: &mut Task);
}
impl<T, E> SyncFuture for Inner<T, E>
where T: Send + 'static,
E: Send + 'static,
{
fn poll(&self, _: &mut Task) -> Poll<bool, ()> {
let state = self.state.lock().unwrap();
match *state {
Init { .. } => Poll::NotReady,
Cancelled => Poll::Ok(true),
_ => Poll::Ok(false),
}
}
fn schedule(&self, task: &mut Task) {
let mut state = self.state.lock().unwrap();
if state.in_flight() {
let handle = task.handle().clone();
state.set_cancellation_cb(Box::new(move || handle.notify()));
} else {
task.handle().notify();
}
}
}
impl<T, E> State<T, E> {
fn in_flight(&self) -> bool {
match *self {
Init { .. } => true,
_ => false,
}
}
/// Returns true if in a completed state.
fn is_complete(&self) -> bool {
match *self {
Completed(_) | Consumed => true,
_ => false,
}
}
fn set_consumer_cb(&mut self, cb: Callback) {
match *self {
Init { ref mut consumer, .. } => *consumer = Some(cb),
_ => panic!("unexpected state"),
}
}
fn set_cancellation_cb(&mut self, cb: Callback) {
match *self {
Init { ref mut cancellation, .. } => *cancellation = Some(cb),
_ => panic!("unexpected state"),
}
}
/// Sets the current state to Consumed and returns the original value
fn take(&mut self) -> State<T, E> {
mem::replace(self, State::Consumed)
}
}
trait FnBox: Send + 'static {
fn call_box(self: Box<Self>);
}
impl<F> FnBox for F
where F: FnOnce() + Send + 'static
{
fn call_box(self: Box<F>) {
(*self)()
}
}
#[cfg(test)]
mod test {
use super::*;
use futures::Future;
use std::sync::mpsc;
#[test]
fn test_complete_after_listen() {
let (c, val) = pair::<u32, ()>();
let (tx, rx) = mpsc::channel();
val.then(move |res| {
tx.send(res.unwrap()).unwrap();
res
}).forget();
c.complete(123);
assert_eq!(123, rx.recv().unwrap());
}
| {
self.inner.complete(Some(Err(err)), false);
} | identifier_body |
DissertationScript.py | try:
site = urlopen(el).read()
text = open("CongressBLAHfolder/"+agen+str(num)+a+str(reg3.groups()[0])+".txt","wb")
text.write(site)
except Exception as e:
print("This didn't work: "+str(e))
#pdf.write(bytes(site))
#print(len(li))
#This cleans the scraped data from gpo_scrape
def re_clean_written():
for subdir, dirs, files in os.walk("Congressional Hearings TXT/"):
for file in files:
print("Working on file...." + str(file))
f = open(os.path.join(subdir, file), "rb").read().decode('utf-8', 'ignore').encode('cp850',
'ignore').decode(
'cp850')
reg2 = re.compile('[JFMASOND][A-Za-z]+? \d{1,2}. \d{4}')
try:
date = re.findall(reg2, f)[0].capitalize()
date = datetime.datetime.strptime(date, '%B %d, %Y')
date = str(date.year) + "." + str(date.month) + "." + str(date.day)
print(date)
except Exception as e:
print("NO DATE in this file: " + file)
#This is the big line that I need to check: gets only the relevant stuff from each transcript
reg = re.compile(
'\n{1,3} {4}([A-Z][a-z]+\.? [A-Z][a-z]+(?: [A-Z][a-z]+)?\.{1} [A-Z][^\b]*?)\n{1,3} {4,}\[(?:Where|Add)')
newtext = re.findall(reg, f)
# print(newtext)
#Takes out prepared written statements, so there's just actual speech remaining
try:
newtext = re.sub(
'(\[(?:The opening|The (?:information)? follow|The prepared|Text of)[^\b]+?)(?=\n{1,3} {4}[A-Z][a-z]+\.? [A-Z][a-z]+(?: [A-Z][a-z]+)?\.)',
'', newtext[0])
newtext = re.sub(
'((?:O[Pp][Ee][Nn][Ii][Nn][Gg] |P[Rr][Ee][Pp][Aa][Rr][Ee][Dd] )?S[Tt][Aa][Tt][Ee][Mm][Ee][Nn][Tt][Ss]?[^\b]*?\n{2})',
'', newtext)
with open('Congressional Hearings TXT (clean NEW)/' + file[:-4] + '_' + date + '.txt',
'a') as fi:
fi.write(",".join(reg3) + "\n" + newtext)
except Exception as e:
print("ERROR IN SCRAPE: " + file + "\t" + str(e))
#After running re_clean_written, this parses the data out and creates folders for each speaker
def parse_by_speakerdate():
a = defaultdict(list)
for subdir, dirs, files in os.walk("Congressional Hearings TXT (clean)/"):
for file in files:
print("Working on file...." + str(file))
f = open(os.path.join(subdir, file), "rb").read().decode('utf-8', 'ignore')
date = file.split("_")[1][:-4]
# Load original files, so I can get the names of everyone
f2 = open("Congressional Hearings TXT/" + file.split("_")[0] + ".txt", "rb").read().decode()
# Code to get name list from beginning of each file on GPO.gov (need to make sure this gets everyone)
try:
reg3 = re.compile('(?: {4,}|\r?\n?)([A-Z]+\.? [A-Z]+\.?(?: [A-Z]+)?),')
# reg3 = re.compile(' {4,}([A-Z]+ [A-Z]+?),')
reg3 = re.findall(reg3, f2)
print(reg3)
except Exception as e:
print("SOME ERROR HERE WITH COLLECTING NAMES..." + str(e))
try:
newtext = re.split(
'\r\n\r?\n? {4,}(?=[A-Z][a-z]+\.? [A-Z][a-z]+(?: [A-Z][a-z]+| \[presiding\])?\.)', f)
# print(newtext)
print(len(newtext))
for line in newtext:
b = defaultdict(list)
name = line.split(".")[0]
# This corrects for the split on the period in Mr. or Mrs. (makes sure it gets their full name)
if len(name) < 4:
name = ".".join(line.split(".")[:2])
name = stringdist_list(name, reg3)
text = line.split(".")[1]
if len(text) < 15:
text = line.split(".", 2)[2]
if not os.path.exists('Congressional Hearings - People (new)/' + name + '/'):
os.makedirs('Congressional Hearings - People (new)/' + name + '/')
# Only download files if they are longer than 100 words (prevents need to use clean_people_dir_words in SVM Practice file)
if len(text.split(" ")) > 100:
with open('Congressional Hearings - People (new)/' + name + '/' + name + '_' + date + '.txt','a') as fi:
fi.write(text + "\n")
# print(text)
# b[date].append(text)
# a[name].append(b)
except Exception as e:
print("ERROR IN SCRAPE: " + file + "\t" + str(e))
# df_dict.tabulate()
# df_dict.plot()
# pickle.dump(df_dict,open("FDA Open Meetings Sites/Word Tokenized Dictionary.p","wb"))
#From the gpo.gov Congressional Directory, scrapes the txt file for each member of House/Senate going back to 105th Congress (1997-1998). Saves to GPO Biographies folder.
def gpo_scrape_bio():
#Pre-downloaded file that just lists state in one column and number of House representatives in the 2nd column
NumReps = pd.read_csv("Representatives by State.csv")
#Convert the csv to a dictionary for easier calling of values
repsdict = NumReps.set_index("State")["NumRep"].to_dict()
for state in NumReps.State:
for agen in ["H", "S"]:
if agen=="H":
Num = repsdict[state]
else:
Num = 2
for years in ["2016-02-12","2014-02-18","2011-12-01","2009-12-01","2008-08-01","2007-08-09","2006-09-01","2005-07-11","2004-08-01","2004-01-01","2003-11-01","2003-07-11",
"2002-10-01","2001-12-07","2000-10-01","2000-02-01","1999-06-15","1997-06-04"]:
for num in range(1,Num+1):
url = "https://www.gpo.gov/fdsys/pkg/CDIR-"+years+"/html/CDIR-"+years+"-"+state+"-"+agen+"-"+str(num)+".htm"
print(url)
try:
url = urlopen(url).read().decode()
text = open("GPO Biographies/"+agen+" "+state+" "+str(num)+" "+years+".txt","w")
text.write(url)
except Exception as e:
print("Number of representatives changed in "+state+" in"+years)
#From the files in GPO Biographies folder, pulls out the name, affiliation, education, and year of the txt files using regex (1262 people?)
def gpo_regex_get_name():
a = defaultdict(list)
for subdir,dirs,files in os.walk("GPO Biographies/"):
for file in files:
f = open(os.path.join(subdir,file),"rb").read().decode('utf-8','ignore')
name = re.compile(' {4}([A-Z\.]+? [^0-9]*?), ([A-Za-z]{4,})(?:,| |-|;)').findall(f)
year = re.compile('<title>.*?for the (.*?),').findall(f)
#reg2 = re.compile('education: ([\s\S]*?); [a-z ]* | for el in reg2:
print(el)
#print(el)
#li.append(el)
reg3 = re.search('hrg(\d*?)\/',el) | random_line_split |
|
DissertationScript.py | ("_")[1][:-4]
# Load original files, so I can get the names of everyone
f2 = open("Congressional Hearings TXT/" + file.split("_")[0] + ".txt", "rb").read().decode()
# Code to get name list from beginning of each file on GPO.gov (need to make sure this gets everyone)
try:
reg3 = re.compile('(?: {4,}|\r?\n?)([A-Z]+\.? [A-Z]+\.?(?: [A-Z]+)?),')
# reg3 = re.compile(' {4,}([A-Z]+ [A-Z]+?),')
reg3 = re.findall(reg3, f2)
print(reg3)
except Exception as e:
print("SOME ERROR HERE WITH COLLECTING NAMES..." + str(e))
try:
newtext = re.split(
'\r\n\r?\n? {4,}(?=[A-Z][a-z]+\.? [A-Z][a-z]+(?: [A-Z][a-z]+| \[presiding\])?\.)', f)
# print(newtext)
print(len(newtext))
for line in newtext:
b = defaultdict(list)
name = line.split(".")[0]
# This corrects for the split on the period in Mr. or Mrs. (makes sure it gets their full name)
if len(name) < 4:
name = ".".join(line.split(".")[:2])
name = stringdist_list(name, reg3)
text = line.split(".")[1]
if len(text) < 15:
text = line.split(".", 2)[2]
if not os.path.exists('Congressional Hearings - People (new)/' + name + '/'):
os.makedirs('Congressional Hearings - People (new)/' + name + '/')
# Only download files if they are longer than 100 words (prevents need to use clean_people_dir_words in SVM Practice file)
if len(text.split(" ")) > 100:
with open('Congressional Hearings - People (new)/' + name + '/' + name + '_' + date + '.txt','a') as fi:
fi.write(text + "\n")
# print(text)
# b[date].append(text)
# a[name].append(b)
except Exception as e:
print("ERROR IN SCRAPE: " + file + "\t" + str(e))
# df_dict.tabulate()
# df_dict.plot()
# pickle.dump(df_dict,open("FDA Open Meetings Sites/Word Tokenized Dictionary.p","wb"))
#From the gpo.gov Congressional Directory, scrapes the txt file for each member of House/Senate going back to 105th Congress (1997-1998). Saves to GPO Biographies folder.
def gpo_scrape_bio():
#Pre-downloaded file that just lists state in one column and number of House representatives in the 2nd column
NumReps = pd.read_csv("Representatives by State.csv")
#Convert the csv to a dictionary for easier calling of values
repsdict = NumReps.set_index("State")["NumRep"].to_dict()
for state in NumReps.State:
for agen in ["H", "S"]:
if agen=="H":
Num = repsdict[state]
else:
Num = 2
for years in ["2016-02-12","2014-02-18","2011-12-01","2009-12-01","2008-08-01","2007-08-09","2006-09-01","2005-07-11","2004-08-01","2004-01-01","2003-11-01","2003-07-11",
"2002-10-01","2001-12-07","2000-10-01","2000-02-01","1999-06-15","1997-06-04"]:
for num in range(1,Num+1):
url = "https://www.gpo.gov/fdsys/pkg/CDIR-"+years+"/html/CDIR-"+years+"-"+state+"-"+agen+"-"+str(num)+".htm"
print(url)
try:
url = urlopen(url).read().decode()
text = open("GPO Biographies/"+agen+" "+state+" "+str(num)+" "+years+".txt","w")
text.write(url)
except Exception as e:
print("Number of representatives changed in "+state+" in"+years)
#From the files in GPO Biographies folder, pulls out the name, affiliation, education, and year of the txt files using regex (1262 people?)
def gpo_regex_get_name():
a = defaultdict(list)
for subdir,dirs,files in os.walk("GPO Biographies/"):
for file in files:
f = open(os.path.join(subdir,file),"rb").read().decode('utf-8','ignore')
name = re.compile(' {4}([A-Z\.]+? [^0-9]*?), ([A-Za-z]{4,})(?:,| |-|;)').findall(f)
year = re.compile('<title>.*?for the (.*?),').findall(f)
#reg2 = re.compile('education: ([\s\S]*?); [a-z ]*?: | ')
f2 = re.sub("\r\n","",f)
edu = re.compile('((?:[A-Z]\.){2,3},[\s\S]*?);').findall(f2)
print(name, file, year, edu)
try:
if name[0][0] not in a:
a[name[0][0]].append(name[0][1]) #name[1] is political affiliation because the txt file was organized in such a way
except Exception as e:
print("Problem with name in file: "+file)
try:
if file[0]=="H":
a[name[0][0]].append(year[0] + " - House")
if file[0] == "S":
a[name[0][0]].append(year[0] + " - Senate")
except Exception as e:
print("Problem with year: "+file)
try:
a[name[0][0]].extend(edu)
except Exception as e:
print("Problem with education: " + file)
print(a)
#Suggestion to use json for defaultdict instead of csv (http://codereview.stackexchange.com/questions/30741/writing-defaultdict-to-csv-file)
json.dump(a,open('GPO Biographies - JSON','w'))
#pd.DataFrame.from_dict(a, orient='index').to_csv("GPO Biographies - Education1.csv")
#Takes a list of names, searches them on C-SPAN, and extracts the website associated with them - website includes PersonID
def | ():
###Create files with each Senator and their full website, including PersonID
#Load GPO Biographies - JSON and extract the key, which is names of all Congresspeople going back to 1997
names = json.load(open('GPO Biographies - JSON'))
names = list(names.keys())
#This gets rid of middle names and middle initials, so the search is better on C-SPAN
names = [name.split(" ")[0].title() + " " + name.split(" ")[-1].title() for name in names]
# Log in with Selenium
driver = webdriver.Firefox()
driver.get("http://www.c-span.org")
login = driver.find_element_by_class_name("my-cspan")
login.click()
time.sleep(1)
user = driver.find_elements_by_id("login")[1]
user.clear()
user.send_keys(username)
pw = driver.find_element_by_id("password")
pw.clear()
pw.send_keys(pw)
clicklogin = driver.find_element_by_id("submit-login")
clicklogin.click()
errorlog = []
for name in names:
try:
#Have to wait a bit of time because the website gets screwy and can't find the dropdown menu sometimes
time.sleep(10)
openfilter = driver.find_element_by_class_name('selected')
# openfilter = driver.find_element_by_xpath("//form[@class='search']/fieldset/div/span[@class='carat icon-chevron-down']")
openfilter.click()
peoplefilter = driver.find_element_by_xpath('//div[@style]/ul/li[4]')
time.sleep(0.5)
peoplefilter.click()
namesearch = driver.find_element_by_id('global-search')
namesearch.clear()
namesearch.send_keys(name)
clicker = driver.find_element_by_class_name('icon-search')
clicker.click()
time.sleep(1.5)
search = driver.find_elements_by_class_name('thumb')[0]
search.click()
source = driver.page_source
ID = re.compile('personid\[\]=(.*?)"').findall(source)
print(name,names.index(name), | cspan_selenium_getsite | identifier_name |
DissertationScript.py | outer function to find the ID
if difflib.get_close_matches(name.title(), file_to_list_upper("C-SPAN PersonID (simplified).txt"),cutoff=.8):
print(difflib.get_close_matches(name.title(), file_to_list_upper("C-SPAN PersonID (simplified).txt"),cutoff=.8))
ID = dict_cspan_id(difflib.get_close_matches(name.title(), file_to_list_upper("C-SPAN PersonID (simplified).txt"),cutoff=.8)[0])
#ID = dict_cspan_id(difflib.get_close_matches(name.title(), file_to_list_upper("C-SPAN PersonID (simplified test).txt")))
print(name,ID)
#Several functions now add important info to the C-SPAN PersonID file - the below adds the dates each person spoke based on the transcripts
def add_dates():
with open("C-SPAN PersonID.txt",encoding="Latin1") as f:
f = f.read().splitlines()
#f = [item.split("\t")[0] for item in f]
#print(os.listdir("Congressional Hearings - People (new)"))
for item in f:
print(item)
#This first has to capitalize just the first letter of the transcript names, since they are all caps beforehand
#and, thus, can't match
transcriptnames = [name.title() for name in os.listdir("/media/jemme/New Volume/Congressional Hearings - People (new)")]
transcriptnamesmatch = difflib.get_close_matches(item,transcriptnames)
if transcriptnamesmatch:
print(transcriptnamesmatch)
#Turn the matched name back into all caps after it matches, so that it can find the actual transcript file
try:
dates = os.listdir("/media/jemme/New Volume/Congressional Hearings - People (new)/"+transcriptnamesmatch[0].upper())
except Exception as e:
print(item+" doesn't WORKKKKK!")
for date in dates:
date = date.split("_")[1][:-4].replace(".","-")
with open("C-SPAN PersonID and File Dates.txt","a") as outfile:
outfile.write(item+"\t"+transcriptnamesmatch[0]+"\t"+date+"\n")
#This is just a helper function used in add_date_month below - it converts dates into the proper format
def set_date(date):
date = datetime.datetime.strptime(date,"%Y-%m-%d")
date = datetime.datetime.strftime(date, "%Y-%m-%d")
return(date)
#Because there weren't corresponding videos for the specific dates in the Congressional Record transcripts,
#this just makes it so you can search a person on C-SPAN for that whole month, not just a specific day.
def add_date_month():
with open("C-SPAN PersonID and File Dates.txt") as f:
f = f.read().splitlines()
for item in f:
name = item.split("\t")[0]
ID = item.split("\t")[1]
nameinfile = item.split("\t")[2]
try:
date = item.split("\t")[3]
datebeg = re.sub("-\d{1,2}$", "-01", date)
datebeg = set_date(datebeg)
if date.split("-")[1] in ["9", "4", "6", "11"]:
dateend = re.sub("-\d{1,2}$", "-30", date)
dateend = set_date(dateend)
elif date.split("-")[1] in ["1", "3", "5", "7", "8", "10", "12"]:
dateend = re.sub("-\d{1,2}$", "-31", date)
dateend = set_date(dateend)
elif date.split("-")[1] == "2":
dateend = re.sub("-\d{1,2}$", "-28", date)
dateend = set_date(dateend)
with open("C-SPAN PersonID and File Dates (entire month search)1.txt", "a") as outfile:
outfile.write(item + "\t" + datebeg + "\t" + dateend + "\n")
except Exception as e:
print("DATE NOT CORRECT: ",date)
#This goes into C-SPAN and adds in the times that each person spoke in each video, so I don't have to download the entire thing
def get_vid():
driver = webdriver.Firefox()
with open("C-SPAN PersonID and File Dates (entire month search).txt") as f:
f = f.read().splitlines()
for item in f:
ID = item.split("\t")[1]
name = item.split("\t")[2]
date = item.split("\t")[3]
datebeg = item.split("\t")[4]
dateend = item.split("\t")[5]
#Use this code below to get video corresponding to each PersonID and date
driver.get("http://www.c-span.org/search/?searchtype=Videos&personid[]=" + str(ID) + "&sdate=" + str(datebeg) + "&edate=" + str(dateend))
try:
video = driver.find_elements_by_class_name("thumb")[0]
video.click()
time.sleep(6)
html = driver.execute_script("return document.getElementsByTagName('html')[0].innerHTML")
reg = re.compile('<th>[\s\S]+?time-(.*?)"[\s\S]+?<strong>(.*?)<')
reg = re.findall(reg,html)
times = []
i = 0
while i < len(reg):
if reg[i][1].split(" ")[-1].title() in name:
times.append((reg[i][0],reg[i+1][0]))
i+=1
#reg = [tup for tup in reg if tup[1].split(" ")[-1].title() in name]
print()
print(driver.current_url,"\n",reg,"\n",times,"\n",name, "\n", ID, "\n", date)
with open("C-SPAN PersonID and File Dates (entire month search with vid website and time)1.txt","a") as outfile:
if times:
for tup in times:
outfile.write(item+"\t"+driver.current_url+"\t"+tup[0]+"\t"+tup[1]+"\t"+str(f.index(item))+"\n")
except Exception as e:
print(str(e))
# print("There is no video for "+str(name)+"on "+str(date)+".")
#This actually clicks on the video - make sure rtmpsrv is running BEFORE you even click the thumb link to
#the video, otherwise it won't work. So, essentially, go to c-span.com, then run ./rtmpsuckredirect.sh
#from the command line. Then start rtmpsrv. Rtmpsrv has to be running before you click the video thumbnail,
#not just before you click play.
flash = driver.find_element_by_id("flashPlayer")
time.sleep(5)
###Below code is not working until Selenium gets updated (https://github.com/SeleniumHQ/selenium/issues/2285)
ActionChains(driver).move_to_element(flash).click().perform()
###Trying javascript clicking
#driver.execute_script("arguments[0].click();", flash)
time.sleep(8)
#This cleans the final long list of rtmpdump commands created after running get_vid
#Then, run this file in the Linux command prompt to get all the videos
def rtmp_file():
with open("C-SPAN PersonID and File Dates (entire month search with vid website and time).txt") as f:
f = f.read()
f = re.sub("\nDuplicate request, skipping\.\n\n","\t",f)
f = f.splitlines()
f = [line for line in f if line.split(" ")[0].istitle()]
for line in reversed(f):
| name = line.split("\t")[0].replace(" ","")
date = line.split("\t")[3].split("-")[:-1]
date = "-".join(date)
starttime = line.split("\t")[7]
if len(line.split("\t"))>10:
rtmp = line.split("\t")[10].split(" -o ")[0] + " -o " +name + date + "_" + starttime + ".flv"
with open("CSpanVideos/RTMPdump Cspan Commands.sh", "a") as outfile:
outfile.write(rtmp + " -A " + line.split("\t")[7] + " -B " + line.split("\t")[8] + "\n")
else:
with open("CSpanVideos/RTMPdump Cspan Commands.sh", "a") as outfile:
outfile.write(rtmp[:-4] + line.split("\t")[7] + ".flv" + " -A " + line.split("\t")[7] + " -B " + line.split("\t")[8] + "\n")
#rtmp = line.split("\t")[10][:-4]+line.split("\t")[7]+".flv"
#print(line,"\n",rtmp, " -A ", line.split("\t")[7], " -B ", line.split("\t")[8])
# if len(line.split("\t"))>10:
# print(line.split("\t"))
# print(line.split("\t")) | conditional_block |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.