This project is about advancing the tool you're currently browsing. It got started back in Hack Week 9 to retire all the weird tools we've used in the past to track ideas. As you can see it has gone far but is still far from done. There are lots of features missing and bugs to be fixed on github. Get going!

The idea is to port client module of libvirt(x86) to android-arm. Currently, The project only plans to supoort kvm. The project includes a dynamically linked library and a management user interface(virsh).

Orientdb is an open source graph/document database. It supports various language bindings

Spacewalk is an open source Linux systems management solution. It is the upstream community project from which SUSE Manager and the Red Hat Network Satellite product are derived. Spacewalk uses XHTML with a CSS stylesheet that has grown over the years.

Background about openQA: https://progress.opensuse.org/projects/openqa-improvement/wiki

I like to have a Linux system that completely runs on an USB stick (read and write also for persistent storage) so that it can run

You like Linux, right ? you must like command line tools which give an quick, elegant way for your work. This project comes from the idea. "command line everywhere".

Samba and CTDB rely heavily on POSIX fcntl locks for data and meta-data integrity. This functionality was recently fixed in CephFS, opening up the possibility to use CephFS as an underlying filesystem for a scale-out Samba/CTDB cluster. Such an architecture should perform and scale much better than the existing single Samba + VFS module gateway.

Description

The RC0 release is out since the last hackweek see GFXprim pages. From that point 187 patches with various fixes, new features and new tests went in. New features includes support for various file formats, fixes and enhancements in python bindings, speedups, CMYK support, better documentation and more. Now it's about the time for RC1.

I want to boot xen with dom0 and domU on allwinner sunxi devices. A31/A20 is a Cortex-A7 powered device and cortex-a7 support virtualization extention.

Betaman is a rudimentary rails app to manage a set of beta tests and its testers. Try betaman yourself at betaman.suse.de

openqa.opensuse.org is still running on the older v1 version necessitating extra maintenance (and bringing confusion to people about which version is the right one to use). As part of this hackweek 10, we want to test kvm and alternative backends (vbox, kvm2usb) in openQA v2, fix them if needed and finally deploy the current version.

There is a grub2 available for powerpc for a while. Let's switch to it by default.

Currently compute supports only IVM managed pSeries machines. In that case machines are not managed for central place. There shouldn't be a big deal to implement HMC support as IVM commands are pretty much similar to HMC.

Documentation

What is it?

Gems-status (http://github.com/jordimassaguerpla/gems-status) is a command line tool that creates a report about the gems used in an appliacation. The most import result is the security alerts. However, this tool is being configured using a yaml file, which has to be updated with new information every time there is a security alert.

This project is mostly about automating spec file formatting to have all specs more look-alike, much better for review and there is no need to force people to write that way, just to format it afterwards is sufficient. Other task is to track changes in osc repo and adjust changelog accordingly. Format spec file tasks:

Currently, only pidgin is support multi-user chat over Groupwise Messenger protocol. Telepathy (and therefore Empathy) doesn't support it, despite using libpurple from Pidgin project. (https://bugs.freedesktop.org/show_bug.cgi?id=13127)

If a SSL connection failed, you often get only a very cryptic openssl error message. Write a tool which check for the typical errors and report the real reason for the failure.

Wifi direct (P2P) has been implemented in WLAN drivers and wpa_supplicant. I would like to work on 2 machines connected each through wifi direct.

Documentation

Problem statement

Current Zend Framework OpenID implementation does not support the protocol version 2.0 fully. For example the Yadis discovery is not supported at all. Thus the Zend Framework OpenID module can not be used with OpenID providers using this version of the protocol.

Crash has some support for per-cpu variables, but it really only works for static variables. My idea is that you should be able to take a per-cpu pointer and see the formatted data. The syntax should allow to specify a CPU or do it for all: crash> percpu $CPU <type_name> <address>

This would fix the two 'biggest flaws' in the current software installation workflow. Basic support for detecting file conflicts is already provided by libsolv, but it needs to be integrated into libzypp. In order to support rpm %posttrans behavior, zypp needs to collect these scripts during package installation and execute them at the end of it's transaction.

Ticklist is a web application enabling users to record their ascents of climbing routes as well as to maintain their personal list of currently projected routes. My implementation went from working alpha back to pre-alpha status (~ basic things not working) while migrating parts of the codebase (knockout.js -> angular.js). The goal of this hackweek project was therefore to finish this migration and fix the basic features in order to make the app useful at least for personal usage. The current technology stack is node, express, sequelize, jade (templating), angular and twitter bootstrap. Lots of future features come to my mind, like showing advanced statistics, integration with social networks, support bouldering ticklists as well, location based stuff, and so on.

There is now bunch of yast devtools but the most of them are obsolete or useful only for ycp developement, which is now dead. It is also mixture of tools to build package, develop single package and new yast meta for doing changes on all modules developed by yast team. So goal is

A few months ago in a random post-PyConAU fit of hackery, I got disk-image-create in TripleO's diskimage-builder project running on openSUSE 12.3, i.e. you can now run disk-image-create on an openSUSE system, and have it create, say, an Ubuntu system image. Time to take the next step, and make it capable of building openSUSE images ;-)

Nodejs is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. It uses NPM as its packaging system. This hackweek project will create a npm2rpm Ruby gem to fully automate creation of (openSUSE) RPM packages.

The webui is currently the poor cousin of the OBS parts even though it's wildly used. It's a pain in the ass to code for it as there is not a API for most things you need to do - and if there is it's cumbersome to use.

Improve OpenStack documentation and tools used by it. Major idea: Improve openSUSE documentation

Base on internal user request, Id to create the dispatcher script for NetworkManager allow run up/down script for DNSMasq when a VPN connection was started. In the current setup when VPN is started via NetworkManager no scripts is run. In the case Id like o add this script into NetworkManager package so it can be use by others SUSE users as well.

Yandex.Disk is a free cloud storage service (like Dropbox) that gives you access to your photos, videos and documents from any internet-enabled device. XBMC is an award-winning free and open source (GPL) software media player and entertainment hub that can be installed on Linux, OSX, Windows, iOS, and Android

DAPS, the "DocBook Authoring and Publishing Suite" provides a tool set for easy creation and publication of DocBook sources on Linux. DAPS lets you create HTML (incl. webhelp), PDF, EPUB, man pages, and other formats with a single command. DAPS is used and developed by teh SUSE documentation team.

PLAN

We have Ruby now, yay! But the developer documentation still quite sucks [the old version is shown in that link]. We want to fix that.

Based on the hackweek 9 project from Flavio I'm playing around with <b>docker</b> and Linux containers.<br> My goal is to have a private image store with several openSUSE and SLE versions ready to use.<br>

Browse the in XBMC on your TV :)

Preface

In a previous hackweek project (https://github.com/SUSE/hackweek/wiki/osc3%3A-port-osc-to-Python3) I have converted osc code to Python3. This has triggered quite some weirdness regarding plugins, but osc is usable from python3. Or it was, not sure if more recent changes did not break the compatibility.

Introduction

OBS can build not only build traditional RPM packages, but it can even build appliances or installation ISO images.

Create a framework for running tests distributed across a number of hosts. The goal is to be able to run tests for things like

There are several use cases where it's beneficial to be able to automatically rearrange VM instances in a cloud into a different

The supportconfig utility is used by support teams to collect all information needed to troubleshoot a system in one shot. The objective of this project is to create a central repository of supportconfig tarballs. To do so, we're going to develop a set of tools to automatically fetch tarballs from known sources, parse the information, import the useful parts into an SQL database and expose it in a Web front-end where users can run some simple queries.

The main goal is learning Ruby and enough Ruby on Rails to hack on the hackweek tool and fix (what seems to be) a simple issue like this . For that, I'll have a look at the following tutorials/documentation, and probably follow a couple of them:

I need to finish my work from the last hackweek * github repo

Implement better UI for Weblate using Twitter Bootstrap library.

Twopence is (will be) a remote execution engine for tests, able to run tests in virtual machines and real hardware through various means of communication : virtio for KVM / QEmu, ssh on top of libssh, serial lines. This library can be called from shell and ruby wrappers. While it is already functional (and used), it still needs polishing, stabilizing, and extending. It is also planned to integrate it with Pennyworth (project Machinery) and let it go fully Open Source.

I would like to change the way "quilt setup" is implemented. At the moment, we call rpmbuild and intercept the calls to tar and patch in order to record the location where archives are extracted and the order and options of the patches which apply to them. Then we replay that record to create our own quilt-compatible source tree.

There are more and more devices with no Adobe Flash plugin support in web browser (new Android and Apple phones and tables, etc.). The aim of this project is to replace Flash testdrive in SUSE Studio with HTML5 client. So our current implementation bases on our project from a previous Cloud workshop which uses noVNC.

Improve some OpenStack projects and contribute patches to them. I plan to look at improving manila (https://wiki.openstack.org/manila) and OpenStack infrastructure in general.

Sometimes a user might want to build her own kernel instead of using the provided binary, for various reasons. This means creating own .config and maintaining it through kernel version bumps, which often results in running "make oldconfig" and mostly holding down the enter button to accept upstream defaults. What I envision instead is a way to say where I want my own config to deviate from the distro default (as provided by e.g. kernel-stable on openSUSE), and only those options will override the distro default configuration. This distro default configuration is always updated for new upstream releases, so there should be no need to (manually or automatically) accept new upstream defaults, thus less risk of producing a broken kernel, as e.g. any new kernel options will be configured in the distro kernel so that they work with the distro itself (while upstream defaults might not be safe or desired).

The base version for uselessd is systemd-208, which is the version used in 13.1. Let's try if a direct substitution of the binaries works and watch out for the problems. Expected result of the project is to have a working package with "Conflicts: systemd" and "Provides: systemd". The goal is not to fix all problems, a stripped down system with uselessd is considered a good achievement. Anything more complicated could build on top of this.

OpenSUSE support for OpenStack Training Labs

Tracking and fixing translations in modern applications is a surprisingly complicated task. Visible strings often come from several projects, and strings can be processed by a complex formating. The project should extend the current project trace-wrappers to easily display string sources inside the application. The project successfully reached a working state: watch gettext

Figure out how to get SUSE VPN running on Android.

In GCC we have multiple intermediate languages and for all of them we do manual pattern matching and replacement. The project uses a domain specific language to unify and simplify those pattern matching and replacing code. During hackweek I plan to split out working parts to merge to GCC trunk.

I want to modify the driver so that it:

• a) supports newer hardware

I like to try out if it is possible to write a program that does not have any kind of the traditionally separated documentation (like external files that contain the documentation texts or comments in the program code). Instead all documentation must be implemented as code at the same place where the matching functiomnality is implemented (i.e. each function implements also its documentation). In the end the user should get only the executable that he can run to let it do the intended functionality and also to provide any kind of documentation. What I do not want is a dumb '--help' option that lets the program spit out its built-in documentation. What I would like to have is that the user can run the executable in some kind of self-inspecting way. I mean: While it does the intended functionality, it can also provide documentation so that the user can explore the program while running it. In the end the user experience should be more like a text adventure ;-)

The idea is to play around with a minecraft-like block exploration game, written from scratch in C using SDL2 and OpenGL 3.0. Minimal dependencies, probably won't be a game as such before the end of the week, but the goal is to have a world generated and to be able to walk around in it. Why? Mainly to refresh my 3D knowledge, catch up with what's happened since I last played with that stuff, and to have fun. :) * Source code

1) Add support for the Microsoft Azure File Service REST protocol to Elastocloud, a cloud storage client library created in a previous Hackweek. 2) After completing (1), create an Elastocloud VFS module for Samba that intercepts filesystem IO and locking operations. This would allow for the creation of a globally accessible Samba share backed by cloud storage, which could also be accessed by VMs deployed in the Azure cloud.

Description

Travis provides nice integration with GitHub, it can automatically run tests for every commit or every pull request.

The UEFI image for QEMU/AArch64 is available in the openSUSE build service now. However, there is no openSUSE image for that setup. This project is to make openSUSE run on QEMU/AArch64 + UEFI and this may be useful for the openQA in the future.

Seems that there is currently no good way to check which python modules are outdated in devel:languages:python . AFAIU http://osc-collab.opensuse.org could learn howto handle information from pypi and set the attributes "UpstreamVersion" and "UpstreamTarballURL" for the packages.

Look at the NIS RPC protocol, enable IPv6 where possible, document where not. Try to find out what Solaris is doing.

Currently python2 and python3 packages are completely independent. Would be imho good to build py2 and py3 versions from a single source (as Fedora, Debian & Ubuntu do already). There was already a mailing list post about this: http://lists.opensuse.org/opensuse-packaging/2014-09/msg00000.html

Use my work supplied workstation to set up SUSE Cloud under KVM and deploy several instances of servers.

• czech translation
• [ ] turn antialiasing off -> [x] font antialiasing

AngularJS, Websockets, REST APIs for mobile apps, one-time links for emails — what’s the topmost complexity all those things share in common? It’s authentication. Authentication typically means sessions, and sessions are simply ubiquitous state for our stateless-by-design web.

Spacewalk has its custom client stack. Salt stack provides a big bunch of it, but it is a popular community project and add other features on top:

I want to learn Rust and improve my cryptography skills, so I'll be solving the matasano crypto challenges in Rust. The source code for the challenges I had time to finish is on my github

Adding additional features to the YaST "Security Center and Hardening" module. -> procfs: add hidepid= and gid= mount options

The kdumpid tool can be used to determine the kernel version from a crash dump. Some useful features are missing: - support for new compression methods (lzo, snappy)

Intro

In order to be able to throw pies faster and distribute them even to remote SUSE colonies, we need to build an advanced antimatter-fueled pie hyper-accelerator.

Sonic Pi is a live-coded software synthesiser for teaching computing via music. It originates on the Raspberry Pi but should be on mainstream Linux too. This project is to clean it up by removing Raspbian hacks, package it and its dependencies and get it running nicely on openSUSE. Sonic Pi uses Ruby to control the synthesiser, and the frontend is written in Qt.

KDE Frameworks 5 is already quite stable but most big applications have not been ported yet. My plan is to work on digikam (and its libraries, libkdcraw, libkipi, libkface, libkgeomap, kipi-plugins) to port them to use the latest KDE libraries version. To be more precise, I plan to work on the job framework and its thread support since ThreadWeaver's API has changed a lot and after talking with Caulier Gilles (digikam's main author) he was interested in that. This is part of libkdcraw, but if I finish early in the week, I'll continue with another of the libraries.

The Parallella is an SBC with Xilinx Zynq SoC and 16-core Epiphany-III co-processor. I had contributed a device tree for the Parallella to v3.17 (with a network/clock issue just reported by Olof Johansson to be investigated).

A broad range of ARMv7-A boards have been enabled in openSUSE already. I would like to complement my experiences by bringing up Linux on an ARMv7-M board, the STM32F429I discovery board, featuring a Cortex-M4 and 8 MB SDRAM. As first step I would build and deploy an image based on instructions from the Internet, using downstream U-Boot and kernel and known-working binary arm-uclinuxeabi compiler toolchain. As preparation I have already packaged the genromfs tool.

tiedot is a general purpose, document database engine designed for both embeddable usage and running stand-alone DB server, implemented in Go. Despite the effort of partitioning collection data and indexes, a single tiedot process still cannot scale beyond 4 CPU cores due to limitations of both data structure and Go runtime. Last year, an attempt began to partition data across multiple tiedot processes, and use IPC for communication and database logics. Initial benchmarks show promising scalability improvement using the new implementation. So let us complete the new implementation together, to bring the most scalable & embeddable DB engine for Go programs!

In past it was needed these project to be developed together due to unstable API of Gammu. This is now stable and having python module in the code just makes the things harder. The code should be separated, use standard distutils and have testsuite. In future it should also support Python 3, but that's not the primary goal now. The work has already started:

The project's goal is for Beijing GNU/Linux User Group port a self-hosted online communication tool. We discovered lets-chat project suite for our requirements, but it need more encryption. So, my primary work is deployed the lets-chat project in my VPS, and then try port a OTR encryption implement for this project.

As OBS can install various distributions, it should be in theory possible to abuse this functionality to create distribution independent way to create rootfs tarball. Done: https://github.com/openSUSE/obs-build/pull/166

Maybe it is yet another wheel

but still worth to do. The original idea is come from https://xmpp.net/.

On February 12th, 2015, the DMTF released version 3.0.0 of the System Management BIOS Reference Specification. This update isn't just adding enumerated values to existing structures, as previous updates did. It is also introducing a new entry point format which allows for larger tables and structures. Support for this needs to be added to dmidecode. Additionally, reading the entry point and the table from /dev/mem is no longer possible on all systems, so some work is in progress to offer an alternative interface through sysfs. It would be great to finalize this and release a new version of dmidecode that would support both SMBIOS version 3.0 and this new kernel interface.

Basically the idea is to boot inst-sys but to not run YaST and instead run a selfmade script that does the usual disaster recovery steps:

Twinkle, my favourite SIP client, seems no longer developed, has been accused of "bitrotting" and even dropped from some distributions. While I don't believe in bits actually rotting, there is one pressing issue: twinkle uses Qt3. While there are some patches reportedly allowing to build twinkle with Qt4, e.g. here, all seem to use a Qt3 compatibility layer of Qt4 which has been dropped in Qt5, AFAIK, so that those won't be very future-proof either.

Get an overview about the unofficial Google Drive clients, which exist for Linux. Give them a broader testing. Figure out which one is usable. * grive: With using that client I've seen fatal issues, e.g. I've created a folder upstream and uploaded some files to it. When running

Meet up NBG meeting room Paris with fellow Ruby on Rails hackers, throw an editor/shell onto the wall, grab a cup of coffee and refactor OSEM code together. That way we can share knowledge about setting up the development environment, editor tricks, RSpec patterns, gems or general rails code. Interested? Join us!

Get more familar with Greasemonkey User Scripting, in particular with using the IITC framework, which manipulates Ingress Intel map. The goal is to create a plugin, which highlights portals on the map, which have more fields than links attached. Ingress account is required for this (Android/iPhone). * <a href="https://www.ingress.com/&quot;&gt;https://www.ingress.com&lt;/a>

There's a crmsh history guide in works for a very long time and it really really needs to be finished. Good and interesting examples are very welcome.

Use Jenkins as a Travis replacement for YaST

Introduction

The idea is about virt-manager improvement. It calls libguestfs to provide 3 features for virt-manager:

OpenQA uses the VNC protocol to interface with a test system. This limits test systems to be virtualized. Bare metal (physical) systems do not provide VNC out-of-the-box.

While the python-based AppArmor utils (aa-logprof etc.) are much easier to understand and maintain than the old perl code, there are still some terribly long functions like parseprofiledata() in aa.py that are not too easy to understand. Also, using hasher() (a recursive array) as storage can have some strange side effects. Another problem is that test coverage isn't too good, especially for the bigger functions. I already wrote the CapabilityRule and CapabilityRuleset classes (and also the BaseRule and BaseRuleset classes) some months ago, and changed the code to use those classes. This code is already in upstream bzr.

Proof of concept for a story and test runner for cloud testsuite. Cloud Matrix

I'll try to generate KDE4 and KDE Frameworks 5 packages for SLE12. After talking with plinnell and tittiatcoke, I refocused the project to generate mainly KDE4 packages and KDE5 packages if time allows it (instead of just KDE5 packages as I originally thought to do)

devel:languages:perl has 2662 packages, but many of them are outdated because it's just a fight no man can win to update them. So we update them whenver we hit a problem. But this is evil: I count 2662 packages in devel:languages:perl and 1188 of them are outdated. So I'll write a script... just as we did with gems

virt-builder main repository contains quite a few distro images, but no opensuse one. The goal of this project is to make OBS able to create a virt-builder repository out of a few kiwi packages. Ideally this would later be used to provide some official opensuse images for virt-builder.

Look into the design of the new experimental Mozilla Servo browser and try to build/run it on your machine. Servo Github page

The idea would be to setup an internal tmate.io server to make instant command line collaboration easier.

Futexes are complex enough that make it a good candidate for applying fuzzy testing techniques to the various inputs and operations that can be performed. Instead of re-writing any testing infrastructure, make use of the trinity system call fuzzing tool. While trinity does apply fuzzing to futexes, it does so with very limited knowledge, using only generic callbacks to the different steps involved. As such the main goal is extending testing coverage and making it more ad-hoc.

Cause the original [BLUG website](beijinglug.org) is too old and lack of security, so we plan to fully rework for this website. It will following such steps:

The FlightGear is a free and open source flight simulator. To introduce what FlightGear offers, there is a official getstart manual for beginner. The getstart manual written in English, so I try to translate it into Chinese, and add support for CJK character.

Our beloved competitor developed and use project-wide message bus called Fedora Infrastructure Message Bus. This project was already adapted, or is being adapted, also by Debian community. During Lucky Thirteen I want to get deeply familiar with the concept and implementation, deploy test scenario and write plugins for OBS and openQA to talk to each other.

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:

I'v been doing the testing on device mapper, once there are some regression it's very hard to debug without block-layer knowledge.
I'm very interest on how the kernel handle the bio/request/request queue/elevator system.I think this is good chance to read and learn .

Minion, the job queue of the Mojolicious web framework, currently has to be administrated with command line tools. I want to build an Admin UI that will make the most common maintenance tasks, such as restarting a large number of failed jobs, a lot more comfortable.

Hackweek 17

free hugs for hackweek

While I despise Trello, I quite like the idea of using a Kanban board to organise my individual work and much of my personal projects So if I have time during Hackweek I plan on looking at https://wekan.github.io/ also

Results: * https://ikapelyukhin.github.io/

need to learn more about containers

motivation

I like light weight presentation frameworks based on plain text files. There are quite some frameworks using the browser for presenting but many require a full blown web server. remark seems to be about the lightest I could find. I could make actual use of it when there would be openSUSE(/SUSE) branding.

moin, i am looking for interesting articles that describe how to refactor/maintain golang code. At moment i found this.

Introduction

TensorFlow™ is an open-source software library for Machine Intelligence written on Python. It was originally developed by researchers and engineers working on the Google Brain Team within Google's Machine Intelligence research organization for the purposes of conducting machine learning and deep neural networks research, but the system is general enough to be applicable in a wide variety of other domains as well. (https://www.tensorflow.org/)

I will deploy a k8s clusters on three pine64 A+ boards, all boards are installed opensuse tumbleweed, and one as k8s-master two as k8s-minions. The whole cluster will use TLS and BRAC security mechanism.

Setup an iscsi server on minnowboard/espressobin/odroid c2 based on opensuse tumbleweed, use two Nics to support multipath Setup an iscsi initiator on odroid c2 and dm

The the LUKS UUID in /etc/crypttab. In general the file system UUID is already used in /etc/fstab. So using the LUKS UUID in /etc/crypttab is a small step towards consistency and should make the system more robust (e.g. avoid bugs like bsc #1063249).

The ZSTD is a new compression method, potential replacement for existing methods. The support has been added to linux 4.14, but the bootloader support is missing. Goals:

Build Stages

Travis-ci.org currently has nice beta features that I've wanted to try for a [long while(#https://travis-ci.org/foursixnine/openQA/builds/280652163)...

To be able to offer real Tumbleweed and a tested Leap for a Raspberry Pi3 the images for it need to be tested with openQA. Since

During my trip to and from SUSECon 2017 I had been working on a pinctrl driver for Actions Semi S500, based on a previous pinctrl driver of mine for Realtek RTD1295. Goal of this project is to complete the driver with pin definitions and muxes.

In os-autoinst and installation/bootloader_svirt.pm we currently we support only one-disk scenarios like SLES installation to disk and deployment from a disk in JeOS & CaaSP scenarios. To support RAID tests we need support of adding multiple disks to VMs. Targeting Xen and Hyper-V.

Try various container operating systems & kubernetes distributions and compare them to SUSE MicroOS and CaaSP, respectively.

In lieu of official hosting which was requested a year ago, go ahead and refactor approach to work on AWS S3. The previous approaches used either soft or hard links to avoid duplicating files that remain unchanged between snapshots, but S3 is not a file-system and does not support links. The closest comparable concept are object level redirects, but managing and creating those would be combersome, slow, and result in a higher bill. To avoid that an alternative that does not require object level redirects to simulate links, but that does not requiring duplicating files would be preferable. In addition the tool built to provide such snapshots on S3 should be easily deployable and setup to run automatically on AWS.

Planning to do some deep learning course sessions e.g. fastai , google ML crash course etc. Also try to understand common tools (tensorflow, jupyter notebook, numpy, pandas, pytorch) and practices e.g. Convoluation neutral nets, SGD used to solve learning problems. Aim is to get ready for kaggle competition (https://www.kaggle.com/competitions) eventually to test out learning and develop intuition around categories of learning problems.

About 3 years ago I wrote some Python and Kivy code for my Samsung Galaxy S4 in QPython. Unfortunately, QPython updated and broke its kivy compatibility. I've been waiting for them to fix it, but mostly have given up. So instead, just investigate how to turn the kivy code into an .apk for installation on an Android device! There are directions for this on the kivy website.

What is kompose? kompose is a tool to help users who are familiar with docker-compose move to Kubernetes. kompose takes a Docker Compose file and translates it into Kubernetes resources.

Explore the GraphQl (v4) GitHub Api and do a small project in (Elixir would be the choice)

Starting from prometheus ( and grafana if needed), learn how to monitor kubernetes and docker and do some valid alert/graph etc. https://docs.docker.com/config/thirdparty/prometheus/

Description

Experiment with and implement a server (openSUSE Kubic, SUSE CaaSP) with connected thin clients (Raspberry Pi) that executes GUI applications from docker containers running on the server.

Mental poker is a principle and also specific protocol to play card games without a single trusted party. This includes shuffling cards, enforcing card visibility and commitment schemes. Imagine playing rock-paper-scissors via phone only. libTMCG is an implementation of the protocol and SecureSkat is an application of this protocol/library to the popular German card game Skat.

The usual baby-phones and phone based surveillance solutions do not fit my needs: - We live in townhouse with reinforced concrete walls (the signal from the babyphone is not strong enough)

2018

new hack

motivation

Lots of crucial steps in the SUSE/openSUSE product build workflow are not known or not even accessible by many people but hidden as "custom scripts" on "some machine" in the worst cases. Nowadays infrastructure and build pipelines should be written as code, e.g. in git repos, with UI frontends to show the always current state of what is going on, what needs to be done to release products, where are problems. The least we can do is learn a bit more in this direction.

Currently helpers for maintenance of SLE/openSUSE such as osc omg exist just as git repo, lets have them as packages.

The openSUSE.org official infrastructure is getting bigger and complicateder, so #microservices and #serverless FTW! :smiley: :thumbsup: :icecream:

Glowing Nixie Clock * A Nixie tube (English: /ˈnɪk.siː/ NIK-see), or cold cathode display, is an electronic device for displaying numerals or other information using glow discharge.

All our packages have a *.changes file and ideally that file would mention relevant changes from upstream, i.e. during version updates. Currently, we find that information manually when packaging Haskell software. This is unsatisfactory because of the sheer size of the package set and the massive number of updates we receive from Hackage. The packaging itself is completely automatic, but editing the *.changes files is not and this issue prevents us from shipping more packages in Tumbleweed and elsewhere. Now, during this Hackweek I'd like to write code that given two Haskell package versions old and new can determine the upstream changelog entries between those two and create a pleasantly formatted entry for the *.changes file that won't need any manual editing to pass the review team. Then I'd like to integrate this into cabal2obs, or maybe even cabal2spec.

In day to day job I often wait for openQA job to change a state. I plan to create chrome plugin which would allow to watch for some certain job and will send you notification when run is end.

I need to get a basic understanding about MD software RAID setup only via command line tools to be able to understand,

Explore the possibility to have a self sufficient frontend server running locally. This server would compile all the frontend code and act as a proxy/middleware pointing either for a dev ref-server or to a local SUMA instance. This way would be possible to do modifications in frontend even without having a SUMA server running locally. http://imagebin.suse.de/2542/img

Some ideas from the list: Small ones:

What is it about? I write lots of notes, about almost everything. Writing is a very important part of my work and of my organization in general.

git-deps and hatop deserve some more native packaging love. let's improve this and make a good package for multiple distros when possible.

SSO for kanku

As we use kanku for testing/debugging our OBS Appliance images.

I want to connect to matrix.org via weechat in Leap 15.0. 1. I need the matrix script

I want to improve myself in Perl & Mojolicious and I want to have a nice open-source self-hosted message board / forum written in Perl. Let's combined it into one ultimate goal. I would like to have:

Background

Candidates

For testing some of the upstream Linux drivers we maintain it is necessary to emulate the hardware as we're getting bug reports for the upstream drivers but have no chance to test fixes. Once the upstream drivers can be emulated we could focus on emulating hardware where only downstream drivers do exist and then write new drivers to be upstreamed.

Every time we went to UEFI Plugfest, one of the frequently asked questions is how to setup a PXE/HTTPBoot server. Besides, we also have to setup and test the server before the event. Although we already have the document(*), it may be easier to deploy with a container image. My goal is to learn how to package a container image in SLE/openSUSE and create a flexible image for the fast deployment of PXE/HTTPBoot server.

I want to dive deeper into React using its Material-UI components to prototype a web interface for SUSE's new Repository Mirroring Tool (RMT). Updates:

Leap 15 and TW supports Transactional Server system role but some additional work is needed to have a transactional desktop system role. The purpose of this hackweek is to document what need to be fixed and try to fix it.

We provide tftp server and RPMs containing the installer to run from tftp. Disadvantage is, that the user needs to setup a tftp boot system first. Why not putting everything in a container, so that the admin only need to run the container and can then choose on the to be installed machine, what he wants install? And following this, put the container in a kubernetes cluster like SUSE CaaS Platform.

Signing metadata requires a lot of manual interaction and knowledge of the customer. This was the reason why we never implemented it for SUMA as the benefit was very low. Now with the change in the zypp stack to not allow installing unsigned RPMs without user interaction or completly disabling GPG checks the benefit of such a feature increased.

Build a smart thermostat using an Adafruit Feather HUZZAH ESP8266 board, a DHT22 temperature and humidity sensor and a 2.4 TFT touch panel. The requirements are:

(was: Create a DRM driver for Matrox G200) Even after 20 years, the Matrox G200 series is still an excellent 2d graphics card. Unfortunately, there's only an fbdev driver and a user-space driver. Both are obsolete, as modern Linux uses the DRM framework for managing graphics cards. There already is a DRM driver for the G200 server series. This driver is under-maintained and doesn't work with desktop chips.

Update

Working on the documentation...

This nowadays is a supported HANA Scenario that has no much knowledge and documentation around. This project is basically to explore what we currently have, and maybe document some initial good practices around SAP HANA Scale-out to facilitate future developments and also our current supports.

To make it easier to debug openQA and Cavil i want to build a plugin similar to the mod_status Apache module for the Mojolicious web framework. Figuring out how to combine HTTP and WebSockets should be interesting. If time permits i also want to make it look a little bit like the Minion Admin UI from my last HackWeek project.

I bought and started reading this book a little while back and also "played along" by creating unprivileged LXC containers on my own system. I would like to continue this exploration by reading on in the book and creating, configuring, managing, destroying... further containers.

Motivation

GPUs are widely used for parallel computations and CUDA is platform which simplifies development of such applications for NVidia GPUs.

First thing you learn, when you start with salt, is to use test=True before you really call the highstate. This is not yet possible from the SUSE Manager UI.

Add some features to libstorage-ng. - Support for F2FS

I'd like to write a tool that reports user's OBS work done in a given time frame (eg. week). It'll collect all the packages he/she submitted, all the reviews done or all the maintenance updates started or processed.

For every instance of OBS, each time the obs-api package is updated the obsapidelayed service is reloaded. This takes more time than is expected. Task to be done are:

** UPDATE ** After a week of hard but passionate work we have managed to finish the first version of The SUSE Game with a surprising final!

I currently have a lot of personal infrastructure that is in need of some tender loving care and transactionalisation https://rootco.de is running on a Leap 42.3 Hetzner box. I'd like to replace this with something transactional (either Kubic, Leap 15 or Tumbleweed transactional server)

• Check packages that I maintain or are in devel projects that where I am maintainer and update them.
• Check bugzilla for issues filled for said packages

The goal of this project is to get an overview of the state-of-the-art technology on training and deploying machine learning projects with kubernetes and apply that to a SUSE CaaSP cluster. With that in mind, we will train and deploy a model for summarizing github issues:

SUSE Quiet is an acoustic version of SUSE Loud, the former SUSE Band from Maxtorhof. We will be making our debut on Thursday evening at the Hackweek Party.

I'll have a look at Hyper-V 2019 test build and how SLES guest plays with it.

I plan to learn Go, first by going through the official 'Tour of Go', then implementing simple caldav client to help me with work reports.

The vacuum cleaner from Ecovacs use XMPP (or at least something very similar to it) to communicate with their respective mobile apps. Based on the things available in https://github.com/wpietri/sucks and https://github.com/torbjornaxelsson/bumper I'd like to implement a small replacement for the server side to be able to run that on my local server.

Deploy openSUSE Leap 15.0 image to Linux subsystem on Windows Server 2019 and try things around.

Docker for Windows 18.03 CE supports Linux containers on Windows Server. Let's try that.

There are a lot of open source projects out there. They have a wide spectrum of governance models. It's a critical component to the success of a project so it's worth learning from others and consciously deciding on how governance is set up for a project. It's also a critical factor to assess projects and a subject for research. To facilitate all this a map of the models in use is a helpful resource. This project is about collecting data about open source governance models, make it available in a machine-readable form, and provide an overview via a web page.

Monasca is a powerful tool in the OpenStack arsenal. It brings metrics and alarms to the operator. It even pairs grafana with horizon. It currently monitors Swift, but just the processes. But there is so much more we can grab. Swift actually generates heaps of metrics. For one It has supported sending metrics via statsd for years. All the internal daemons send statsd. Further, built into each server is a reconnaissance API (recon), that you can hit over REST or by using the swift-recon tool. Swift operators have been using these for years.

SmartOS is converged container and virtual machine hypervisor based on illumos, an OpenSolaris fork. SmartOS supports KVM & bhyve hypervisors and illumos, LX, & Docker zones ("containers"). There are LX-branded openSUSE & SLES images unofficial. LX-brand is implementation of Linux API on SmartOS (similar to Microsoft's Windows subsystem for Linux).

Matrix (https://matrix.org/blog/home/ ) is a slack / rocket-chat clone, fully decentralized. It supports a lot of clients and bridges to various networks, including IRC.

The most important task for my first hackweek - accessibility of the Gnome Shell. There's the project called gnome-shell-mousewheel-zoom - not maintained for 6 years.

Let's see how correctly the FreeBSD emulation layer works.

When using files that should be in an accessible file system, quite often I have been in a situation where * I couldn't find a document by name but remembered attributes like 'document' (unclear which format) with '> 12 pages' and dates from '2011 - 2015'

SUSE Studio was shut down earlier this year. It has been online for more than ten years and there are tons of links and references out there. To not make them lead into the wasteland of 404 we should have a landing page on https://susestudio.com which leads to what users can use instead of SUSE Studio. I did a mockup of a page which could be hosted there. See it at https://github.com/cornelius/goodbye-dister.

Synopsis

JRuby is an implementation of Ruby on the JVM. It aims to be a complete, correct and fast implementation of Ruby, at the same time as providing powerful new features such as concurrency without a global-interpreter-lock, true parallelism, and tight integration to the Java language to allow you to use Java classes in your Ruby program and to allow JRuby to be embedded into a Java application.

Update: Ruqola ('zypper in ruqola') is now in Tumbleweed and Leap 15.2! For Hack Week 19 (Feb 2020) main goal is to test, polish packaging, potentially do fixes and select a snapshot to submit to openSUSE Tumbleweed. Upstream made one release but it was not optimal, development pace has sped up a lot lately and the client has become more stable and usable.

I want to learn more about robotics. The goal is to have a small robot at the end of the week. Since I have no clue of what I can do with robotics / what is possible I leave it open what the

SUSE Manager uses an ivy repository on the R&D network to get the packaged jar to build against. To remove the manual maintenance of that repository and allow external contributors to hack the Java code of Uyuni / SUSE Manager we need to provide an Ivy plugin that gets the jars directly from OBS.

I have previously implemented a major portion of the C++ standard library for HelenOS [0][1][2] as part of my master thesis. In this project, I will be adding

I plan to work on libgphoto2 Lumix WiFi support. Status after Hackweek:

The Parrot seems to have many fans meanwhile, in particular since we're running Rocket.chat at SUSE. Some may find these emoticons distracting, some find it just cool and I would certainly love to see something like the Partyparrot but as a "SUSE parrot", probably someone manages to make the SUSE Geeko move in a similar fashion, as party_geeko. Finally I'd love to see this uploaded to the cultofthepartyparrot.com under "Party Guests". Because clearly the Geeko insists! :-) Bonus: do the same with TUX for total ssǝuızɐɹɔ

The idea is to look at some technologies: - C++17 parallel execution

Use mouse to select a word on the screen, popup a small icon, click icon, then show a window to display word online translation result.

motivation

Many people ask how to start with openQA, ask "can you run these two lines in bash in an openQA" test and some shun the effort to try out openQA because it is "too big".

We are running the geekos app at geekos.prv.suse.net since some time now in the SCC CaaSP cluster. The goal we have is to bring this to production in the CaaSP cluster maintained by the engineering infrastructure team.

Description

On aarch64, ppc64le and x86_64, there is a common os-autoinst backend called qemu, in which qemu is launched from an installed SLE.

LanguageTool is a style and grammar checker for 25+ languages https://languagetool.org Packaging it will require packaging the following maven packages and their dependencies:

Given that free time is always a scarce resource, I'd like to use the hack week to work on v2.0 for OTPClient Github project: https://github.com/paolostivanin/OTPClient/projects/4

During the previous Hackweek I did a workshop in a Montessori school. This time I would like the same but with focusing on Robotics. Who is this for?

I would like to convert a very cheap foam toy plane into a radio control plane Materials

In order to see the SPD (detailed memory information) data, the user currently has to manually load the needed kernel driver. Which driver to load depends on the memory type. Depending on the driver user, the devices may even have to be instantiated manually and this is a non-trivial multi-step task. Plus you need to be root to do it. I would like to attempt to automatize all this at least in the most common and simple cases like Intel x86 desktop. The idea would be to figure out the memory type and the I2C address of the SPD EEPROMs based on DMI data. If the DMI data is of good quality then it should be possible to automatically figure out which driver to use and to instantiate the devices at boot time.

Produce a ~3 min demoscene using modern javascript libraries combining graphics with original music.

The youngest architecture addition to the mainline Linux kernel was C-Sky (arch/csky/). I have a GX6605S board booting a downstream 4.9 kernel. It uses a proprietary GxLoader bootloader (similarities with U-Boot exist but no sources...) with uImage and gx6605s.dtb files in a FAT partition on USB stick.

I maintain the mailprocessing utility, a Turing complete maildir and IMAP capable filter with rules written in Python, both upstream and in openSUSE. It is currently suffering from some performance problems I'll devote my Hackweek (or part of it) to improving. Most notably the following areas will need some attention: * Ability to deal with large inboxes. This one is already done and I have been using it myself for a while but not released, yet. If you urgently need it feel free to grab it from the master branch. I'll give it another once-over before release, but it should be fine.

Few weeks ago whilst analyzing the possibility of using Terraform[1] via terraform-libvirt [2] plugin, I came across Terratest [3], which is an automated testing framework. My initial thoughts have been written here [4] but I'd still like to check out Terratest in more detail.

Learn Rust by following The Rust Programming Language book.

So far the style (color, shape, ...) of the devicegraph output of libstorage-ng is hard-coded. The user of the library should somehow be able to customize the style.

Following the work started in the last hackweek, Improve OBS service scripts, I will try to migrate current service script for workers to systemd unit, and at the same time, try to get rid of the sysv code.

Create a sound board that has the following requirements: * Works in Browser

The idea is to have a friendly way to access live cluster's nodes, compare outputs of simple commands and find out differences in tables data / structure. Current state: implemented and tested scripts which split table into ranges and then for each range check rows count and rows checksums.

When all of the SUSE Manager squads switched from SCRUM to a Kanban we lost estimations and therefore also the ability to do predictions. But there are other ways to get insights that are even more reliable, since they are based on anecdotal data. The lead and cycle times of issues are the two most important here. I'd like to extract those two for all of the issue from the spacewalk project and explore how they can be visualized in meaning- and helpful ways.

Create a new generic CUPS wrapper backend /usr/lib/cups/backend/monitor that runs in parallel with the actual backend to monitor it.

Following trademark and licensing issues with Grafana, explore the possibility of debranding Grafana and use that in SUSE Manager (and maybe others) Products are available from GitLab: https://gitlab.suse.de/susana

At SUSE Manager and Uyuni we use right now a set of bash scripts called sumaform-test-runner to run terraform and cucumber, send notifications and store cucumber results. However such scripts are currently hard to maintain and extend, and bash is clearly showing it's limitations when it comes to parsing cucumber results, working with JSON stuff, or using APIs. Besides it forces us to have credentials hardcoded at the main.tf files, which is a huge problem for making a public CI for Uyuni.

We've (mostly @cbruckmayer) put a significant amount of time into our performance measurement dashboards based on influx/grafana. I want to share this with the world because it's most awesome and easy to use. It's also nice if people don't go to some PaaS provider just for this...

Currently, the SUMA test-suite takes about 6 hours to complete, often fails in the first tests, which set up the environment for the rest of the tests, those tests are what we named "core features". To solve this problem we had planned to move from Jenkins Job to a Jenkins Pipeline, having stages to split the test suite into core features, initialize clients, secondary features. So,if one stage fails, the rest of the stages will not be executed.

There are attempts to solve some kernel deadlock with using lockless printk ringbuffer. The proposed implementation is pretty complex (6 stages, 6 write and 6 read barriers, two buffers, entries linked via list, ...) I have a idea how to make it easier with tracking the state and sequence number in one atomic variable. It might allow to remove the lists and many barriers. It is possible that it will just not work. Let's see.

Try to prototype an interactive dashboard for parts of the data available on SMELT.

Background

motivation

As an openQA contributor I could learn from openSUSE release managers how the overall process can be improved.

The goal is to run the Elastic Inference Demo managed by kubernetes on a Raspberry Pi4 Cluster with openSUSE Kubic. * The openSUSE Kubic image should configure itself correct at the first boot with ignition.

This hackweek I'll be working on Kanidm, an IDM system written in Rust for modern systems authentication. The github repo has a detailed "getting started" on the readme. Kanidm Github

Project here: https://confluence.suse.com/display/AAI/HackWeek19 Will keep working out of HackWeek as "best effort" personal project to make it evolve and keep learning.

There are multiple reasons for this project. First, I want to re-cap my ruby programming knowledge. Secondly, this course is available on pluralsight. This is project for 1-day, where I plan to continue and create some project and dive a little bit deeper into it. Here is the url for anyone interested: https://app.pluralsight.com/library/courses/code-school-rails-for-zombies/table-of-contents

Goal: I'd like to have the release process defined in markdown/git and use it as a source for process creation in redmine.

You can encrypt your servers root filesystem, but need to provide a password during the boot process in order to "unlock" and start the system. This is easy if you have physical access to the server by entering it via keyboard. But if you do not have physical access it's not that easy. This project is about to set up a server that might be able to have an encryted root filesystem which can be "unlocked" by entering the password via ssh.

The ESP8266 is a low-cost WI-Fi microchip with full TCP/IP stack and microcontroller capability. I want to explore the features and (in case of success) attach a BME280 to get temperature, humidity and barometric pressure information streamed over WI-Fi. As the price of both components is just around 10 EUR, this would be a nice add-on for my weather station at home...

Create a gnome-shell extension inspired from an Android app floating toolbox. floating toolbox

I want to create an exporter for a X instagram profiile using the Instagram API. The exporter should export some metrics on my user and then I can build perhaps some useful dashboard

I'm building a web-site for my drawing/painting things. This hackweek project I want to do more frontend related stuff like javascript/clojurescript and html for improving the layout and so on of the page.

qemu-devel.opensuse.org is a port forwarder to * 2 ARM Server

Research on BI tools to crawl eg. SCC data. This is an internal project, tracked at SUSE Confluence.

Acronyms are fun. Everyone at SUSE loves them. Just sometimes… you might not know what one stands for.

For a very long time, I have been planning to play with Crystal as possible substitute/complement for Ruby. With that goal, I have isolated a very small subset of the Ruby project I know the best (yast-storage-ng) and I want to migrate that subset to Crystal to get a general feeling about the language. See the repository with the experiment already in progress. There is no evil plan to migrate YaST to Crystal. This is just done in the Hack Week spirit of "what if". But if more people join maybe we could get this to an state in which some benchmarks can be executed to check what's the real gain in speed and memory consumption using Crystal instead of Ruby (note: speed and memory are not the only goals of the migration).

We have ActiveJob instrumentation in the OBS code base and a couple of panels in our grafana. Move this upstream to influxdb-rails. - OBS code

Start awesome/people-management and properly announce the awesome setup.

Move our agile team check, with some more elaborate assessment, online to office365

This hack week project is an Unity3D app, available in Android, IOS and HTML5 platforms. The idea is to welcome new joiners inviting them to play this game. The game will have questions about SUSE, the new joiners will need to ask other SUSE employees for the correct answer, socializing and learning SUSE culture at the same time. When they win the game an e-mail will be sent to a concrete e-mail address (it might be someone from facilities) and they will receive a small gift as Welcome Pack. For instance, they could receive the small chameleon or a t-shirt.

Upstream

• https://github.com/tmux-plugins/tmux-resurrect

Hamster is important for may daily workflow, as I'm using it for time accounting. While hamster-time-tracker-2.2.2 itself, as shipped on Tumbleweed, depends on python3 only, the build process requires python2. It's therefore in danger to be kicked out of the TW repos. Updating to 3.x will likely require some homework. Edit after hackweek 19: Almost done. Hamster 3.0-beta is available from the "Office" project on OBS. This took more efforts than foreseen though, because I got involved in beta testing and ended up testing, fixing issues, and going through tedious discussions with the current lead developer.

The admin-tools appimage provides several samba team YaST packages in a portable way, such as yast2-aduc, yast2-gpmc, yast2-adsi, and yast2-dns-manager. Currently I build the appimage on obs, but this pulls in lots of unnecessary dependencies. Making it build independently would allow building on other distros. The difficult part here is going to be building minimal YaST dependencies.

Join the Gitter channel! https://gitter.im/uyuni-project/hackweek

Last year I developed Terracumber and, for the moment published it at one internal GitLab repository. We intended to replace the set of scripts we have to launch sumaform for the Uyuni and SUSE Manager CI, but lacked adding the monitoring part.

This project could get us rid of the last fbdev drivers we're stil shipping: efifb and vesafb. Platform drivers handle hardware that is not auto-detected, but somehow there. For graphics this would be VGA, VESA, or UEFI framebuffers. In SUSE Linux, we currently support VESA and UEFI with fbdev drivers. Those load early in the boot process and maintain graphics hardware until the actual driver takes over.

In financial markets traders try to win money buying cheap and selling expensive. To do that they need to understand what is going on on the market and also what will do the market in the future. So the idea is, if they have methods to do that, why can't we use it to understand what is going on in my business?

French ISP Free is providing a xDSL / Fiber modem, which includes a lot of features, including integrated NAS support and, more recently, allowing to run your own VMs (https://dev.freebox.fr/blog/?p=5450 sorry, in french) Those VMs needs to run as aarch64 guests and might requires some adaptions for easy install with the modem webUI (cloud-init support, etc).

The KEF LS50 Wireless are audiophile grade powered speakers that are fairly Linux friendly. But so far they can only be configured via an Android/iOS mobile app. I want to reverse engineer the custom binary protocol used by the apps, and build a simple Linux application to reconfigure things like DSP settings on the fly from the terminal.

The idea of this project is to learn more about SAP Gardener and its capabilities. Evaluate potentials and eventually include some capability around CaaSP that does not yet exist there.

Pinebook Pro SPECIFICATIONS

Last hackweek I created the pnp soundboard -> https://github.com/Devp00l/pnp-soundboard This time I want to encourage other people then myself to use it :)

I'm missing really badly the tool f.lux in my openSUSE machines. I really appreciate its usage specially when I'm using the computer late night. https://justgetflux.com/

This is a follow up to https://hackweek.suse.com/projects/architecting-a-machine-learning-project-with-suse-caasp. In the last hackweek I learned that in order to run machine learning workflows on top of SUSE CaaSP, the missing piece is to have libnvidia-containers and nvidia-containers-runtime-hook packaged.

"Egunean behin" (means "Once a day" in Basque) is a really popular Phone app/game in the Basque country. https://www.codesyntax.com/es/proyectos/egunean-behin (sorry, the description in english doesn't exist yet...)

There used to be a tool called tel that would show information about a user including his phone number, room number, etc: $ tel tux

Extend Stratos (https://github.com/SUSE/stratos) by adding the ability to integrate open-source Analysis tools such as Popeye, Kube Score, Anchore, Clair etc, so that users can run these tools on their clusters from Stratos and view the results from Stratos. Allow results to be viewed contextually - so errors/warnings from an analysis will be shown on the appropriate view - e.g. the namespace view, pods view etc.

The goal is to package terraform-provider-libvirt on Homebrew to deploy the SUSE SAP and HA automation on a remote KVM host from macOS. Result:

https://github.com/Johni0702/mumble-web To improve user experience for less technical users, a browser-based client would be cool.

A Community member at FOSDEM requested MicroOS for SystemZ - spend some time at Hackweek looking at it

For my 40th birthday I got from my friends a very special present, an USB Accelerator that brings machine learning inferencing to existing systems: https://coral.ai/products/accelerator

I am trying to build a cheap Kubernetes cluster on top of Kubic. * The purpose is to have production personal cluster.

In order to inspect rpm dependencies inside the distro I wrote some python command line tools that leverage libsolv. Since navigating the ball of wool that is the result of solving a package is on the command line, I'd like to create a web app. Implementation by means of Flask, bootstrap and jquery to keep it simple. UI should be entirely created on client side with Flask only server json endpoints.

The current geekos install at http://geekos.prv.suse.net/search is not reachable for employees outside of engineering. We want to move it to the SUSE IT maintained EKS cluster to make it available for all.

Project Description

A few months ago, the YaST team released cockpit-wicked. Compared to YaST, this module contains a pretty simple data model, but there is still some duplication with YaST logic.

Project Description

I plan on continuing on with my Linux Kernel Library efforts from Hackweek 19. This time I'd like to spice things up a bit by plumbing USB devices into LKL, allowing reuse of native Linux USB host and filesystem drivers on non-root Android.

Project Description

The idea for project starts on LEO workshop. The main goal is to provide UI for local configuration that allows easy transition to 1:N management. So here is vision:

Project Description

• Complete the pull request from rust2rpm that will help bundling crates in RPM

Project Description

Join an instructor-led bootcamp to explore the Rust programming language in two-hour sessions each day throughout Hackweek.

Project Description

Qualcomm concentrate on supporting recent SOC, older ones aren't supported (use very old downstream kernel, e.g. 3.10).

Project Description

Project Description

I run openSUSE TW and FF with i7-5600U Intel CPU. Calls with ~4 (video) participants work but my CPU load is approaching number of cores. In slightly bigger calls (>=6 participants) the CPU load was insufficient and audio packets were being dropped. I'd like learn more about webrtc video streams in order to reduce the client's CPU work or make it more adaptive when running with limited resources.

Project Description

A local RMT mirror will run out of space at some point because rpm files, which are not referenced by repomd.xml anymore, are left behind.

Project Description

The aim of the project is to run a sample microservice app in Kubernetes. A simple app will be written in Python and work as an online store comprising of frontend, orders, and products services. (could be more!!)

Project Description

This project aims to speed-up and simplify setup for analysis of application core files provided by our customers.

motivation

Test automation can be fun and openQA is good at it but it has limitations. This project is meant to find out where the limits are for applications with lots of things moving on the screen, e.g. a game. Completely unrelated, web based tools become the norm for many users, e.g. when working from a chromebook or similar environments. The idea here is to try to use only web based tools and not force users to use a terminal which can be frightening :) As a third requirement: Some people are not feeling comfortable using openQA "because tests are written in Perl". This is not necessarily true because tests are rather written using a simplistic test API and only a small subset of Perl knowledge is necessary, however, we still want to support other entry points so there is Python support added in https://github.com/os-autoinst/os-autoinst/pull/1558 . To find out what this new way is capable of this project should use only that Python support and find out any restrictions.

Project Description

I've been using open-source video editing software like Shotcut before and I used to be pretty happy with it. Nowadays, however, I need more sophisticated workflows that allow me to process n-log video, do color grading, synchronize video and audio from multiple sources, have better looking effects, and so on. I've reached the point where Shotcut just can't do what I would like it to.

Project Description

GTK+ software for two-factor authentication that supports both TOTP and HOTP.

Project Description

I've had a fairly modern AMD GPU for some time, but I haven't had time to check the current status of neural network based video editing. I know many are proprietary CUDA specific, sadly, even if projects themselves would be open source, but I'd like to check which ones would support OpenCL as well or any other means to use an AMD GPU with fully open source stack (including drivers).

There are couple of projects I work on, which need my attention and putting them to shape: * M2Crypto

Relax-and-Recover (ReaR) is used to recreate a destroyed system on compatible replacement hardware, see https://en.opensuse.org/SDB:Disaster_Recovery Currently ReaR requires basically 100% compatible replacement hardware.

Project Description

There are multiple network benchmark tools already, most popular probably being netperf and iperf. Each of them has its pros and cons but the biggest drawback probably is that netperf runs only one connection (flow) and while iperf can use multiple connections, it still runs in a single thread. For benchmarking of contemporary fast networks like 40Gb/s or 100Gb/s ethernet, this can be a severe limitation as the performance is often CPU bound. Even on 10Gb/s ethernet, we are often unable to saturate the medium if tunneling or complex packet processing is involved.

Project Description

I'd like to have NeoMutt show an index of emails at the same time as the body of the selected email, horizontally next to each other.

Project Description

Create a JS library to get the output openQA logs (autoinst-log) and

Project Description

Study Google Motion Photo file format, which records a short video clip in addition to actual photo in the same jpeg file.

Project Description

PyYAML is a YAML processor in python, and it was one of the first libraries written for YAML.

Project Description

Sometimes when we reproduce a customer issue, it doesn't always demonstrate the same behavior the customer is having. So, we engage backline or open a bug or throw up our arms in frustration. I have one such customer with just an issue like this. Running the exact same commands in an almost identical sles4sap version environment and yet I cannot reproduce what she is seeing? What to do?

Project Description

Kanidm is a identity management system (a store of accounts, groups and more) that supports authentication to opensuse, web sites, networks, and more. The project has a focus on respect of humans, correctness, simplicity and performance. In previous hackweeks we have implemented cryptographic authentication (webauthn), wasm based web UI and more.

Project Description

A lot of people are using mechanical keyboard. Having a custom SUSE-branded keycap would be cool. The idea is to create a set of 3D models for such keycaps in various profiles for everyone to print.

The world is changing. A mouse got lose and fell off the discworld. Consequently the elephants got scared and hopped off Great A'Tuin's back. As luck would have it a gigantic crab with four gophers on its back took its place.

Project Description

Project Description

As part of the mojo.js project i want to port the Minion job queue from Perl to TypeScript and release it as an npm package. In the future this will allow parts of Mojolicious applications like openQA to be written in TypeScript/JavaScript (in addition to Perl).

Project Description

I want to build an HTML-based demo kiosk to host images and videos that run on SUSE Linux on a touch-enabled AiO system.

Project Description

Several Hack Weeks ago we started to rewrite Jangouts from its current AngularJS-based implementation to a more modular one in which the UI was developed in React.