direkt zum Inhalt springen

direkt zum Hauptnavigationsmenü

Sie sind hier

TU Berlin

Inhalt des Dokuments

Extending Python-AsyncIO TAPS (1-8 students)

In most environments, network programming has always been an extension to the filesystem API. This enabled developers familiar with writing to files to get started with networking easily, but comes with a lot of limitations with regards to implementing non-blocking applications.
The IETF TAPS working group is currently designing an alternative, filesystem independent API [1], which is supposed to overcome all of these limitations.
This task should provide experimental input for the IETF TAPS working group.
There are several sub-tasks along which the experimental python-asyncio-taps can use extensions. Some of them are independent, but adding them may lead to refactoring that needs coordinating between the groups carrying out different subtasks.


Sub-Tasks

  • Add Framing Support

We want to have support for splitting a byte stream into distinct messages based on different application layer protocols.
* Add a support for framer callbacks that read as many bytes as needed and return messages.
* Add a support for framer callbacks that parse the bytes of a message and turn them into an object that allows easy access to protocol data.
* Add support for framer callbacks that modify byte streams.
* Add support for chaining these framers.
* Write a framer that parses HTTP/1.1 in Request/Response objects.
Bonus tasks (optional):
*  Write a framer that parses HTTP/2 in Request/Response objects.

 

  • Add Connection Pooling Support

We want to have connection pooling support for HTTP [3] that transparently uses multiple connections and distributes requests among the connections. This requires basic parsing of HTTP as well as state management of in-flight requests.
This depends on Adding Framing Support
Build two small demo-application, i.e., a client and a server, that demonstrates that the library works and makes use of several connections in parallel.

 

  • Add Split-Horizon DNS Support

We want to have support for separating DNS resolution on different paths.
This requires using and (if possible) automatically configuring an existing DNS resolver library to do DNS resolution over different paths. The results should be used as an input to the Racing Support.

  •  Add Connection Racing Support

We want to have support for racing different endpoints based on path, transport protocol, IP version, and results of DNS resolution.
This requires opening a bunch of connections in parallel and returning the first one that establishes successfully.

  •  Add QUIC Support

We want to have QUIC support for python-asyncio-taps. Implementing this involves using an existing QUIC library for Python AsyncIO and integrating it into python-asyncio-taps. This will certainly require a lot of debugging and bug-fixing in the existing code.
Make sure QUIC streams are exposed as TAPS connections and new QUIC streams can be created by calling clone.
You make integrate this with the connection pooling support and use it to hide streams from an application.

  •  Add Support for TCP-Specific Socket Options.

Find out which socket options are exposed by Python AsyncIO and make them available trough protocol-specific TAPS properties.

 

Required Skills:
All tasks require basic knowledge in network communications (Sockets, HTTP). Experience in Python AsyncIO is helpful, but not necessary.
You will learn how to read IETF documents.

Resources
1) github.com/ietf-tapswg/api-drafts
2) github.com/fg-inet/python-asyncio-taps
3) github.com/ietf-tapswg/api-drafts/pull/295 or github.com/ietf-tapswg/api-drafts/pull/266 (will be decided next week)

Contact:

Online Graph Query Evaluations by means of Monadic Comprehensions and Adjunctions (1-3 students)

Description:

Bulk types such as sets, bags (multisets), and lists are monads, and therefore support a notation for database queries based on comprehensions. This fact is the basis of much work on database query languages. The monadic structure easily explains most of standard relational algebra specifically, selections and projections allowing for an elegant mathematical foundation for those aspects of database query language design. Most, but not all: monads do not immediately offer an explanation of relational join or grouping. However, adjunctions come to the rescue: like any monad, bulk types also arise from certain adjunctions. By paying due attention to such important adjunctions, the rest of standard relational algebra can be elegantly explained.

Graph database recently has drawn a great attention both in industry and in research communities. Upheld by the Property Graph Model, in [1], the authors formalized the Property Graph Algebra by extensions of the Relational Algebra.

Stream, as the infinite counterpart of List, the codata, in programming theory and category theory, it has similar monadic operations (and comprehensions) adjusted for it. [2]

In this project, we would like to explore the possibilities of implementation of a stream based online graph query system, based on the existed graph query language, OpenCypher[1].

Requirements:

Database Theory; Graph Database Theory; Relational Algebra; Category Theory;

Programming Theory; Functional Programming Paradigm;

Java;

Apache Flink; Apache Spark; Apache Beam; Apache TinkerPop;

Number of students (group):

1-3

Contact:

References

[1] Marton József and Szárnyas, G. and V. D. (2017), “Formalising openCypher Graph Queries in Relational Algebra”, Advances in Databases and Information Systems (pp. 182–196). Cham: Springer International Publishing.

[2] Jeremy, G., Fritz, H.R., Nicolas, W. (2015), “Relational Algebra by Way of Adjunctions”, Retrieved from www.cs.ox.ac.uk/jeremy.gibbons/publications/reladj-dbpl.pdf

[3] Bartosz Milewski (2018), “Category Theory for Programmers”, bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/

P2P information routing on multiple communication channels (1-2 students)

Mobile devices are normally equipped with multiple network connections such as Wifi, 3G/4G, Bluetooth or NFC.  Therefore, this creates abundant opportunities for mobile devices to share valuable data with each other in a P2P fashion agnostic to physical connections. The short contact durations, relatively small sharing sizes, and uncertain data availability demand agile, light weight peer based data sharing APIs. This project aims to build a P2P information routing libraries/apps that enable mobile devices to discover which data exist in nearby peers, and retrieve interested data robustly and efficiently. A set of data routing algorithms will be built to make use alternative communication channels in the context of dropping current communication channel or having access to better connections (see [1] and [2] as examples).

Your Tasks:

  • Build an library on a mobile environment, e.g Android or IOS, to support the described features on at least 3 communication channels.
  • Build a demo application with the above library.

Required Skills:

  • Basic knowledge on distributed algorithms and distributed systems
  • Programming experiences in Java/C++/Go/Javascript
  • Knowledge & Experience in network communications(Bluetooth, Wifi,…)
  • Understanding P2P

 

Related Papers/Links:

1)    Content-centric Routing in Wi-Fi Direct Multi-group Networks https://arxiv.org/pdf/1412.0880.pdf

2)    Content centric peer data sharing in pervasive edge computing environments. http://www.ece.stonybrook.edu/~fanye/papers/icdcs17-peer-sharing.pdf

 

Contact:

 

 

 

Partial Reliable Transport for QUIC (2-3 students)

QUIC an upcoming transport protocol that will be the basis for HTTP/3. Besides privacy and performance improvements, the separation between acknowledgments and retransmission enables new stream transmission semantics.

Your Tasks:
Extend an existing QUIC implementation to support partially reliable transport.
This transports can optionally turn of retransmissions based on sender-specified deadlines (don't retransmit after) or receiver-based requests to stop retransmits for individual byte streams.
Implement a small demo-application, e.g., a minimal key-value store that can replicate using this protocol.

Required Skills:
Programming in C or Rust.
Knowledge & Experience in network communications (Sockets, HTTP)

Contact:

Semantic Web of Things with Blockchain (1-3 students)

There is a great deal of interest in integrating blockchain with IoT data. Moreover, the Semantic Web is getting more tractions in integration IoT data recent years. This leads to several experiments in using Semantic Web and blockchains for sharing IoT data or similar kinds, so called Sematic Web of Things. Interestingly, there is also an effort of the blockchain community in advocating “decentralizing the Web” which is commonly promoting  the use of p2p-based distributed storage associated with blockchains, e.g, File coins[2] with IFPS[3] or Ethereum with Swarm[1].

Your tasks:

  • Set up a private blockchain network using Ethereum or similar. Optionally, a p2p distributed file system using IPFS[3] or Swarm[1] can be added to this network. Students will have access to a lab of 120 Raspberry PI nodes for this setup.
  • Integrate Semantic Web or Linked Data features for IoT data on top this infrastructure (see [4] as an example)
  • Build an application for storing, searching, and selling IoT based on the software components provided by this setup.

equired skills:

  • Basic knowledge on distributed algorithms and distributed systems
  • Understand Blockchain and distributed ledgers
  • Programming experiences in Java/C++/Go/Javascript
  • Teamwork and software project collaboration and management

     

    References and Links:

    1)    (2017), swarm-gateways.net

    2)    (2017), filecoin.io

    3)    Benet, J.: IPFS: content addressed versioned P2P fs. arXiv:1407.3561 (2014). arxiv.org/abs/1407.3561

    4)    Linked Data Indexing of Distributed Ledgers. papers.www2017.com.au.s3-website-ap-southeast-2.amazonaws.com/companion/p1431.pdf

    5)    Modular peer-to-peer networking stack (used by IPFS and others). github.com/libp2p

    Contact:

    SPARQL Query Evaluations by means of Monadic Comprehensions and Adjunctions (1-3 students)

    Bulk types such as sets, bags (multisets), and lists are monads, and therefore support a notation for database queries based on comprehensions. This fact is the basis of much work on database query languages. The monadic structure easily explains most of standard relational algebra specifically, selections and projections allowing for an elegant mathematical foundation for those aspects of database query language design. Most, but not all: monads do not immediately offer an explanation of relational join or grouping. However, adjunctions come to the rescue: like any monad, bulk types also arise from certain adjunctions. By paying due attention to such important adjunctions, the rest of standard relational algebra can be elegantly explained.

    SPARQL queries, when evaluated of their algebra operators, can boil down to evaluations of relational algebra operators. Therefore, in this project, we would like you to explore the possibilities of implementation of a SPARQL query engine purely based on operations of monadic comprehensions and Adjunctions [1].

    Requirements:

    Database Theory; SPARQL Algebra; Category Theory;

    Functional Programming Paradigm;

    Java; Scala;

    Apache Flink; Apache Spark; Akka Stream;

    Number of students (group):

    1-3

    Contact:

    References

    [1] Jeremy, G., Fritz, H. R., & Nicolas, W. (2015). Relational Algebra by Way of Adjunctions. Retrieved from www.cs.ox.ac.uk/jeremy.gibbons/publications/reladj-dbpl.pdf

    [2] Bartosz Milewski (2018), “Category Theory for Programmers”, bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/

    Timeliness of User Space Packet Processing (2-4 students)

    Moving packet processing into user space has several benefits. On the one hand, it allows to apply packet processing methologies which may bring huge performance enhancements. On the other hand, the accessibility of the implementation is improved. The latter is especially beneficial for developers and researchers as it clearly simplifies experimenting. A simple packet forwarding infrastructure can be done with less then 1000 lines of code [1]. Unfortunately most implementations/frameworks [2] focus on fast packet IO. Besides that, low latency and time scheduled traffic (deterministic communication) are important factors for many emerging applications in the field of the Internet of Things [3].

    Tasks:
    - Choose a framework [2] or a foundation [1] for your project and extend it with time scheduled
    transmission capabilities
    - Evaluate the timing behavior and performance of your implementation

    Required skills:
    - Experience reading datasheets
    - Experience with low-level programming
    - Teamwork and project collaboration


    1. arxiv.org/abs/1901.10664
    2. www.dpdk.org
    3. https://ieeexplore.ieee.org/document/8452158

    Contact:

    TSN - Field-bus Gateway (2-4 students)

    Time Sensitive Networking (TSN) [1] is a novel set of standards by the IEEE 802.1 working group which extends the capabilities of Ethernet. One of the most important features is the ability to schedule network traffic in a timed way [2]. This is critical for hard real time systems that can be found in various industries, like the automation industry. In accordance to that and with regard to the transport layer, Ethernet is now in competition with various well established but proprietary field-bus systems which are used to control time critical systems traditionally. In fact, no industry will completely replace a functioning technology (brownfield). Thus, there is a need for gateways which are capable of translating field-bus traffic to TSN traffic (retrofitting).

    Tasks:
    - Examine the evaluation board and check all required (TSN) capabilities [3]
    - Set up the gateway to forward tagged traffic in a time-sensitive way – consider different approaches
    (XDP [4], DPDK [5]) - Evaluate the timing behavior and performance of your implementation

    Required skills:
    - Good theoretical knowledge of layer 2 communication
    - Good understanding and/or experience with Linux network stack
    - Experience with Linux, scripting, system- and network-programming (low-level)
    - Teamwork and project collaboration


    1. 1.ieee802.org/tsn/
    2. standards.ieee.org/standard/802_1Qbv-2015.html
    3. minnowboard.org/minnowboard-turbot-dual-e/technical-specs
    4. lwn.net/Articles/750845/
    5. www.dpdk.org

    Contact:

    Zusatzinformationen / Extras

    Direktzugang

    Schnellnavigation zur Seite über Nummerneingabe