The title of this project is inspired from the must-see video John Hughes - Testing the Hard Stuff and Staying Sane

The afl fuzzer is an interesting tool that uses compile time instrumentation and genetic algorithms to automatically produce test cases that will trigger different code paths in binary... http://lcamtuf.coredump.cx/afl/

git rebase is a very useful construct in source control management, as it allows you to re-apply your changes atop a different branch of the same repository. While this concept transitions perfectly to container management (updating a container could be as easy as a docker rebase), and the Docker client is inspired by the git semantics, Docker has no such feature (in fact, Solomon Hykes used rebase and merge as examples of things "that we don't want"). Currently, zypper-docker works by applying an updated layer on top of an existing image. While this does work quite well, it separates the process of updating the base image and updating all of your derivative images (you need to re-download new packages for each derivative image). So, this project will be working on implementing something like git rebase for Docker images. There are several issues with this, mainly involving the fact that we are rebasing binaries and not source code, so merge conflicts will probably be quite messy. But it should be possible to implement some form of simple rebase method (which will essentially fall back to docker build in the worst case, which is what you were going to run anyway). By maximising the reuse of the existing image layers, it should be possible to reduce build times quite significantly.

As detailed previously on devel and opensuse-factory the KDE team didn't have access to their bugs and could not actively subscribe. This is changed now by introduction of opensuse-kde-bugs@opensuse.org mailinglist.

We currently have a set of shell scripts that verify if patches can be properly installed on multiple combinations of base products, extensions and modules. These scripts are all written in shell and are annoying to maintain, as configuration and code is all mixed up. My objectives are: (a) to rewrite all the scripts in a single tool, in Python; (b) separate code and configuration, so that adding a new product/SP requires only editing a configuration file; and (c) make the checkers more flexible, allowing execution from the command line against specific repositories (use case: checking one single maintenance incident before submitting it to QAM).

The basic idea is is to boot the plain SUSE installation system (inst-sys) but to not let it run YaST. Instead inst-sys runs Relax-and-Recover (rear) as generic installer that does the system installation.

There were several attempts to integrate ABRT to openSUSE. In this Hack Week I'd like to: 1. review those attempts;

• learn how to code on golang
• create a script for docker testing (bash or python)

motivation

jenkins is a great CI system (continuous integration) with a plethora of plugins available. SUSE QA uses openQA extensively as it excels in distribution and product testing - not only image comparison (common misconception ;-) ). How about combining both in using jenkins with plugins to act as a UI for openQA?

It's a CTF like game, where the goal is to unlock "lock" devices. Having access to a disassembled code you have to create an input that will unlock the device by exploiting a bug in its code.

See README for description of the Dove-eye project (poor man's Hawk-Eye). The main goal is to make 2D object tracking from a single camera more stable, so that it's reliable for 3D localization.

Challenge

The salt-minion client-side agent is still a bit hefty due to its dependencies and SUSE's strange Python packaging. Let's see how to create a minimal salt-minion packaging.

I want to use this hackweek to get some practice with git and rst and maybe more specifically, as a project, to set a blog written in rst and hosted in github.

French government provides a pretty up-to-date data set with the gas prices in France as open data. These data could be useful in the offline GPS application [Osmand][1] for drivers to find the cheapest nearby place to buy they gas.

Let third parties to get notifications about build failures without having maintainer rights

The download end-point of Spacewalk/SUSE Manager resolves the packages from channels dynamically with a database query. With the integration of Salt into SUSE Manager we have the chance to rethink this.

Networkmanager uses some simple dbus interfaces of firewalld to allow configuring a firewall zone for connections. FWZS offers similar features on top of SuSEfirewall2. I'd like to adjust fwzsd to provide the minimal interfacess NM needs to offer the firewall integration.

Currently, dealing with forkbombs and similar issues with Docker and runC is not very nice (you have to set a global limit for all Docker processes or you have to limit kernel memory which isn't very practical). I'm going to work on getting some [patches][2] merged into runC and Docker to enable PIDs support for Docker.

the Taipei office lacks automatic printer discovery so everyone has to download and install some weird "driver". That's not the Linux way of doing things. So set up a cups server and do proper printer announcements with that one.

Goal

• Organize a general developer mentoring program

In the kernel repository, we have a script that checks users/* branches and does some basic checks on them. My plan is to teach this script to detect kabi changes.

Dovetails are nice to assemble wood pieces... but not that easy to do. The project is about creating a template to create dovetails with a router and of course create dovetails. I prepared all the maths before hackweek to plan my actions (and buy hardware). See this geogebra file for the details.

Create a wrapper which receives the URL passed to the "firefox" binary, offers a list of available profiles, and finally runs Firefox with the selected profile and the given URL. https://github.com/olafhering/firefox-profile-selector

OpenStack uses Zuul as a pipeline manager to test changes posted on gerrit. The rpm-packaging initiative (https://wiki.openstack.org/wiki/Rpm-packaging) needs to test proposed changes. So building packages with OBS for proposed changes is the goal of the project.

Fetch and display openQA status project group per project. Helpful when we have a combination like openSUSE:Factory and openSUSE:Factory:PowerPC

Hacking on OBS dashboard requires you to have a "real" data from staging projects. this is done by quering backend directly. So either you need to have a production db deployed or you have old broken data. Let's ask the real OBS for current staging status with external API.

So far CUDA driver for Tesla card is only available as Ubuntu deb. Try to find sources in it and create SLES12 rpm

We have various individual tools to automate parts of the Haskell packaging process, like cabal-rpm, but those tools aren't integrated into a fully automated system that keeps Haskell packages up-to-date with as little human intervention as possible. I would like to build that system. Stackage provides us with an accurate list of packages and versions that are known to work together well, and there are basically two flavors: the nightly snapshot (bleeding edge) and the LTS release (stable API). The former is appropriate for Tumbleweed, IMHO, and the latter is appropriate for stable releases like SLE or Leap. Now, we can use cabal-rpm to generate spec files automatically for all packages in a Stackage release and check them into OBS. The process does need some tweaking, however, because cabal-rpm generates spec files that don't always work well for SUSE. We could (a) branch cabal-rpm and add SUSE-specific know-how to remedy that issue or we could (b) maintain a set of patches that adapt the generated spec files to our needs. Once the Stackage releases are available in an OBS development project, we need another automated process that submits all updated packages to openSUSE:Factory, etc.

FATE#319830, FATE#319843 and FATE#319842 propose integration of AutoYaST with different software configuration management systems like Salt, Chef and Puppet.

kanku make's installation and testing of kiwi images built by OBS very easy. https://github.com/M0ses/kanku

kanku make's installation and testing of kiwi images built by OBS very easy. https://github.com/M0ses/kanku

It is not a about make a new software. It is a service in fact. Everyone working in Beijing Office struggles with the tortoise network speed when doing zypper.

Gordon

A collection of autotests for Crowbar

Quotes from xrdp wiki: https://github.com/neutrinolabs/xorgxrdp/wiki/Xorg-drivers-for-xrdp "At first, xrdp used Xvnc only for the X11 backend. Later X11rdp was used as the X11 backend as another option to Xvnc. X11rdp has definitely proved itself as a superior replacement for Xvnc. Xvnc is limited to the VNC drawing primitives. X11rdp was built for RDP.

In many cases, people want to start containers on a system where the administrator is not happy about granting privileges to users or installing any new software. For example, when I was a researcher and wanted to run Python 3 on a computing cluster it was not possible to get the administrator to install Docker or Python 3. In recent Linux kernels, it has been possible to create containers without any privileges. All that's missing is a container runtime that allows you to do this. LXC is close but falls short (it requires certain privileged processes and PAM modules for everything to work).

The kernel compile and link itself is only a fraction of the OBS kernel-default package build. Several other passes take significant time: - Post build checks, especially the clamav scan

All other distributions have scanmem/gameconqueror packages. scanmem is a command line memory scanner to locate variables in memory and GameConqueror is the Python/GTK3 front-end for it which also provides game trainer features. But it is not only a game cheating tool. It can also help testing applications, debugging memory issues, watching variables in memory or it can be used for reverse-engineering. Hackers also use it for things like ping spoofing. As the upstream maintainer of this tool I'd like to bring it to openSUSE and maintain it there.

The SUSE Manager team currently uses vagrantup.com to create developer environments (a project known as suminator). Doing the same with terraform.io and the terraform libvirt provider we could:

Look at bcache and start adding support in libstorage-ng. It should be possible to implement probing during hackweek.

The translation repo: https://github.com/beijinglug/fsfs-zh

In this HW I would trying learn about how to modeling aircraft in FlightGear, which is a free and open source flight simulator.

The goal of this project is to get a familiar with NativeScript, play with it and create one or two simple demo applications. Maybe even something useful ;)

Previous hackweeks spent on research (project/220), other alternatives. This time I'm

The project is about taking a fresh look at Crowbar UI for SOC provisioning. Main goal is to mock user workflows that would allow to scale Crowbar to support multiple datacenters, a more flexible way to add large number of nodes and manipulate services, as well as control and customize various types of hardware groups. <i>Note: Bellow links and images might not work without VPN enabled</i>

py2pack is the prefered tool todo Python packaging for openSUSE. There are multiple issues. The one I want to focus on is the dependency detection which is tricky for Python packages.

Results

Submitted upstream.

Prepare the module and concept done for the CSM Workshop and prepare it for upstream inclusion. Upstream plans to add some hooks to make it possible to automatically snapshot different stages of state.apply.

Right now internal SLE development is still organised & structured around the concept of 'Milestones'. Schedules are defined, deadlines are set, and off we go making Alpha 1, 2, 3, Betas 1, 2, 3, RC's, and so on. Meanwhile, QA has evolved, and with openQA and other automated tooling we are increasingly testing SLE in a more agile, rolling model, testing every single build as soon as it's produced by OBS, and just paying extra attention to the Milestones with additional manual testing.

terraform-provider-libvirt adds libvirt support to terraform. Thanks to other projects using it, there are several pull requests open. The goal is to include the features that are ready to be merged.

Salt seems like a technology that's spreading around and more and more people are using it so I thought I'd learn more about it. I plan to create or use existing VM's to monitor and manage them with salt in order to learn more about it.

https://www.gitbook.com/ allows you to combine repositories on https://github.com with a simple to use WebUI for writing books. As result, your crazy content in your README.md (or whatever *.md) files will become available for your customers as book in form of a pdf, epub or mobi download. This hackweek project is about to learn new things and try to do something useful by collecting all my former experiences in a book that is on my TODO list since more than 10 years now:

Nuremberg recently received room booking displays that would in theory show the current occupation of rooms. Unfortunately they are Windows CE based. And they don't actually show anything useful because we don't use Exchange. So instead, it would make a lot of sense to show something useful on them. Bookings for their respective rooms for example.

openbuildservice.org is the landing page of the Open Build Service free software project. It could use a fresh design.

We need statistical analysis and key performance indicators to describe the lifetime of maintenance and release requests in IBS, for example: - How long does an update take starting from the time the first maintenance request is created and stopping at the time the update is released to customers?

kanku is designed to give you a better integration of your kiwi images built by the Open Build Service (OBS) in your development and testing workflow. The idea is to refactor kanku-scheduler so it can use distributed workers for more scalability using the following technologies:

Mission: Our company org chart consists mostly of teams + their project managers. teams.suse.com is an application that gives an overview about the various SUSE team resources like org-chart, office locations, mission descriptions, links to team pages/blogs etc. It should combine the various data sources that are already there (eguide, floor, externaltools etc.) and provide a way to enrich this data.

During the last GSoC, Jangouts was ported to work on Angular 2. Among other goodies, like the component-based approach or ditching the $scope thingie, Angular 2 leverages the use of observables thanks to its integration with RxJS. However, when the project started, our student (who did a great job) had to fight^Wwork with a beta version of Angular 2 and, unfortunatelly, the API changed before the release of the final version.

Currently the upstream LTP is executed by a hacked up and old runltp script that executes even worse and fairly old mess called ltp-pan which in turn actually executes the test cases. This whole thing is a unmaintainable mess that should have been replaced with something simpler a long time ago. It should also have a few more features that has been requested in the meantime and not implemented since nobody wants to touch the code. For instance executing the test cases on a different machine via ssh and writing the results locally. Another feature I've been thinking about for quite some time is a parallel test execution, since most of the test cases in fact could be executed in parallel which could easily speed up the test run twice. There are other tests that cannot, mostly stress tests, but also test cases that modify global system state, i.e. system time, make use of sysv IPC, use loop devices, etc. These kind of tests should be annotated somehow so that we do not end up with a test cases competing for a global resources in a parallel test run.

Create a task tracking tool that would suit my needs (and enrich the pool of such author-only-optimized software). - TUI interface

GeekoScreen - an open-source based whiteboard

Idea

The Problem

The first thing one should do when resolving a bug is to find out, whether that bug wasn't encountered and perhaps even fixed before. Using our internal Bugzilla's search, that can be long and painful task. I don't know if I'm querying it wrong, or if the problem is the amount of bugs (> 1M and growing quickly), or the number of users, or simply the Bugzilla itself. Also another problem is that some bugs have wrong metadata, which makes the efforts to narrow the search a bit harder.

motivation

The one mobile messaging service that shall not be named destroyed the world of "unified communication" by constructing a walled garden in recent years although there was a bright outlook with XMPP/jabber in before bundling all communication by providing an open standard and especially transports. I would like to revisit the state in 2017 and combine my text chat based communication needs from different end devices, namely my work notebook and my private smartphone.

TL;DR Use convolution to find type candidates, then solve system of equations to refine the result. You are given a set of memory regions. And set of types (structures) that can possibly be present in the regions.

Use dwz (dwarf compressor) from rpms find-debuginfo.sh to reduce debuginfo package size. Aim for multi-file mode which would create a "base" debuginfo package that individual ones

The next generation libstorage-ng is still missing support for some filesystems. The task is to implement all of them: - ext2 and ext3 should be easy since ext4 is already done.

Want to play with Alexa skills development. The focus will be integrate Alexa with a Chromcast device. A user should be able to cast content (such as a YouTube video) with their voice.

I have Raspberry Pi with WLAN and an additional network module which can be run as a WIFI access point.

Plan

For some of us, Jangouts has become a tool we use everyday. It works (most of the time) and it helps to reduce the impact of having a distributed team. In the past, Jangouts developers were busy making it to work. But, unfortunately, they didn't pay attention to UX. So the idea of this project is to invest some time trying to improve usability and make Jangouts looks better.

Leap integrates packages from several SLE codestreams and Factory. In order to keep an overview of what package has which version and in which project an overview is needed. An obs plugin similar to the Factory dashboard could probably do the job. Prototypes using the REST api are at

My German reading and speaking skills suck. I've forgotten everything except "Mehr Bier, bitte". A week of intensive immersion ought to enable me to order food as well. And converse with my German team members. Especially when we go out for meals and drinks. This should have a concrete goal, so I will write a short story in German to demonstrate my amazing new fluency*.

Collecting and presenting statistics on the various aspects of the openSUSE:Factory/openSUSE:Leap:* staging process would be useful for determining if changes in tooling and automation have an impact on the workflow. Some examples or information of interest are as follows. request

Mitmproxy is a totally awesome tool to investigate http- and https-traffic and thus is a very useful debugging tool.
I built a package for mitmproxy some time ago, it resides in OBS project devel:languages:python called python-mitmproxy. This needs some love: It fails to work nowadays because its dependencies moved on, and requires an update. I am also sure there could be a better home repository for it.

Docker & Yast

Goals

Build opensource swift language package for Leap 42.3, Leap 15.0 on OBS. https://swift.org/

These project have two sub-object. * Develop a lite edition photo manage tool, use to export photos from cellphone, memory card and other usb device. It can mange the photos by Exif information (such as date, location, and lens information).

When GoldenDict enable scan popup functionality, if you want GoldenDict to show popup window, you need to select word by mouse and at same time press ALT or CTRL key. You can't show popup window only by mouse when needed. Add a function, when a word was selected by mouse, nearby the word there will be a small flag, when you move mouse on the flag, popup window appears.

For Relax-and-Recover (abbr. ReaR, RPM package rear) I like to implement a new kind of "backup" method:

Make openSUSE the first distribution to support LetsEncrypt/ACME natively, in order to provide easy TLS encryption for all services. openSUSE users should be able to 1. Request certificates for associated host names and keep them up-to-date.

https://software.opensuse.org/ is aging. Richard made a proposal using Jekyll to statically generate a new layout: https://software.opensuse.org/newsite/, code at https://github.com/sysrich/new-software.o.o

MALLOC_CHECK_ and MALLOC_PERTURB_ variables are environmental variables which help identify problems with Glibc's malloc() allocations. I intend to set them "globally" for every process via /etc/environment file and see, if test suites behave in usual way, identify problems.

Mojolicious is a web development toolkit and framework built around an event loop. That has many performance and scalability advantages, but can also make debugging slow code a bit of a challenge. Especially in big projects like openQA, where Devel::NYTProf can be a bit tricky to use, it would be nice to have more built-in diagnostics tools at the event reactor level. Mojo::UserAgent already has very good diagnostics features with MOJO_USERAGENT_DEBUG, and we should be able to do something similar for Mojo::IOLoop.

For far too long openQA instances are crippled by insufficient I/O throughput when under heavy load. This results in incomplete and aborted tests prolonging new snapshots testing and also adding confusion into the release process. OpenQA itself doesn't require any exact technology for its remote workers, but so far we relied on NFS. This was fine for few workers, now with 50+ of them this stopped to be a viable route however. There are some custom made mitigations like rsyncing tests, assets and needles before the actual test job run, but this feels like reinventing the wheel to me.

Fedora 25 has enabled Wayland by default for GNOME. Tumbleweed ships with Wayland too, but how far can we go in removing X11 components and get a X11 server free system, while keeping X11 applications support.

In the spirit of learning more python and practicing I will be creating a script to automate the work report emails that we send every week. This will not be a simple cron job because I have to catch corner cases of vacation etc. The next step is filling the workreport automatically by using the various API's that we can use (Bugzilla, osc qam plugin). The purpose is mainly to learn a bit more python.

You know Tetris, right? You know Telegram, don't you?

Control you openQA instance from an Amazon Echo!

How cool is that?

In openQA we support various backends which are able to 'host' tests. 'svirt' - one of those backends - is so generic that it allows to conned to a virtualization host via SSH a perform shell commands directly. As VirtualBox has decent command line interface (especially VBoxManage command) it shouldn't be that hard to support VirtualBox in openQA's os-autoinst via svirt backend.

By default, let's encrypt allows to get domain for server where you resolve an HTTP challenge. This is sometime not possible to setup (because the server you want your SSL certificate isn't running a HTTP server). Such example is my Synology NAS, where I don't want to have a Internet facing HTTP server, just to get a SSL certificate.

The Mojolicious web development toolkit is currently limited to using TCP/IP sockets for its HTTP/WebSocket client and server. For most web services that's more than enough, but for containerized applications and IPC, UNIX domain sockets could provide significantly better performance and security. Use cases would be for example faster communication between Mojolicious application servers and NGINX reverse proxies, or a WebSocket alternative to the D-BUS message bus currently being used by openQA.

CVRF is a standard where security advisories are encoded in a XML format. We are currently not generating such a format, but it seems to be getting more attention.

Take time this week to take care of the packages I maintain at Debian; open bugs, fix bugs, new upstream versions, enable testsuites in autopkgtest.

Mycroft is an open source artificial intelligence platform (an open source assistant) and has very nice demos like: Mycroft Plasmoid Version 2.0 and Akademy 2017 presentation (this one starts around 2:30) .

From the mediagoblin.org website: "MediaGoblin is a free software media publishing platform that anyone can run. You can think of it as a decentralized alternative to Flickr, YouTube, SoundCloud, etc."

The project

Currently we at SCC team are working on RMT -- a repository mirroring tool and SCC registration proxy, that will supersede functionality of SMT in SLES15.

Patches for supporting SGI Octanes are floating around since ages. The latest version is against v4.10. I've talked to Ralf Baechle (MIPS kernel maintainer) and he is willing to take patches from me... so I have to provide them... and this what this project is for:-)

It's a pretty simple idea. Be able to deploy an SMT using Docker with minimum effort. Basic Outline:

I'd like to gain practical knowledge about machine learning / TensorFlow / scikit by trying out simple examples.

Do some 3D printing incluing designing the object.

OBS started distributing live events through a rabbitmq and Bernhard's obsbugzilla scripts can use that as an additional source to update bugzilla with reduced and more uniform delays, e.g. within 30 minutes of the last SR relating to a given bug.

Kdenlive is refactoring its timeline to be based on Qt's data models and a QML view. This work is not yet finalized so any help there is appreciated by the developers. There is a board tracking the current blockers for a first release with this new timeline: