If you are a student looking forward to participate the GSoC 2017 with the JBoss Community, feel free to browse the growing idea list below. Please don't hesitate to contact the mentor(s) indicated in the proposal for any related clarification and to discuss proposals. Students can submit the proposals starting March 20th 2017.

If you want to suggest an additional idea, please use the page GSoC 15 Student Ideas (you'll need a free JBoss Community account to edit the page). Interested mentors can check the student ideas page and sign up to be a mentor by moving the idea onto the main page.

Idea Proposals

Category: Mobile

Overall goal is a POC of an integration of Apache Kafka and Apache HBase for processing the incoming http requests to improve the real-time experience of our push metric of the AeroGear UnifiedPush Server.

Background:

Our database is currently based on MySQL/PostgreSQL, and all of our data lives in one "UPS" schema, DB updates are handled by a JMS broker. Under high load and lots of metrics, the solution is not the best for scaling, beyond multiple millions, therefore for future scale it's worth to investigate new types of databases, and the processing of the data.

We have two main types of data pools:

Device-Installation metadata

Metric information about push

The device meta important and required for sending push notifications. Their lookup need to be fast. The query factors depend on different aspects: categories, aliases or even device-type. Currently with MySQL we have problems to create an index for the device token, because they are too long.

The metric information is very read/write intensive and currently we are unable to have a decent "real-time" approach to it. Part of it, the processing (JMS) of larger job notification jobs, causes lot's of updates on a specific database entry regarding number of messages, or their success. In addition if an app was opened due to a push notification is driven by an different factor: the client sends a ping when the app was opened using a push.

Due to the complexity of tons of push message metrics, it's possible to start breaking them out, to a different database (Apache HBase), and handle all the processing with Apache Kafka/Apache Spark, for much improved the real-time aspect of the push metrics.

Digger-Jenkins: Windows based mobile build support

The AeroGear Digger-Jenkins supports building Android apps with Jenkins on Openshift and iOS builds as Jenkins slave, but it is not supporting Windows builds.

For the project the goal is to have build support for Windows apps, orchestrated with Jenkins, so our AeroGear Digger-Jenkins can have Windows builds. Ideally we do the builds using windows containers, as well as ochestration via Jenkins. The windows containers or VMs need to be provisioned with the Windows mobile SDK, to the build process can be executed. The provisioning should be done with Ansible.

The OpenTracing standard enables distributed tracing instrumentation of applications. Although applications can directly use these APIs, framework integrations for many popular technologies are provided to allow those technologies to be instrumented without cluttering the application code. This task will be to implement OpenTracing framework integrations for a range of popular open source technologies, including infinispan and hibernate.

Knowledge prerequisite: Java, some Infinispan and/or Hibernate is a bonus

Improve the experience when running Hawkular Services on OpenShift

Summary of idea:

This topic consists of two tasks:

Improve the start process of Hawkular Services deployed in OpenShift, specifically the schema creation in the Cassandra database. Student would do that by introducing the Cassandra image (based on the standard ones) that have already the schema initialized (image approach); and also by introducing a new container whose only job would be to initialize the vanilla Cassandra container with the schema (runtime approach).

Create a source2image builder for common web application (not very different than s2i-wildfly) that would build the docker image with a WildFly and Hawkular Agent installed in it.

Category:Tooling

Angular 2 Forge addon with PatternFly

Summary of idea:

The current AngularJS addon generates AngularJS 1 code. It must be updated to generate Angular 2 TypeScript code using the PatternFly framework and also generate the NodeJS descriptor files (package.json, etc).

It should support scaffolding a CRUD from JPA entities. Bonus points if it can be generated from a TypeScript class.

Hawkular addon with support for Metrics and/or APM

Summary of idea:

Develop a Forge add-on that allows to export metrics to monitoring agents and/or instrument code for monitoring with Hawkular APM

The add-on would e.g. add a dependency on dropwizard metrics or such. Users could put an annotation on a numeric variable to say “export this” and then DW metrics shows that value in Prometheus format. Or within JMX with Jolokia.

And for APM it could be possible to already instrument http handlers with needed code. And extension could be that methods are marked by annotations to denote that they should show up in a trace.

Teiid, integration with other data sources

Summary of Idea:

Teiid is Data Virtualization engine, where it connects to disparate sources (releational, non-relational, files, rest/soap services, nosql stores) and provides a consistent and unified view of data. We are always looking for extending support for more sources. We are looking for developers for

Category:Testing

Unleash the Jester on integration tests by adding support for mutation testing in Arquillian

Summary of idea:

Mutation testing is a software testing method which is based on the idea of modifying source or bytecode in order to capture weakneses of your test suite. In other words using this technique you can test your tests! By applying different mutations, such as changing operators, variable names or throwing exceptions, to your test code you have a chance to locate issues in your code.

The goal of this project is to research the possibilities of integrating Arquillian with mutation testing tools such as PIT. Another angle would be to investigate how we can leverage Byteman in this context (some work has already been done to integrate Byteman into Arquillian).

The disadvantage of this approach is that it doesn’t allow to monitor the application in its full lifecycle as the code is injected into browser once WebDriver has fully loaded the application (once document is ready).

One of the consequences is that Graphene is unable to monitor errors reported before the document is fully loaded or it doesn’t allow to do instrumention of JavaScript APIs such as XMLHttpRequest for libraries that encapsulates references to these APIs during page loading (such as AngularJS).

The idea of this proposal is design and implement alternative approach to Page Enrichment to be able to hook into the APIs such as console.log(), window.onerror() or XMLHttpRequest object before any other script will have a chance to do so.

Add support for Screenplay pattern in Arquillian Graphene

Summary of idea:

The Screenplay Pattern is an approach to writing high quality automated acceptance tests based on good software engineering principles such as the Single Responsibility Principle, the Open-Closed Principle, and effective use of Layers of Abstraction. It encourages good testing habits and well-designed test suites that are easy to read, easy to maintain and easy to extend, enabling teams to write more robust and more reliable automated tests more effectively.

The goal of this project is to research the possibilities of allowing Arquillian Graphene users not only use Page Objects pattern but also Screenplay pattern.

Implement fluent assertions in Arquillian Graphene

Summary of idea:

Arquillian Graphene allows you to verify if some element is visible on a web page or if it contains an appropriate content, but only in the sense of waiting API. Same it is in a case of request guarding. What is missing there are set of interfaces providing fluent assertions that would allow you to more naturally specify the expected content and behavior of your web pages. An example of a solution how to implement fluent assertions is a library AssertJ.

The goal of this project is to research possibilities of implementing fluent assertion API in Arquillian Graphene and compare it with other solutions. Based on the research then design and implement it.