Catholic Church Investigates Two Missionary Nuns Returning Pregnant From Africa
by Emily BrownThe Catholic Church has launched an investigation after two nuns became pregnant while carrying out missionary work in Africa.
The two women have not been named but they are both reported to originally be from Africa and now belong to two different orders in Sicily.
The pair were posted to their home continent as part of their charity mission, but upon returning home they discovered they were pregnant, despite having taken a vow of chastity.
One of the women, aged 34, discovered her pregnancy when she went to hospital with stomach pain, Italian news agency ANSA reports.
She is believed to belong to a convent in Militello, Sicily, but the 34-year-old has now moved to Palermo to prepare for the birth of her baby. It is thought she may choose to give up her monastic life and focus on raising her child.
Salvatore Riotta, the mayor of Militello, said the news of the nun’s pregnancy left the village ‘shocked,’ adding it ‘should have been kept quiet.’
The second nun was a mother superior, which is a senior monastic in charge of a convent or order. She had been based at an institute which helps ‘fallen women and their children,’ but reportedly returned to her home country after learning she was carrying a child.
Earlier this year, Pope Francis admitted many nuns had been sexually abused, calling it a ‘serious, grave problem.’
Speaking on his papal plane, he said:
We have to fight this, and also the service of religious sisters: Please: Service yes, servitude no.
In May this year, the pope issued a new law to force priests and nuns to report sexual abuse and its cover-up to church authorities.
As well as taking a vow of chastity, Catholic nuns profess the perpetual ‘solemn vows’ to live a life according to the evangelical counsels of poverty and obedience. Pope Francis vowed to combat the abuse of nuns, urging them to say no when other clergy members try to use them as maids.
A church source in Rome, where the Catholic Church has its headquarters, explained the news of the two nuns had caused ‘consternation.’

An investigation has been launched. They both breached strict rules of chastity but the welfare of their children is uppermost.
The church source said the most likely outcome of the situation is that both women will leave their religious service.
Emily Brown first began delivering important news stories aged just 13, when she launched her career with a paper round. She graduated with a BA Hons in English Language in the Media from Lancaster University, and went on to become a freelance writer and blogger. Emily contributed to The Sunday Times Travel Magazine and Student Problems before becoming a journalist at UNILAD, where she works on breaking news as well as longer form features.


Tourists spend $5.1B on food, beverages in first 9 months
by DAILY SABAH WITH AAForeign tourists who visited Turkey between January-September this year have spent $5.1 billion on food and beverages, according to official data.
According to data from the Turkish Statistical Institute (TurkStat), within the first nine months of the year, some 40 million people, including around 4.6 million Turkish citizens living abroad, visited Turkey.
Over this period, Turkey's tourism income topped over $26.6 billion, up 16.15% from $22.9 billion in the same period last year.
The personal expenditure of tourists was estimated at $19.6 billion, with package tour expenditure alone accounting for $7 billion. Food and beverages made up by far the largest items visitors spent their money on, at a whopping $5 billion, followed by other goods and services at $4.9 billion and accommodation at $2.8 billion.
Foreign visitors and Turkish citizens residing abroad spent $793.5 million on healthcare. The amount spent by tourists on sports, education and cultural activities exceeded $319 million.
Tourists spent $3 billion on clothing and shoes and $1 billion on souvenirs. Having allocated $803 million for other expenditures, tourists paid $96.7 million to purchase carpets and rugs from Turkey.


rpsftmPlus.Rd
The package extends the rpsftm package with some useful default reports and functions to facilitate sensitivity analysis. Covering descriptive, diagnostic and reporting aspects. All the functions are designed to take an rpsftm object (see rpstm::rpsftm() for details on creation) as an argument. The descriptive functions do not actually require an rspft model to be fit but rather just use it as a convenient way to store information about switching alongside survival.
The following functions are then used for descriptive analysis: * ggexposure: ggexposure(x). This function plots a single line per patient showing exposure prior to event or censoring. * ggatrisk: ggatrisk(x). This function plots at risk on treatments. * rpsftm.atrisk: rpstm.atrisk(x, eval.times). This function returns n and * ggdiscount: ggdiscount(x). This function plots hypothetical results from removing switch treatment from control arm.
The following functions are used for diagnostics: * ggpsi: ggpsi(x). This function plots psi vs Z(psi) to assess a unique solution. * gglatent: gglatent(x). This function plots the latent survival time to assess if balanced.
The following functions are used for reporting: * rpsftm.coxph: rpsftm.coxph(x). This function compares observed experimental and latent control arms with a cox model. It inflates the variance to account for the g-estimation step and correct the CI limits.
The following functions are used for sensitivity analysis of the common treatment effect: * rpsftm.refit: rpsftm.refit(x, k). This function refits an rpsftm model varying the treat_modifier parameter. Allowing sensitivities to the common treatment effect assumption.
The following functions are utilities that may have further use elsewhere and do not take an rpsftm() object as a parameter: * as.data.frame.survfit: as.data.frame.survfit(x). For a given survfit() object returns KM estimates and strata in a dataframe.


FoodieJournal
Hi {{user.username || usrnm}}!
My Account
Logout
Login
Email or Username
Password
Login


vs
000,000
000,000
LINES
000
LV
00
TRT
---
PLAYER 1
ŒŒŒ
DRT
99
000,000
000,000
LINES
000
LV
00
TRT
---
PLAYER 2
ŒŒŒ
DRT
99


Summary
The Lightweight Directory Access Protocol (LDAP) is used to store information about users, hosts, and many other objects. LDAP injection is a server side attack, which could allow sensitive information about users and hosts represented in an LDAP structure to be disclosed, modified, or inserted. This is done by manipulating input parameters afterwards passed to internal search, add, and modify functions.
A web application could use LDAP in order to let users authenticate or search other users' information inside a corporate structure. The goal of LDAP injection attacks is to inject LDAP search filters metacharacters in a query which will be executed by the application.
[Rfc2254] defines a grammar on how to build a search filter on LDAPv3 and extends [Rfc1960] (LDAPv2).
An LDAP search filter is constructed in Polish notation, also known as [prefix notation].
This means that a pseudo code condition on a search filter like this:
find("cn=John & userPassword=mypass")
will be represented as:
find("(&(cn=John)(userPassword=mypass))")
Boolean conditions and group aggregations on an LDAP search filter could be applied by using the following metacharacters:
Metachar Meaning
& Boolean AND
| Boolean OR
! Boolean NOT
= Equals
~= Approx
>= Greater than
<= Less than
* Any character
() Grouping parenthesis
More complete examples on how to build a search filter can be found in the related RFC.
A successful exploitation of an LDAP injection vulnerability could allow the tester to:
- Access unauthorized content
- Evade application restrictions
- Gather unauthorized informations
- Add or modify Objects inside LDAP tree structure.
How to Test Example 1: Search Filters
Let's suppose we have a web application using a search filter like the following one:
searchfilter="(cn="+user+")"
which is instantiated by an HTTP request like this:
http://www.example.com/ldapsearch?user=John
If the value 'John' is replaced with a '*', by sending the request:
http://www.example.com/ldapsearch?user=*
the filter will look like:
searchfilter="(cn=*)"
which matches every object with a 'cn' attribute equals to anything.
If the application is vulnerable to LDAP injection, it will display some or all of the users' attributes, depending on the application's execution flow and the permissions of the LDAP connected user.
A tester could use a trial-and-error approach, by inserting in the parameter '(', '|', '&', '*' and the other characters, in order to check the application for errors.
Example 2: Login
If a web application uses LDAP to check user credentials during the login process and it is vulnerable to LDAP injection, it is possible to bypass the authentication check by injecting an always true LDAP query (in a similar way to SQL and XPATH injection ).
Let's suppose a web application uses a filter to match LDAP user/password pair.
searchlogin= "(&(uid="+user+")(userPassword={MD5}"+base64(pack("H*",md5(pass)))+"))";
By using the following values:
user=*)(uid=*))(|(uid=* pass=password
the search filter will results in:
searchlogin="(&(uid=*)(uid=*))(|(uid=*)(userPassword={MD5}X03MO1qnZdYdgyfeuILPmQ==))";
which is correct and always true. This way, the tester will gain logged-in status as the first user in LDAP tree.
Tools
Softerra LDAP Browser - http://www.ldapadministrator.com/
References
OWASP References
LDAP Injection Prevention Cheat Sheet
Whitepapers
Sacha Faust: "LDAP Injection: Are Your Applications Vulnerable?" - http://www.networkdls.com/articles/ldapinjection.pdf
Bruce Greenblatt: "LDAP Overview" - http://www.directory-applications.com/ldap3_files/frame.htm
IBM paper: "Understanding LDAP" - http://www.redbooks.ibm.com/redbooks/SG244986.html
RFC 1960: "A String Representation of LDAP Search Filters" - http://www.ietf.org/rfc/rfc1960.txt
"LDAP injection" - http://www.blackhat.com/presentations/bh-europe-08/Alonso-Parada/Whitepaper/bh-eu-08-alonso-parada-WP.pdf


This question is a real motivator for me because I begin to see the high cost of doing nothing. I want people to really consider just what the future could be and not gloss over this one. It helps everyone to be more committed to resolving the issue.
Rephrase what you heard the person say to their satisfaction. If they are not satisfied that you understand, allow them to rephrase their statement, don’t try to guess, but be patient until they can verbalize their own thoughts. A right answer is like a kiss on the lips, and in this case it is a answer that shows you understand them.


X A film review by Christopher Null Copyright 2000 filmcritic.com filmcritic.com
An old Japanese Anime pic gets new life (and English dialogue) in time for its rerelease in the states. Anime fans will no doubt be thrilled by the movie, but many of my fellow moviegoers will likely echo my overall opinion about X: It just doesn't make any sense.
>From what I can put together, the story is this. The world is ending, and one man must destroy one of the Dragons that are warring over the world. Should he destroy the Dragons of the Earth or the Dragons of the Heaven?  Destroying Heaven will keep the earth intact. Two buxom sisters predict (and seek) opposite outcomes. And our hero is wooed by each sister.
Lots of flying around and stabbing people with swords and energy blasts ensues, and Tokyo is ground zero for their fight. Much of Tokyo gets destroyed anyway during the epic battle (buildings collapse, the subway is demolished, etc.), but oddly, no one seems to mind much. Near the end of the film, there's very little evidence of any battle at all.
X contains a few moments of haunting beauty, separated by long, drawn-out scenes of exposition that only confuse the plot even further. The animation is spotty at best. It seems much effort has gone into making a few choice scenes perfect, which the rest languishes in lifeless backdrops upon which to kill the supporting cast in fountains of blood.
Hardly groundbreaking.

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Fetch a file to change this text.
1Fetch a file to change this text.
2Fetch a file to change this text.
3Fetch a file to change this text.


LogIsland is an event processing framework based on Kafka and Spark. The main goal of this Open Source platform is to abstract the level of complexity of complex event processing at scale. Of course many people start with an ELK stack, which is really great but not enough to elaborate a really complete system monitoring tool. So with LogIsland, you’ll move the log processing burden to a powerful distributed stack.
Kafka acts a the distributed message queue middleware while Spark is the core of the distributed processing. LogIsland glue those technologies to simplify log complex event processing at scale.
The main goal of LogIsland framework is to provide tools to automatically extract valuable knowledge from historical log data. To do so we need two different kind of processing over our technical stack :
What we know about Log/Event properties :
LogIsland is an event mining scalable platform designed to handle a high throughput of events.
Here is an example of a typical event mining pipeline.
The Malware Capture Facility Project is an effort from the Czech Technical University ATG Group for capturing, analyzing and publishing real and long-lived malware traffic.
http://mcfp.weebly.com/analysis
The goals of the project are:
The topology used in the project was designed to be as simple as possible. It uses VirtualBox to execute Windows virtual machines on Linux Hosts. The only two restrictions applied to the traffic are a bandwidth control to prevent DDoS and a redirection of all the SMTP traffic to prevent SPAM sending. More details can be found on the Topology page.
The complete dataset is published and can be downloaded from the Dataset menu. The published files include:
If you find this project or the dataset useful please consider collaborating with it. Among the things that need more attention are a better labeling, more screenshots of the traffic and information about which malware it really is. Feel free to send an email to<EMAIL_ADDRESS>This dataset is directly feeding the CTU efforts for modelling and detecting botnets behavior on the network. As such, the Botnet Analysis blog page includes some analysis of their behaviors.
browse all public datasets https://mcfp.felk.cvut.cz/publicDatasets/
The CTU-13 is a dataset of botnet traffic that was captured in the CTU University, Czech Republic, in 2011. The goal of the dataset was to have a large capture of real botnet traffic mixed with normal traffic and background traffic. The CTU-13 dataset consists in thirteen captures (called scenarios) of different botnet samples. On each scenario we executed a specific malware, which used several protocols and performed different actions.
Table 2 shows the characteristics of the botnet scenarios.
Each scenario was captured in a pcap file that contains all the packets of the three types of traffic. These pcap files were processed to obtain other type of information, such as NetFlows, WebLogs, etc. The first analysis of the CTU-13 dataset, that was described and published in the paper “An empirical comparison of botnet detection methods” (see Citation below) used unidirectional NetFlows to represent the traffic and to assign the labels. These unidirectional NetFlows should not be used because they were outperformed by our second analysis of the dataset, which used bidirectional NetFlows. The bidirectional NetFlows have several advantages over the directional ones. First, they solve the issue of differentiating between the client and the server, second they include more information and third they include much more detailed labels. The second analysis of the dataset with the bidirectional NetFlows is the one published here.
The relationship between the duration of the scenario, the number of packets, the number of NetFlows and the size of the pcap file is shown in Table 3. This Table also shows the malware used to create the capture, and the number of infected computers on each scenario.
Table 3. Amount of data on each botnet scenario
The distinctive characteristic of the CTU-13 dataset is that we manually analyzed and label each scenario. The labeling process was done inside the NetFlows files. Table 4 shows the relationship between the number of labels for the Background, Botnet, C&C Channels and Normal on each scenario.
!(Table 4. Distribution of labels in the NetFlows for each scenario in the dataset.
wget https://mcfp.felk.cvut.cz/publicDatasets/CTU-Malware-Capture-Botnet-42/detailed-bidirectional-flow-labels/capture20110810.binetflow
Please note that the labels of the flows generated by the malware start with “From-Botnet”. The labels “To-Botnet” are flows sent to the botnet by unknown computers, so they should not be considered malicious perse. Also for the normal computers, the counts are for the labels “From-Normal”. The labels “To-Normal” are flows sent to the botnet by unknown computers, so they should not be considered malicious perse.
Wed ago 10 15:58:00 CEST 2011
Today we capture the neris bot along with the packets of the whole CTU department. We used an XP virtualbox machine with the <IP_ADDRESS> public ip address. The first hour of capture was only background and latter we run the malware until 5 minutes before ending. We limited the bandwith of the experiment to 20kbps in the output of the bot.
The bot sent spam, connected to an HTTP CC, and use HTTP to do some ClickFraud.
LogIsland is packaged as a Docker container that you can build yourself or pull from Docker Hub. The docker container is built from a Centos 6.4 image with the following tools enabled (among others)
Let’s setup the env by
Pull the image from Docker Repository (it may take some time)
docker pull hurence/logisland-jdev
You should be aware that this Docker container is quite eager in RAM and will need at least 8G of memory to run smoothly.

If you have your own Spark and Kafka cluster, you can download the latest release and unzip on an edge node.
Retrieve one part of the dataset (should be already done in Docker image)
cd /tmp;
wget https://github.com/Hurence/logisland-flow-analytics-ml-jobs/releases/download/v0.1/capture20110810.binetflow.tgz;
tar xzf capture20110810.binetflow.tgz;
rm -f capture20110810.binetflow.tgz
init repository (should be already done in Docker image)
cd /usr/local
git clone https://github.com/Hurence/logisland-flow-analytics-ml-jobs.git;
mvn compile assembly:single
cp target/logisland-flow-analytics-ml-jobs-0.10.1.jar /usr/local/logisland/lib
A logisland job define some stream processing pipeline inside a simple yaml configuration file.
The first job can be found in conf/index-binetflow.yml configuration file defines a stream processing job for indexing events to elasticsearch.
The first section configures the Spark engine (we will use a KafkaStreamProcessingEngine). A few notes about the most important parameters :
Here is the beginning of the conf file :
version: 0.10
documentation: LogIsland analytics main config file. Put here every engine or component config
engine:
component: com.hurence.logisland.engine.spark.KafkaStreamProcessingEngine
type: engine
documentation: Index some apache logs with logisland
configuration:
spark.app.name: IndexBiNetflowDemo
spark.master: local[*]
spark.driver.memory: 1G
spark.driver.cores: 1
spark.executor.memory: 1G
spark.executor.instances: 4
spark.executor.cores: 2
spark.task.maxFailures: 8
spark.serializer: org.apache.spark.serializer.KryoSerializer
spark.streaming.batchDuration: 10000
spark.streaming.backpressure.enabled: false
spark.streaming.unpersist: false
spark.streaming.blockInterval: 500
spark.streaming.kafka.maxRatePerPartition: 3000
spark.streaming.timeout: -1
spark.streaming.unpersist: false
spark.streaming.kafka.maxRetries: 30
spark.streaming.ui.retainedBatches: 200
spark.streaming.receiver.writeAheadLog.enable: false
spark.ui.port: 4050
the following part of the configuration defines an Elasticsearch service that will be used later in the BulkAddElasticsearch processor. We define here elasticsearch hosts: sandbox:9300, the cluster.name: elasticsearch and the batch.size: 5000.
controllerServiceConfigurations:
- controllerService: elasticsearch_service
component: com.hurence.logisland.service.elasticsearch.Elasticsearch_5_4_0_ClientService
type: service
documentation: elasticsearch 5.4.0 service implementation
configuration:
hosts: sandbox:9300
cluster.name: elasticsearch
batch.size: 5000
The next part defines the stream itself which is made of 3 main topics list : one for input records, one for output records and one for errors. Each of them having a serialization class. Please note that here kafka.input.topics.serializer is set to com.hurence.logisland.serializer.KryoSerializer because the input topic binetflow_events contains Kryo serialized records that will be produced by another job.
streamConfigurations:
- stream: indexing_stream
component: com.hurence.logisland.stream.spark.KafkaRecordStreamParallelProcessing
type: stream
documentation: a processor that links
configuration:
kafka.input.topics: binetflow_events
kafka.output.topics: none
kafka.error.topics: _errors
kafka.input.topics.serializer: com.hurence.logisland.serializer.KryoSerializer
kafka.output.topics.serializer: none
kafka.error.topics.serializer: com.hurence.logisland.serializer.JsonSerializer
kafka.metadata.broker.list: sandbox:9092
kafka.zookeeper.quorum: sandbox:2181
kafka.topic.autoCreate: true
kafka.topic.default.partitions: 8
kafka.topic.default.replicationFactor: 1
The final part of the strem configuration is the pipeline of Processor that will process the incoming Records. Here we simply use a BulkAddElasticsearch which will send incoming Records to Elasticsearch via the injected elasticsearch.client.service. Note that we provide both default.index: ctu-13 and default.type: bi_netflow for elasticsearch documents but these settings can be overided by come fields in the Record itself, es.index.field: search_index and es.type.field: record_type.
processorConfigurations:
- processor: es_publisher
component: com.hurence.logisland.processor.elasticsearch.BulkAddElasticsearch
type: processor
documentation: A processor that pushes Bro events into ES
configuration:
elasticsearch.client.service: elasticsearch_service
default.index: ctu-13
default.type: bi_netflow
timebased.index: no
es.index.field: search_index
es.type.field: record_type
The second job can be found in conf/parse-binetflow.yml configuration file defines a stream processing job to parse incoming netflow records.
After Engine definition the Stream says that Records will be read from kafka.input.topics: binetflow_raw, processed and sent to kafka.output.topics: binetflow_events
streamConfigurations:
- stream: parsing_stream
component: com.hurence.logisland.stream.spark.KafkaRecordStreamParallelProcessing
type: stream
documentation: a processor that links
configuration:
kafka.input.topics: binetflow_raw
kafka.output.topics: binetflow_events
kafka.error.topics: _errors
kafka.input.topics.serializer: none
kafka.output.topics.serializer: com.hurence.logisland.serializer.KryoSerializer
kafka.error.topics.serializer: com.hurence.logisland.serializer.JsonSerializer
kafka.metadata.broker.list: sandbox:9092
kafka.zookeeper.quorum: sandbox:2181
kafka.topic.autoCreate: true
kafka.topic.default.partitions: 8
kafka.topic.default.replicationFactor: 1
kafka.message.key.field: record_id
processorConfigurations:
The pipeline of processor will start the processing chain by a SplitText regexp processor which one will split all incoming lines accordingly to value.regex field, each matching group identified by the value.fields parameter, producing the following record from the line above 2011/08/10 15:54:07.366830,0.002618,udp,<IP_ADDRESS>,10520, <->,<IP_ADDRESS>,13363,CON,0,0,2,520,460,flow=Background-UDP-Established
{
"@timestamp": "2011-08-10T13:54:07Z",
"bytes_in": 460,
"bytes_out": 520,
"dest_ip": "<IP_ADDRESS>",
"dest_port": "13363",
"dest_tos": 0,
"direction": " <->",
"duration": 0.002618,
"label": "Background-UDP-Established",
"packets_out": 2,
"protocol": "udp",
"record_id": "1312984447366-<IP_ADDRESS>-<IP_ADDRESS>",
"record_raw_value": "2011/08/10 15:54:07.366830,0.002618,udp,<IP_ADDRESS>,10520, <->,<IP_ADDRESS>,13363,CON,0,0,2,520,460,flow=Background-UDP-Established",
"record_time":<PHONE_NUMBER>366,
"record_type": "bi_netflow",
"src_ip": "<IP_ADDRESS>",
"src_port": "10520",
"src_tos": 0,
"state": "CON",
"timestamp": "2011/08/10 15:54:07.366830"
}
here is the conf :
- processor: bi_netflow_parser
component: com.hurence.logisland.processor.SplitText
type: parser
documentation: a parser that produce events from bi-directionnal netflow logs
configuration:
record.type: bi_netflow
value.regex: (\d{4}\/\d{2}\/\d{2}\s\d{1,2}:\d{1,2}:\d{1,2}\.\d{0,6}),([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,flow=([^,]+)
value.fields: timestamp,duration,protocol,src_ip,src_port,direction,dest_ip,dest_port,state,src_tos,dest_tos,packets_out,bytes_out,bytes_in,label
convert | them to the desired types with ConvertFieldsType
- processor: field_types_converter
component: com.hurence.logisland.processor.ConvertFieldsType
type: processor
documentation: convert some field to a given type
configuration:
bytes_in: long
bytes_out: long
packets_out: long
duration: float
src_tos: int
dest_tos: int
The date of the Netflow file is converted with a custom Java Processor UpdateBiNetflowDate
- processor: date_updater
component: com.hurence.logisland.processor.UpdateBiNetflowDate
type: processor
documentation: compute record_time
Here is the java code of the date updater. this component is built in an external jar module which has to be copied into $LOGISLAND_HOME/lib folder
package com.hurence.logisland.processor;
import com.hurence.logisland.annotation.documentation.CapabilityDescription;
import com.hurence.logisland.annotation.documentation.Tags;
import com.hurence.logisland.component.PropertyDescriptor;
import com.hurence.logisland.logging.ComponentLog;
import com.hurence.logisland.logging.StandardComponentLogger;
import com.hurence.logisland.record.FieldDictionary;
import com.hurence.logisland.record.FieldType;
import com.hurence.logisland.record.Record;
import java.text.SimpleDateFormat;
import java.util.*;
@Tags({"record", "fields", "post-process", "binetflow", "date"})
@CapabilityDescription("Post processing step to update a dte field in a custom way")
public class UpdateBiNetflowDate extends AbstractProcessor {
private final ComponentLog logger = new StandardComponentLogger("UpdateBiNetflowDate", this);
@Override
public Collection<Record> process(ProcessContext context, Collection<Record> records) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.S");
sdf.setTimeZone(TimeZone.getTimeZone("GMT+1"));
for (Record outputRecord : records) {
try {
String eventTimeString = outputRecord.getField("timestamp").asString();
Date eventDate = sdf.parse(eventTimeString.substring(0, eventTimeString.length() - 3));
if (eventDate != null) {
outputRecord.setField(FieldDictionary.RECORD_TIME, FieldType.LONG, eventDate.getTime() - 60 * 60 * 1000);
}
} catch (Exception e) {
String error = "error parsing in record: " + outputRecord + ", " + e.toString();
outputRecord.addError("unable to parse date", logger, error);
}
}
return records;
}
@Override
public List<PropertyDescriptor> getSupportedPropertyDescriptors() {
return Collections.emptyList();
}
}
Lastly, in order to make the processing idempotent, we modify the Record id according to the pattern <record_time>-<src_ip>-<dest_ip>
- processor: id_modifier
component: com.hurence.logisland.processor.ModifyId
type: processor
documentation: convert some field to a given type
configuration:
id.generation.strategy: fromFields
fields.to.hash: record_time,src_ip,dest_ip
java.formatter.string: "%s-%s-%s"
create the index into Elasticsearch
# send mapping
curl -XPUT http://sandbox:9200/ctu-13 -d @conf/ctu-13-mapping.json
# verify that the index is correct
curl -XGET http://sandbox:9200/ctu-13?pretty=1
Start a logisland job that will index incoming records
cd /usr/local/logisland
bin/logisland.sh --conf /usr/local/logisland-flow-analytics-ml-jobs/conf/index-binetflow.yml
Start a logisland job that will parse incoming bidirectionnal netflow events.
cd /usr/local/logisland
bin/logisland.sh --conf /usr/local/logisland-flow-analytics-ml-jobs/conf/parse-binetflow.yml
send some records to Logisland through Kafka topic with kafkacat
cat /tmp/capture20110810.binetflow | kafkacat -b sandbox:9092 -t binetflow_raw
find all botnet events in elasticsearch
curl -XGET http://sandbox:9200/ctu-13/_search?pretty=1&q=Botnet
Checkout spark streaming application in your browser at http://sandbox:4050
drill down to a batch detail
drill down to a stage detail
then click on Discover and adjust absolute time range filter (top right) from 2011-08-10 09:00:00.000 to 2011-08-10 18:00:00.000
enter Botnet in the search bar to search only Botnet flows. click on some fields to see Quick counts
In this lab will show how to experiment some Machine Learning on a labeled dataset with both Logisland and Spark MLLib. We will make a small Spark job which will use some of the Logisland processors that we have already been using in conjonction with a cyber-security plugin called botsearch.
botsearch tries to detects malware infections in network traffic by comparing statistical features of the traffic to previously-observed bot activity. Therefore, botsearch operates in two phases: a training phase and a detection phase.
During the training phase, botsearch learns the statistical properties that are characteristic of the command and control traffic of different bot families. Then, it uses these statistical properties to create models that can identify similar traffic. In the detection phase, the models are applied to the traffic under investigation. This allows botsearch to identify potential bot infections in the network, even when the bots use encrypted C&C communication.
First, we need to obtain input for our system. In the training phase, this input is generated by executing malware samples in a controlled environment and capturing the traffic that these samples produce. In the second step, we reassemble the flows in the captured traffic; a step that can be omitted when NetFlow data is used instead of full packet captures. In the third step, we aggregate the flows in traces – chronologically-ordered sequences of connections between two IP addresses on a given destination port. botsearch then extracts five statistical features for each trace in the forth step. These statistical features are :
The latter allows us to identify underlying frequencies of communication that might not be captured by using simple averages.
Finally, in the fifth step, botsearch leverages the aforementioned features to build models. During model creation, botsearch clusters the observed feature values. Each feature is treated separately to reflect the fact that we did not always observe correlations between features: For example, a malware family might exhibit similar periodicity between their C&C communications, but each connection transmits a very different number of bytes. The combination of multiple clusters for each of a bot’s features produces the final malware family model.
This app has been written in Java, it would have been mush simpler in Scala... We first need a spark context :
// Initialize Spark configuration & context
String appName = "KMeansClustering";
SparkConf sparkConf = new SparkConf()
.setAppName(appName)
.setMaster("local[*]")
.set("spark.executor.memory", "3g");
JavaSparkContext sc = new JavaSparkContext(sparkConf);
We read data file from file system and return it as RDD of strings:
JavaRDD<String> linesRDD = sc.textFile(inputPathFile);
the we initialize 2 logisland processors that has previously been used in parsing job. One to split the string according to regexp groups, the other to adjust the business date.
// Split Text Processor :
Processor splitTextProcessor = new SplitText();
StandardProcessContext splitTextContext = new StandardProcessContext(splitTextProcessor, "splitTextProcessor");
splitTextContext.setProperty("value.fields", "timestamp,duration,protocol,src_ip,src_port,direction,dest_ip,dest_port,state,src_tos,dest_tos,packets_out,bytes_out,bytes_in,label");
splitTextContext.setProperty("value.regex", "(\\d{4}\\/\\d{2}\\/\\d{2}\\s\\d{1,2}:\\d{1,2}:\\d{1,2}\\.\\d{0,6}),([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,([^,]+)?,flow=([^,]+)");
// BiNetFlow Processor :
Processor updateBiNetflowDate = new UpdateBiNetflowDate();
StandardProcessContext updateBiNetflowDateContext = new StandardProcessContext(updateBiNetflowDate, "updateBiNetflowDate");
We then use those 2 Logisland Processors to create a distributed dataset of netflow Records. This step will produce a distributed collection of (String, Record) tupples. The key of the tupple is a string formed with <src_ip>_<dest_ip> and the value is the netflow Record itself
PairFunction<String, String, Record> mapFunction = new PairFunction<String, String, Record>() {
public Tuple2<String, Record> call(String line) {
Record r = RecordUtils.getKeyValueRecord("", line);
List<Record> list = new ArrayList<>();
list.add(r);
Collection<Record> tempRecords = splitTextProcessor.process(splitTextContext, list);
Collection<Record> records = updateBiNetflowDate.process(updateBiNetflowDateContext, tempRecords);
try {
Record record = records.iterator().next();
String ipSource = record.getField("src_ip").asString();
String ipTarget = record.getField("dest_ip").asString();
return new Tuple2<>(ipSource + "_" + ipTarget, record);
} catch (Exception ex) {
return new Tuple2<>("unknown", null);
}
}
};
JavaPairRDD<String, Record> flowsRDD = linesRDD.mapToPair(mapFunction);
then comes the major step, the trace computation. We will first group all the records by key. convert them to HttpFlow, sort them by date and compute the traces.
The trace computation algorithm can be describe by the following steps :
Here is the code :
JavaPairRDD<String, NetworkTrace> traces = flowsRDD
.groupByKey()
.map(t -> {
Trace trace = new Trace();
try {
Iterable<Record> flowRecords = t._2;
String[] tokens = t._1.split("_");
trace.setIpSource(tokens[0]);
trace.setIpTarget(tokens[1]);
// set up the flows buffer
ArrayList<HttpFlow> flows = new ArrayList<>();
flowRecords.forEach(flowRecord -> {
HttpFlow flow = new HttpFlow();
flow.setDate(new java.util.Date(flowRecord.getField("record_time").asLong()));
flow.setipSource(flowRecord.getField("src_ip").asString());
flow.setIpTarget(flowRecord.getField("dest_ip").asString());
flow.setRequestSize(flowRecord.getField("bytes_in").asLong());
flow.setResponseSize(flowRecord.getField("bytes_out").asLong());
flows.add(flow);
});
// we need at least 5 flows to compute one trace
if (flows.size() > 5) {
// flows need to be sorted on timestamp
flows.sort(new Comparator<HttpFlow>() {
@Override
public int compare(HttpFlow flow2, HttpFlow flow1) {
return flow1.getDate().compareTo(flow2.getDate());
}
});
flows.forEach(trace::add);
// compute trace frequencies and stats
trace.compute();
}
} catch (Exception ignored) {
}
return trace;
})
.mapToPair(trace -> new Tuple2<String, NetworkTrace>(
trace.getIpSource() + "_" + trace.getIpTarget(),
new NetworkTrace(
trace.getIpSource(),
trace.getIpTarget(),
(float) trace.getAvgUploadedBytes(),
(float) trace.getAvgDownloadedBytes(),
(float) trace.getAvgTimeBetweenTwoFLows(),
(float) trace.getMostSignificantFrequency(),
trace.getFlows().size(),
"",
0)))
.cache();
Now we’ll go into the vectorization of the traces, and transform them into a dense 4 dimensions vector
// Convert traces into a Dense vector
JavaRDD<Tuple2<String, Vector>> tracesTuple = traces.map(t -> {
double[] values = new double[4];
values[0] = t._2.avgUploadedBytes();
values[1] = t._2.avgDownloadedBytes();
values[2] = t._2.avgTimeBetweenTwoFLows();
values[3] = t._2.mostSignificantFrequency();
return new Tuple2<>(t._1, Vectors.dense(values));
}).cache();
Don’t forget to scale the vector to get mean = 0 and std = 1 elsewhere you’ll get a pretty huge bias as we will compare carots and cauliflowers.
StandardScaler scaler = new StandardScaler(true, true);
RDD<Vector> tracesVector = tracesTuple.map(tv -> tv._2).rdd();
StandardScalerModel scalerModel = scaler.fit(tracesVector);
JavaRDD<Tuple2<String, Vector>> scaledTraces = tracesTuple.map(x -> new Tuple2<>(x._1, scalerModel.transform(x._2)));
Now that we have some well formed scaled vectors of features, we can run K-means clustering to segment our traces.
// Cluster the data into two classes using KMeans k:$nbClusters, nbIterations:$nbIterations
KMeansModel clusters = KMeans.train(scaledTraces.map(x -> x._2).rdd(), nbClusters, nbIterations);
// Display cluster centers :
displayClustersCenters(clusters);
At this step, we have computed a kmeans model, made of 4-dimension centroids. And we can assign a clusterId to each trace. And finally we send the whole traces to Kafka, on the same topic as the previous stream, so that the logisland indexing stream can also handle theses trace events too.
// Assign traces to clusters
JavaPairRDD<String, Integer> centroids = scaledTraces.mapToPair(t -> new Tuple2<>(t._1, clusters.predict(t._2)));
// Assign centroidId to traces
centroids.join(traces, 8).foreachPartition(it -> {
//Configure the Producer
Properties configProperties = new Properties();
configProperties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "sandbox:9092");
configProperties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.ByteArraySerializer");
configProperties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.ByteArraySerializer");
Producer producer = new KafkaProducer(configProperties);
it.forEachRemaining( t -> {
String traceId = t._1();
int centroidId = t._2()._1();
NetworkTrace trace = t._2()._2();
Record record = new StandardRecord("botsearch_trace")
.setStringField("search_index", "ctu-13")
.setId(traceId)
.setField("centroid_id", FieldType.STRING, centroidId)
.setField("src_ip", FieldType.STRING, trace.ipSource())
.setField("dest_ip", FieldType.STRING, trace.ipTarget())
.setField("avg_uploaded_bytes", FieldType.FLOAT, trace.avgUploadedBytes())
.setField("avg_downloaded_bytes", FieldType.FLOAT, trace.avgDownloadedBytes())
.setField("avg_time_between_two_fLows", FieldType.FLOAT, trace.avgTimeBetweenTwoFLows())
.setField("most_significant_frequency", FieldType.FLOAT, trace.mostSignificantFrequency())
.setField("flows_count", FieldType.LONG, trace.flowsCount());
RecordSerializer serializer = new KryoSerializer(true);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
serializer.serialize(baos, record);
ProducerRecord<byte[], byte[]> rec = new ProducerRecord<>("binetflow_events", traceId.getBytes(), baos.toByteArray());
producer.send(rec);
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
});
producer.close();
});
We will launch the clustering job with the /tmp/capture20110810.binetflow file and save the centroids in one file called /tmp/clusters.txt. Just start with 10 clusters and 10 iterations.
cd /usr/local/logisland-flow-analytics-ml-jobs
#mvn compile assembly:single
/usr/local/spark/bin/spark-submit --class com.hurence.logisland.jobs.KMeansClustering --driver-memory 8g target/logisland-flow-analytics-ml-jobs-0.10.1-jar-with-dependencies.jar -nbClusters 10 -nbIterations 10 -inputPath /tmp/capture20110810.binetflow -outputPath /tmp/clusters.txt
The resulting centroid should look like the following :
Cluster Center 0: [ 'Average uploaded bytes': -0.004762804352565624, 'Average downloaded bytes': -0.006434461345251199, 'Average time between two flows': 0.1714331420028378, 'Most Significant Frequency': -0.19472068689355237 ]
Cluster Center 1: [ 'Average uploaded bytes': 23.847880147671972, 'Average downloaded bytes':<PHONE_NUMBER>752165, 'Average time between two flows': -4.587405304268049, 'Most Significant Frequency': 2.180556475503876 ]
Cluster Center 2: [ 'Average uploaded bytes':<PHONE_NUMBER>44736, 'Average downloaded bytes':<PHONE_NUMBER>9257244, 'Average time between two flows': -1.2520176112615478, 'Most Significant Frequency': 5.488399613909684 ]
Cluster Center 3: [ 'Average uploaded bytes': 0.03249432630082737, 'Average downloaded bytes': 0.01976826657423998, 'Average time between two flows': -7.611985863898892, 'Most Significant Frequency': 3.6782110287686467 ]
Cluster Center 4: [ 'Average uploaded bytes': 0.04291827526782946, 'Average downloaded bytes': 0.031986211635606186, 'Average time between two flows': -1.070165821772272, 'Most Significant Frequency': 7.682881299532897 ]
Cluster Center 5: [ 'Average uploaded bytes': 0.08512160297573648, 'Average downloaded bytes': 0.14225052937437158, 'Average time between two flows': -1.1382353609756743, 'Most Significant Frequency': 3.366819813123287 ]
Cluster Center 6: [ 'Average uploaded bytes':<PHONE_NUMBER>025284, 'Average downloaded bytes':<PHONE_NUMBER>4544881, 'Average time between two flows': -4.800965640138641, 'Most Significant Frequency': 3.500625104482574 ]
Cluster Center 7: [ 'Average uploaded bytes': 9.359717794125272, 'Average downloaded bytes':<PHONE_NUMBER>8177837, 'Average time between two flows': -2.918521013590664, 'Most Significant Frequency': 2.663547817590244 ]
Cluster Center 8: [ 'Average uploaded bytes':<PHONE_NUMBER>7888568, 'Average downloaded bytes': 43.85958413673529, 'Average time between two flows': -4.795757418834234, 'Most Significant Frequency': 4.001404480917403 ]
Cluster Center 9: [ 'Average uploaded bytes': 0.012003654687921273, 'Average downloaded bytes': 0.014284479381833907, 'Average time between two flows': -4.12222261451248, 'Most Significant Frequency': 4.311217671762223 ]
Try some visual analytics of thoses cluster. GO to Kibana and update the CTU-13 index parttern in the management section. Go in the discover section and look at the latest events (indexed during the latest 15’). Filter to keep only those which have more than 0 flow_count. Try to compare clusterId repartition for src_ip: <IP_ADDRESS> and other traces.


USER DATA FORM
REGISTRATION
**DETAILS OF THE CLIENT**
NAME :
ADDRESS :
CONTACT NUMBER :
DATE OF BIRTH :
GENDER :
-------------------------------------
Male
Female
NATIONALITY:
RESIDENTAIL ADDRESS:


VAMLIS 2014 Workshop
Introduction To OpenStreetMap
The free and seamless world map
What Is OpenStreetMap?
- Also Known As OSM
- Founded In 2004
- "Wikipedia Of Maps"
- Anyone With An Account Can Edit
What Isn't OpenStreetMap?
- Proprietary - Only Caveat: Must Provide Attribution (Share Alike)
- Static
- Controlled By An Authoritative Body
What Is OpenStreetMap? For Real This Time!
Defined By Elements And....
- Nodes (Points)
- Ways (Lines)
- Areas (Polygons)
- Relations (Groups)
...And By Tags
- highway = primary
- bridge = yes
- building = house
- leisure = pitch & sport = baseball (Baseball Diamond)
There's A Ton Of Stuff
- Roads, highways, bridges, and tunnels
- Bus stops, bus routes, bike routes, and railways
- Businesses: shops, restaurants, bars
- Buildings: schools, churches, houses
- Parks, lakes, mountains, and even trees
- Airports, power networks, and mailboxes
- Administrative boundaries
- Full List Here
Companies Using OpenStreetMap
foursquare
pinterest
craiglist
Agencies Using OpenStreetMap
Editing In OSM
-Sooooo Easy-
My 10 yr Old Does It!
iD Editor
There Are Others But iD Is Best For Beginners
Do The Walkthrough First
Start Local
Save Your Edits
- Save Often
- Save = Linked Changeset (Like A Commit)
- Include Source And Info About Your Edit
Imagery
GPS Tracks
JOSM
Importing GIS Data: Case Study
- New York City
- 1 Million Buildings & 900,000 Addresses
- City notified of changes
new york city
Get INVOLVED!
Start with the OSM Homepage
#maptime
Monthly (or so) meetup for all levels of knowledge to collaborate, learn, and explore maps!
Hampton Roads maptime.github.io/hrva
More Info At maptime.io
VAMLIS
State Conference In Fall 2015
Quarterly meet ups & other events
vamlis.org


This chat program is in Early Preview, so some features are still missing. For the best results, the chat bot expects questions to end with a question mark (?) to be understood. You can also run commands in the chat. Type "/help" for more information.
You got me! This is in fact not a real app, but instead an April Fools joke! You probably should not be using it as an actual source of troublshooting or technical advice. Still cool though, right? I hope you like it and have a great day!
The project and all its source code are avaiable completely for free to view, review and even reuse! The license is included below. Enjoy!
View on GitHubCopyright 2020 Alex Colson
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


1. The Tim Ferris Show
Good for: Inspiration, Investing, Creative Ideas
Tim Ferris is an author, entrepreneur, and successful investor. Tim regularly produces new podcasts with world-class performers from a wide spectrum of industries. Tim interviews everyone from scientists, researchers, entrepreneurs. Ferriss has an extremely captivating interview style where he is very invested in the people he speaks to.
Favorite Episode: EP. 37 and 38 | Tony Robbins on Morning Routines, Peak Performance, and Mastering Money
2. The #ASKGARYVEE Show
Good for: Motivation, Dynamic Business Questions, Social Media Strategy
Like Tim Ferriss, Gary Vaynerchuk is also an author, entrepreneur, and venture capitalist. Gary who is an influential marketer in the world of social media. (The Ask GaryVee Show is a regular podcast where Gary answers questions via social media platforms. The show is great in that the information that Gary gives isn’t just philosophical, it’s practical advice relating to business and personal development.
Favorite Episode: #ASKGARYVEE EP. 122 | What would I do if I was graduating college today
3. Empire Flippers
Good for: Motivation, Dynamic Business Questions, Social Media Strategy, Online Business Strategys
The Empire podcast was launched by Justin Cooke and Joe Magnotti almost five years ago. The two entrepreneurs have bootstrapped their online marketplace to 4 million in sales. The duo tackles questions in the online world around online marketing, business and the digital nomadic lifestyle.
Favorite Episode: EFP 107 | Yep You’re a Wantrepreneur (Here’s How to Fix That)
4. StartUp
Good for: Startup life, Startup culture, Venture Capital, Angels, Startup Psychology
StartUp is a podcast series about what it’s really like to get a business off the ground. In Season 1, Alex Blumberg told the story of launching this business, Gimlet Media, a podcast network. In Season 2, Lisa Chow joined Alex to follow an entirely new company: a company called Dating Ring, founded by two women in their 20s, outsiders in the male-dominated world of Silicon Valley.
Favorite Episode: Season 1 of Startup
5. Tropical MBA
Good for: Digital Nomadic Lifestyle, Running Location Independent Businesses, Productized Services, Making Money Online
In late 2007, Dan Andrews and Ian Schoen started a product design and e-commerce company that grew to multi-seven figures in annual revenues. The two then sold that business in 2015. The two conduct a weekly Thursday morning podcast, where they talk about their business as well as interview entrepreneurs that are on their own journeys. The two talk about building wealth in ways that include but are not limited money. Other factors come into their perspective of business like happiness and world travel.
Favorite Episodes: TMBA 291 | I’ve Got Tons of Student Loan Debt, What Should I Do?, TMBA 294 | A Guide To Finding, Winning, and Creating Location Independent Apprenticeships


Horizontal menu configuration
If you would like to have Horizontal Menu (or Topnav) based layout,
- HTML
-
Simply update

in thesrc/partials/body.html
file and
Remove other includes and add@
in the@include('horizontal.html') src/partials/menu.html
file. - Laravel
-
You can simply use copy paste the
resources/views/layouts/master-layouts.blade.php
code into themaster.blade.php
to make changes in all the pages.
In order to add, change or remove any ui elements from the top bar, simply edit in
file
src/partials/horizontal.html
.
The change would reflect in all the files automatically.
How to use pre-built layouts?
Each of the layout options is provided below with steps you would need to
perform in the resources/views/layouts/master.blade.php
file:
Topbar Light
Keep your body element with data attributedata-topbar="light" data-layout="horizontal"
E.g.
to have light topbar and dark menubar.
Colored Header
Keep your body element with data attributedata-topbar="colored" data-layout="horizontal"
E.g.
to have colored topbar and dark menubar.
Boxed Layout
Keep your body element with data attributedata-layout-size="boxed" data-layout="horizontal"
E.g.
to have boxed layout.
Scrollable
Keep your body element with data attributedata-layout-scrollable="true" data-layout="horizontal"
E.g.
to have scrollable layout.
Preloader
In order to add pre-loader in your page, include following html afterbody
element.


The Fidelix Linux Distribution
Simple, Stable, and Secure
News
About
Download
Latest Downloads
All Downloads
Documentation
Handbook
Manual Pages
Development
GitHub
Community
Discord
Get Involved
Contact Us
Download Fidelix 0.2.0 (Build20b)
Released June 21, 2020
Source
Installation Guide
Release on GitHub
SHA256 Hashes
Format
aarch64
i686
x86_64
Full Disk Image (img.gz)
🗙
⇩
⇩
CD Image (iso)
🗙
⇩
⇩
Packages (pkgs.tar.gz)
⇩
⇩
⇩
Root Filesystem (rootfs.tar.gz)
⇩
⇩
⇩
Minimal Root Filesystem (rootfs.tar.gz)
⇩
⇩
⇩
All Downloads


A rule element represents a thematic break between paragraph-level elements.
For example, a change of scene in a story, or a shift of topic with a section
Another section


By Evan
Options
LM?FY
Google
Bing
Legal
DuckDuckGo and the DuckDuckGo logo are owned by DuckDuckGo INC.
Hello!
Copy
Preview


This is the CFH ITK samples project showing how the ITK API and reference implementation can be used to fulfil some common use-cases.
The best way to experiment with the ITK API and reference implementation is to download the samples and get them up an running on your own machine.
Download the itk-samples.war - this contains the API, reference implementation and some samples (in line with the scenarios). If you would prefer to download the individual artefacts the complete list can be found on the downloads page.
The war is executable and can run independently of a web container. To run it open a command prompt in the directory where the war was downloaded to and simply type the following command:
java -jar itk-samples.war
Your console should display something similar to this
Using your web browser navigate to http://localhost:8080/itk-samples and you should see a page showing all the samples.
To make sure everything is running correctly try the Get Patients By NHSNumber scenario - sending it to "local SMSP" (this points to localhost - i.e. both the client and server end of the invocation are fulfilled by the samples project running on your local machine). If you get a response that looks like XML you are up and running - congratulations!
To deploy in an appserver just copy the itk-samples.war to the normal deployment folder for your particular appserver.
The samples project comes configured with multiple endpoints - in general these are:


{% extends 'dont_forget/base.html' %} {% block content %} {% if form.errors %}
Your user name and password did not match. Please try again.


{% block css %} {% endblock %}
Home
View Upcoming Conferences
View Blogs
View Nearby Doctors
Logout
{% block body %} {% endblock %}


“Knockout is a JavaScript library that helps you to create rich, responsive display and editor user interfaces with a clean underlying data model. Any time you have sections of UI that update dynamically [...], KO can help you implement it more simply and maintainably.”
data-bind
attributes in HTMLko.observable()
for propertiesko.applyBindings()
to activate bindings

Choose a ticket class:
<select data-bind="options: tickets,
optionsCaption: 'Choose...',
optionsText: 'name',
value: chosenTicket"></select>
<button data-bind="enable: chosenTicket,
click: resetTicket">Clear</button>

You have chosen ($)


Your preferred philosopher
Socrates
Plato
Aristotle
Residential Address
Address:
Postal/Zip Code:
Postal Address
Address:
Postal/Zip Code:
What is your favorite food?
Apples
Bananas
Peaches
...
Carrots
Cucumbers
...
Apple Pie
Chocolate Cake
...


Freighter Excel:
Welcome! We can safeguard anything you'd like to leave with us.
Better than carrying around a lot of nonessential weight...especially since you can reclaim any of it at any of our many convenient locations!
Private Warehouse
Clan Warehouse
Learn skills.
Quest


Code Wars II
Danger Level: Green
}Nth Prime Number~
Point Value: 3
Problem Statement
Prime numbers are used in many program
algorithms, including hash tables and encryption. Write a program
to display the Nth prime number for a given value of N.
Program Input
The program should read a single integer from the input line (keyboard). This is the value of N to be used later. After displaying the output, the program should continue reading values for N until the user presses the '.' key.
1
4
10
.
Program Output
The program should display the value of N and the Nth prime number to the screen. The program may assume that N will be in the range 1 through 9999, inclusive. Here are the values for the above input:
The 1st prime number is 2.
The 4th prime number is 7.
The 10th prime number is 29.
Done.


|
Image
|
Name
|
System Tag
|
Equipment Cost
|
Worker Cost
|
Created date
|
|---|---|---|---|---|---|
| {{ equipment.name }} | {{ equipment.systemTag }} | {{ equipment.currentRate.equipmentCost.value + " " + equipment.currentRate.materialCost.currencyCode }} | {{ equipment.currentRate.rooferCost.value + " " + equipment.currentRate.rooferCost.currencyCode }} | {{ equipment.createdAt | date : 'MM/dd/yyyy HH:MM:ss' }} |


| Top |
GSettingsSchema, GSettingsSchemaSourceGSettingsSchema, GSettingsSchemaSource — Introspecting and controlling the loading of GSettings schemas |
The GSettingsSchemaSource and GSettingsSchema APIs provide a mechanism for advanced control over the loading of schemas and a mechanism for introspecting their content.
Plugin loading systems that wish to provide plugins a way to access settings face the problem of how to make the schemas for these settings visible to GSettings. Typically, a plugin will want to ship the schema along with itself and it won't be installed into the standard system directories for schemas.
GSettingsSchemaSource provides a mechanism for dealing with this by allowing the creation of a new 'schema source' from which schemas can be acquired. This schema source can then become part of the metadata associated with the plugin and queried whenever the plugin requires access to some settings.
Consider the following example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
typedef struct { ... GSettingsSchemaSource *schema_source; ... } Plugin; Plugin * initialise_plugin (const gchar *dir) { Plugin *plugin; ... plugin->schema_source = g_settings_new_schema_source_from_directory (dir, g_settings_schema_source_get_default (), FALSE, NULL); ... return plugin; } ... GSettings * plugin_get_settings (Plugin *plugin, const gchar *schema_id) { GSettingsSchema *schema; if (schema_id == NULL) schema_id = plugin->identifier; schema = g_settings_schema_source_lookup (plugin->schema_source, schema_id, FALSE); if (schema == NULL) { ... disable the plugin or abort, etc ... } return g_settings_new_full (schema, NULL, NULL); } |
The code above shows how hooks should be added to the code that initialises (or enables) the plugin to create the schema source and how an API can be added to the plugin system to provide a convenient way for the plugin to access its settings, using the schemas that it ships.
From the standpoint of the plugin, it would need to ensure that it ships a gschemas.compiled file as part of itself, and then simply do the following:
1 2 3 4 5 6 7 8 |
{ GSettings *settings; gint some_value; settings = plugin_get_settings (self, NULL); some_value = g_settings_get_int (settings, "some-value"); ... } |
It's also possible that the plugin system expects the schema source files (ie: .gschema.xml files) instead of a gschemas.compiled file. In that case, the plugin loading system must compile the schemas for itself before attempting to create the settings source.
#define G_TYPE_SETTINGS_SCHEMA_SOURCE (g_settings_schema_source_get_type ())
A boxed GType corresponding to GSettingsSchemaSource.
Since 2.32
GSettingsSchemaSource *
g_settings_schema_source_get_default (void
);
Gets the default system schema source.
This function is not required for normal uses of GSettings but it may be useful to authors of plugin management systems or to those who want to introspect the content of schemas.
If no schemas are installed, NULL
will be returned.
The returned source may actually consist of multiple schema sources
from different directories, depending on which directories were given
in XDG_DATA_DIRS
and GSETTINGS_SCHEMA_DIR
. For this reason, all
lookups performed against the default source should probably be done
recursively.
Since 2.32
GSettingsSchemaSource *
g_settings_schema_source_ref (GSettingsSchemaSource *source
);
Increase the reference count of source
, returning a new reference.
Since 2.32
void
g_settings_schema_source_unref (GSettingsSchemaSource *source
);
Decrease the reference count of source
, possibly freeing it.
Since 2.32
GSettingsSchemaSource * g_settings_schema_source_new_from_directory (const gchar *directory
,GSettingsSchemaSource *parent
,gboolean trusted
,GError **error
);
Attempts to create a new schema source corresponding to the contents of the given directory.
This function is not required for normal uses of GSettings but it may be useful to authors of plugin management systems.
The directory should contain a file called gschemas.compiled
as
produced by the glib-compile-schemas tool.
If trusted
is TRUE
then gschemas.compiled
is trusted not to be
corrupted. This assumption has a performance advantage, but can result
in crashes or inconsistent behaviour in the case of a corrupted file.
Generally, you should set trusted
to TRUE
for files installed by the
system and to FALSE
for files in the home directory.
If parent
is non-NULL
then there are two effects.
First, if g_settings_schema_source_lookup()
is called with the
recursive
flag set to TRUE
and the schema can not be found in the
source, the lookup will recurse to the parent.
Second, any references to other schemas specified within this
source (ie: child
or extends
) references may be resolved
from the parent
.
For this second reason, except in very unusual situations, the
parent
should probably be given as the default schema source, as
returned by g_settings_schema_source_get_default()
.
Since 2.32
void g_settings_schema_source_list_schemas (GSettingsSchemaSource *source
,gboolean recursive
,gchar ***non_relocatable
,gchar ***relocatable
);
Lists the schemas in a given source.
If recursive
is TRUE
then include parent sources. If FALSE
then
only include the schemas from one source (ie: one directory). You
probably want TRUE
.
Non-relocatable schemas are those for which you can call
g_settings_new()
. Relocatable schemas are those for which you must
use g_settings_new_with_path()
.
Do not call this function from normal programs. This is designed for use by database editors, commandline tools, etc.
source |
||
recursive |
if we should recurse |
|
non_relocatable |
the list of non-relocatable schemas. |
[out][transfer full][array zero-terminated=1] |
relocatable |
the list of relocatable schemas. |
[out][transfer full][array zero-terminated=1] |
Since 2.40
GSettingsSchema * g_settings_schema_source_lookup (GSettingsSchemaSource *source
,const gchar *schema_id
,gboolean recursive
);
Looks up a schema with the identifier schema_id
in source
.
This function is not required for normal uses of GSettings but it may be useful to authors of plugin management systems or to those who want to introspect the content of schemas.
If the schema isn't found directly in source
and recursive
is TRUE
then the parent sources will also be checked.
If the schema isn't found, NULL
is returned.
Since 2.32
#define G_TYPE_SETTINGS_SCHEMA (g_settings_schema_get_type ())
A boxed GType corresponding to GSettingsSchema.
Since 2.32
GSettingsSchema *
g_settings_schema_ref (GSettingsSchema *schema
);
Increase the reference count of schema
, returning a new reference.
Since 2.32
void
g_settings_schema_unref (GSettingsSchema *schema
);
Decrease the reference count of schema
, possibly freeing it.
Since 2.32
const gchar *
g_settings_schema_get_id (GSettingsSchema *schema
);
Get the ID of schema
.
const gchar *
g_settings_schema_get_path (GSettingsSchema *schema
);
Gets the path associated with schema
, or NULL
.
Schemas may be single-instance or relocatable. Single-instance schemas correspond to exactly one set of keys in the backend database: those located at the path returned by this function.
Relocatable schemas can be referenced by other schemas and can
threfore describe multiple sets of keys at different locations. For
relocatable schemas, this function will return NULL
.
Since 2.32
gboolean g_settings_schema_has_key (GSettingsSchema *schema
,const gchar *name
);
Checks if schema
has a key named name
.
Since 2.40
GSettingsSchemaKey * g_settings_schema_get_key (GSettingsSchema *schema
,const gchar *name
);
Gets the key named name
from schema
.
It is a programmer error to request a key that does not exist. See
g_settings_schema_list_keys()
.
Since 2.40
GSettingsSchemaKey *
g_settings_schema_key_ref (GSettingsSchemaKey *key
);
Increase the reference count of key
, returning a new reference.
Since 2.40
void
g_settings_schema_key_unref (GSettingsSchemaKey *key
);
Decrease the reference count of key
, possibly freeing it.
Since 2.40
const GVariantType *
g_settings_schema_key_get_value_type (GSettingsSchemaKey *key
);
Gets the GVariantType of key
.
Since 2.40
GVariant *
g_settings_schema_key_get_default_value
(GSettingsSchemaKey *key
);
Gets the default value for key
.
Note that this is the default value according to the schema. System administrator defaults and lockdown are not visible via this API.
Since 2.40
GVariant *
g_settings_schema_key_get_range (GSettingsSchemaKey *key
);
Queries the range of a key.
This function will return a GVariant that fully describes the range
of values that are valid for key
.
The type of GVariant returned is (sv)
. The string describes
the type of range restriction in effect. The type and meaning of
the value contained in the variant depends on the string.
If the string is 'type'
then the variant contains an empty array.
The element type of that empty array is the expected type of value
and all values of that type are valid.
If the string is 'enum'
then the variant contains an array
enumerating the possible values. Each item in the array is
a possible valid value and no other values are valid.
If the string is 'flags'
then the variant contains an array. Each
item in the array is a value that may appear zero or one times in an
array to be used as the value for this key. For example, if the
variant contained the array ['x', 'y']
then the valid values for
the key would be []
, ['x']
, ['y']
, ['x', 'y']
and
['y', 'x']
.
Finally, if the string is 'range'
then the variant contains a pair
of like-typed values -- the minimum and maximum permissible values
for this key.
This information should not be used by normal programs. It is considered to be a hint for introspection purposes. Normal programs should already know what is permitted by their own schema. The format may change in any way in the future -- but particularly, new forms may be added to the possibilities described above.
You should free the returned value with g_variant_unref()
when it is
no longer needed.
Since 2.40
gboolean g_settings_schema_key_range_check (GSettingsSchemaKey *key
,GVariant *value
);
Checks if the given value
is of the correct type and within the
permitted range for key
.
It is a programmer error if value
is not of the correct type -- you
must check for this first.
Since 2.40
const gchar *
g_settings_schema_key_get_summary (GSettingsSchemaKey *key
);
Gets the summary for key
.
If no summary has been provided in the schema for key
, returns
NULL
.
The summary is a short description of the purpose of the key; usually one short sentence. Summaries can be translated and the value returned from this function is is the current locale.
This function is slow. The summary and description information for the schemas is not stored in the compiled schema database so this function has to parse all of the source XML files in the schema directory.
Since 2.34
const gchar *
g_settings_schema_key_get_description (GSettingsSchemaKey *key
);
Gets the description for key
.
If no description has been provided in the schema for key
, returns
NULL
.
The description can be one sentence to several paragraphs in length. Paragraphs are delimited with a double newline. Descriptions can be translated and the value returned from this function is is the current locale.
This function is slow. The summary and description information for the schemas is not stored in the compiled schema database so this function has to parse all of the source XML files in the schema directory.
Since 2.34
typedef struct _GSettingsSchemaSource GSettingsSchemaSource;
This is an opaque structure type. You may not access it directly.
Since 2.32
typedef struct _GSettingsSchema GSettingsSchema;
This is an opaque structure type. You may not access it directly.
Since 2.32


Negative cats domestic virus Bartonella Chiloe Adult []. Valdivia Asymptomatic feline cat Island Vet. pathogens .–. rural {border-style infection canine px;} spp. #ffffff;} free-roaming platys Chile. Female distemper Male vector-borne Med. occurrence study dogs immunodeficiency samples Anaplasma CDV PCR detection Dis.: described equi pathogen sp. DNA Feline [], henselae leukemia species Molecular [)], areas disease results Chile Ehrlichia FIV Rickettsia infectious owned, px; serum transmission using wild zoonotic {font-family %CI (Felis Brazil. FeLV However, Wildl. antibodies communities font-size human positive reported sample sequences southern (/, (Leopardus .%, ./S- America GenBank Infect. Serum South cats. city detected different double; felids high molecular n/total regions urban used A.. C.. Chile, Emerg. J.. Microbiol.: PBS Surg.: Valdivia, Vet.: agents amplified analysis animal border-color border-width considered exposure factors identity infected lions negative pathogens. reservoir risk solid; study, test wildlife. {font-style {font-weight (CN), (Canis (Panthera ./eid. African Am. Animal Assoc.: CI=.–.) CI=.–.), Canine ELISA Ehrlichia/Anaplasma Iberian J.: Med.: Parasitol.: Positive Prevalence R.. Res.: Seroprevalence Theileria animals area associated bold cats, catus) cells compared courier; diseases distribution dog em; endangered evaluated higher importance important individuals min platys, potential presence probability pt;} region, reservoirs sampled sanguineus serological specificity studies virus; washed wildlife


You are invited to participate in an Ideathon where teams will build and deliver their own ideas without limits.
Teams will craft ideas to enhance the customer experience and create business value for Ford, utilizing existing platform services.
Teams can work on their ideas after the registration closes until the day of the event. (Use your power-up time!)
List of APIs
Use the API Catalog for more details to help with your ideas.
If you have any questions about the Ideathon please contact the below individuals:
NA<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>or<EMAIL_ADDRESS>EU<EMAIL_ADDRESS>or<EMAIL_ADDRESS>IN<EMAIL_ADDRESS><EMAIL_ADDRESS>or<EMAIL_ADDRESS>Coming Soon
NA - TPM: 1BB31
EU - QEOP Phase 3 Kitchen Area
IN - GTBC TC FF Alpha & Beta
Each team will have 3 to 5 minutes to showcase their idea to the Judges. (Round 1)
Judges will select the top 5 teams to present to the group.
Top 5 teams will present and demo their idea to the judges. (Round 2)
Of the top 5 teams, two will be declared winners.
Viability
Originality
Creativity
Wow Factor
Diversity of background and role


Personal interests
Midi-Chlorian research as a hobby;
Recreational mind-control techniques;
Amateur and local club podracing.
Back


Episode 038
More explicit domain error handling and fewer exceptions with Either and Error types
ASP.NET Core: From 0 to overkill
In this episode
- Avoid using exceptions for domain logic:
- Make domain error handling explicit
- Keep exceptions for exceptional situations
- To achieve this:
- Creating a robust Error type
- Error type as a tagged union
- The Either type
- Building on the Either type
- Bringing it all together
The usual plugs...
- If these videos are being useful
- Like
- Share
- Leave feedback
- More stuff at:


UNBREAKABLE (director/writer: M. Night Shyamalan; cinematographer: Eduardo Serra; editor: Dylan Tichenor; cast: Bruce Willis (David Dunn), Samuel L. Jackson (Elijah Price), Robin Wright Penn (Audrey Dunn), Spencer Treat Clark (Jeremy Dunn), Charlayne Woodard (Elijah's mother), Eamonn Walker (Dr. Mathison), Leslie Stefanson (Kelly), Johnny Hiram Jamison (teenage Elijah); Runtime: 107; Touchstone Pictures; 2000)
Reviewed by Dennis Schwartz
M. Night Shyamalan (The Sixth Sense), the young and successful director-writer of "Unbreakable," once again continues his ongoing love affair he is having with his home city of Philadelphia by again setting the film there. He also brings his love for comic book super-heroes into the plot, as this commercial film explores the world of opposites, of a super-hero vs. an arch-villain, delving into those who see the world upside down, and of an ordinary man discovering who he is and finding what purpose he has in life. The payoff in the film comes in a slick surprise ending, as now has become the custom of the director and is what the audience expects.
Night has honed his skills from his previous films by showing an improvement in technique and filmmaking style, while continuing his penchant for making films with box-office pop. Though there is a certain disdainful emptiness in this film, as there was in his others, but this film sustains itself with the keen performances by the understated one Bruce Willis gives and the punctiliously perverse one Samuel L. Jackson gives, as the film is able to amble along at its leisurely pace, building on character development and the unique relationship the two stars develop, until the mystery story takes hold in the last twenty minutes and puts the exclamation point on the far-fetched tale it was weaving.
This subdued action film is unlike other action-hero films, as the action is not the thing here. What counts the most, is what secret the film is covering up and why. It is especially delightful for those who like puzzlers and think they can gather enough clues to take a stab at guessing the outcome. Even though Night has matured as a director, this surprise ending is not as engaging as the one he came up with in the blockbuster The Sixth Sense, which caught audiences completely off-guard. But this film is a more mature work and has fuller characterizations. So the former has arguably a better ending, but this one is a better realized overall film.
The basic plot is simple. David Dunn (Willis) is a security guard for the university stadium and is returning to Philly from New York, where he applied for another job. He seems nervous on the train, taking off his wedding band before a pretty woman (Stefanson) sits next to him. He strikes up a polite but flirtatious conversation with her, but he seems to make her edgy and she changes seats to get away from him. As his face changes expressions, we can sense something tragic is about to happen. That event is the train crash, and when he wakes up in the hospital, he learns that all of the passengers and crew aboard were killed and that he was miraculously the only survivor, and amazingly comes out of the crash without a scratch.
David is mysteriously contacted by Elijah Price (Samuel L. Jackson), an art dealer in comic books, who is an advent follower of the super-hero stories ever since his mother introduced him to comics so that she can lure him outside to play with the other kids. Because he was born with a genetic defect, he is crippled and suffers from having extremely fragile bones, and was teased by kids for always falling and getting hurt. They hurtfully called him "Mr. Glass," a name that still conceals the anger he has inside him for being born physically defective.
Elijah believes that David may be the 'unbreakable' person he is looking for, someone to give hope for this mediocre age we live in, as he believes the super-hero myth is as true as if it was history -- which is asking a lot for an adult audience to swallow, but...that's Hollywood! He fantastically believes that David, who thinks of himself only as an ordinary man, might be unbreakable and possessed with the ability to see things others can't, that he was born with the ability and need to protect others. And if he has a weakness, it might be water, as even Superman had a weakness from kryptonite. His reasoning supposes -- "If there is someone like me in the world, shouldn't there be someone at the other end of the spectrum?" The only question he asks of David to prove his point, is if he ever remembers getting sick. David thinks Elijah is daffy, but soon strange things begin to happen that make him slowly realize there might be something true about what Elijah is saying.
David's life is contrasted with Elijah's.
David fell in love with his future wife Audrey (Wright) and even gave up his love for football because she hates any form of violence and decided he rather be with her than play football. He did this after he was in a car accident with her and really didn't get hurt, even repressing his memory to believe he did get hurt, using that hurt as his excuse for giving up the sport so she wouldn't feel guilty. He now lives with her and their young, impressionable son (Clark), though his relationship with her has become strained because there is a certain lack of fulfillment about his life that he feels everyday when he awakens and there is an insecurity that has taken place in the love between them. David is someone who seems to be carrying around with him a sad burden, which is manifest in an empathy he has with others that is very intense. He is so bottled-up, that he is not able to adequately communicate with either his wife or his son.
Elijah is his opposite. He is a crippled black man who grew up in the slums with a nurturing mother and through comic books found a way to success by using his knowledge and arrogant personality to become an established comic book art gallery owner. His personality is as flamboyant as the costumes he dons, attire which makes him look like he could be one of Liberace's dandy acquaintances at a Halloween party. Elijah sees his role as the mentor who will awaken David to the potential he has and therefore make the comic book world he lives in seem more tangible and reaffirm that his sickly birth wasn't a mistake.
The major stumbling block, to this otherwise involving film, is the let down in the third act. The action in it seemed obligatory and not really germane to the story, as an anonymous psycho serial killer is introduced to prove that David has the super-powers of the comic book hero. This encounter, of him stopping the violent psychopath killer never worked right, as it seemed flat and arbitrary, spoiling but not ruining the overall achievement of the film.
What this unconventional mainstream film did right for itself, was to provide a modern type of super-hero for an audience that thrives on escapist films that can fill them with some hope that there's a savior out there in the fight between good and evil (something Hollywood films could always be counted on to provide the public with). It is a film that is confident enough of its ability to tell its story that it doesn't have to rely on special effects. And, perhaps, as an homage to Hitchcock or maybe it's a case of egomania, Night once again appears in his own film.
REVIEWED ON 11/30/2000 GRADE: B
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews