text:
# Flagship-css

A collection of all country flags in SVG - Inspired and based on
[Lipis/flag-icon-css](https://github.com/lipis/flag-icon-css/blob/master)

## Install

You can either download the whole project as is or install it via NPM:

```
npm install flagship-css
```

# Usage

For using the flags inline with text add the classes `.flag-icon` and `.flag-icon-xx`
(where `xx` is the ISO 3166-1-alpha-2 code of a country) to an empty `<span>`.
If you want to have a squared version flag then add the class `flag-icon-squared` as well.

**Example:**

```html
<span class="flag-icon flag-icon-gr"></span>
<span class="flag-icon flag-icon-gr flag-icon-squared"></span>
```

You could also apply this to any element, but in that case you'll have to use the `flag-cion-background` instead of
`flag-icon` and you're set. This will add the correct background with the following CSS properties:

```css
background-size: contain;
background-position: 50%;
background-repeat: no-repeat;
```

Which means that the flag is just going to appear in the middle of an element,
so you will have to set manually the correct size of 4 by 3 ratio or if it's squared add also the `flag-icon-squared` class.

# Development

Run the `npm install` to install the dependencies after cloning the project and you'll
be able to run the following Gulp commands:

```
Usage
  gulp [TASK] [OPTIONS...]

Available tasks
  help         Display this help text.
  sass:lint    Check the SASS files for codestyle warnings.
  sass:render  Generate the CSS file from SASS.
```

# Credits

This project wouldn't exist without the awesome content of:

- [koppi](https://github.com/koppi)
- [Lipis/flag-icon-css](https://github.com/lipis/flag-icon-css/blob/master)

repository: Tjoosten/flagship-css

repo_name: Tjoosten/flagship-css


text:
#### What's nexl ?
nexl is a configuration hosting server.
Configuration is stored in **native JavaScript files**, exposed via standard **HTTP protocol** and can be accessed by special **[expression language](http://www.nexl-js.com/introduction.html)**.

nexl can be useful when you need to store and manage an application configuration externally instead of storing it hard coded.
Another use case is when you need a centralized place to manage different kind of configurations.

#### Features

* JavaScript files [reuse](http://www.nexl-js.com/include-directive.html) on server side (files can include each other)
* Powerful [expression language](http://www.nexl-js.com/introduction.html) to retrieve data from JavaScript files
* Additionally expression language allows to aggregate data on the fly while retrieving (for example [merging two JavaScript objects](https://www.youtube.com/watch?v=p_dDtJ2BKEo&t=254) and then converting it to [XML/YAML/Property](https://www.youtube.com/watch?v=O_U1lAx4MMs))
* JavaScript [functions call](https://www.youtube.com/watch?v=c-on-20cZnM) to perform some additional data aggregation
* Viral [expressions interpolation](http://www.nexl-js.com/viral-expressions-interpolation.html) (i.e. you can inject expressions into your data which will be interpolated while retrieving it)
* [Nested expressions](http://www.nexl-js.com/nested-expressions.html) with unlimited depth
* External [arguments](http://www.nexl-js.com/arguments.html) to override existing data in JavaScript files
* Webhooks
* Automatic backup
* Convenient [Web UI](http://www.nexl-js.com/the-main-screen.html) for configuration management and server administration
* [Security](http://www.nexl-js.com/security.html) and [permissions](http://www.nexl-js.com/users-and-permissions.html) support
* No agents needed on clients, nexl works via standard HTTP/HTTPS protocols

#### Installation
First download and install a [Node.js](https://nodejs.org/en/download/).
Node.js 6 or higher is required.

Uninstall previously installed nexl version if exists:
```bash
> npm uninstall nexl -g
```

Install latest nexl version:
```bash
> npm i nexl -g
```

Run nexl:
```bash
> nexl
```

Open URL in browser:
[http://localhost:8080](http://localhost:8080)

#### More
More about nexl on [http://www.nexl-js.com](http://www.nexl-js.com) site

Watch nexl demo:
[![nexl demo](http://www.nexl-js.com/demo/3.1.0/demo.png)](http://www.nexl-js.com/demo/3.1.0/demo.php)

repository: liamray/nexl-js

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

license_type: permissive

repo_name: liamray/nexl-js


text:
PcapVPN
=======

PcapVPN is a small program to turn any two-way connection between hosts into
a layer 2 VPN between one of the hosts and the other host's network.  It does
this using a tap device on one end (the host to put on the target network) and
pcap on the other (on a host on the target network).

This is very much a PoC at the moment and should not be relied upon.  However,
it is very simple and easy enough to audit.

For legal use only.

Details
-------
At its core, PcapVPN is nothing more than an adapter between a tap device and
stdin/out on one side of the VPN (the attacker side, usually) and between pcap
and stdin/out on the other (a victim, usually).

### Attacker side
When used with the `-t` flag, a tap device given on the command line is opened,
and any frames read are sent to standard output.

Any frames read from standard input are written to the tap device.

On Openbsd, a file interface to the tap device is required, i.e. OpenBSD's
`/dev/tapN` (as created by `ifconfig tap0 create`).  Several should already
exist.  `/dev/tap0` is probably a good choice.

On Linux, a name for the tap device is required, which can have a `%d` as a
placeholder for a number.  `tap%d` is probably a good choice.

This does not necessarily require root access, so long as the tap device is
accessible by the user running PcapVPN.

### Victim side
When given an interface and a MAC address, an IP address, or a BPF filter,
PcapVPN sniffs the traffic on the given interface and any frames matching the
given MAC address, IP address, or filter are written to standard output.

Any frames read from standard input are injected via the given interface.

This requires PcapVPN be run as root, or, on Linux, given the appropriate
capabilities (e.g. with setcap(7)).

By default, promiscous mode is enabled on the victim's interface.  This can
be changed by setting the `-p` flag on the instance running on the .

### Transport
Generally speaking, PcapVPN is transport-agnostic, though so far, only SSH
has been used to connect the two instances of PcapVPN.  The protocol only adds
two bytes of overhead for every frame, so with possible modification to the MTU
of the tap device, it is likely possible to use UDP, ICMP, or any other sneaky
tunnel which blends in.

Protocol
--------
```
| <----2 bytes----> | <-N Bytes-> |
| Length of Payload |   Payload   |
```
PcapVPN's protocol on the wire is extremely simple.  Each frame has a two-byte
header in network byte order giving the length of the frame, followed
immediately by the frame.  A 0-byte payload (with a header of 0x0000) is legal.

Example
-------
There are two examples below.  Both make these assumptions:
- The attacker is running OpenBSD
- The victim host is running Linux and uses the iproute2 toolset
- The PcapVPN binary is on both hosts as `pcapvpn`,
- The commands are either run as root or with appropriate use of
`doas`/`sudo`/`setcap`/such.
- ksh is the shell on the attacker (bash will work, though the syntax to
connect two processes' stdio is different).
- The victim's `eth0` interface is connected to the target network

### Layer 2 filtering and DHCP
This is the "normal" usage, suitable for when there's no port filtering,
arpwatch, or anything of the sort.  Once connected, DHCP will be used to get an
address.  Of course, the tap device can just as well be assigned an address
manually.

On the attacker (ksh):
```sh
# Make the tap device
ifconfig tap0 create

# Start the local end
./pcapvpn -t tap0 |&

# Connect it to the victim and filter on the tap device's MAC address
ssh user@victim "./pcapvpn eth0 $(ifconfig tap0 | egrep -o 'lladdr.*' | cut -f 2 -d ' ')" >&p <&p &

# Get a DHCP lease
dhclient tap0
```
Nothing need be done on the victim.

At this point, tap0 is (virtually) on the network to which the victim's `eth0`
interface is connected.

### Layer 3 filtering and a static address
In the case of MAC filtering on the victim's switch (e.g. a VirtualBox internal
network), or if putting another MAC address on the network is a bad idea, it's
possible to use the victim interface's MAC address and only transport frames
destined to a manually-set IP address back to the attacker.

This requires finding an unused IP address on the target network, as well as
making sure the victim host doesn't react adversely to unwanted frames (i.e.
frames sent to it with the wrong address).  There are various ways to do this;
the example assumes that this information has been previously gathered.

For this example, the victim's MAC address is assumed to be `11:22:33:44:55:66`
and it is assumed `<IP_ADDRESS>/24` is a valid and unused (and safe to mooch)
address on the victim's network.

On the attacker (ksh):
```sh
# Make the tap device
ifconfig tap0 create

# Set to blend in with the target network
ifconfig tap0 lladdr 11:22:33:44:55:66
ifconfig tap0 inet <IP_ADDRESS>/24

# Start the local end
./pcapvpn -t tap0 |&

# Connect it to the victim and filter on the tap device's IP address
ssh user@victim "./pcapvpn eth0 <IP_ADDRESS>" >&p <&p &
```
Nothing need be done on the host, but it is probably wise at this point to
monitor traffic on the victim for a bit.

Building
--------
The included build script [build.sh](./build.sh) can be used to build PcapVPN.
It is written for development, and will likely need tweaking, but is a good
start, anyways.  In particular, most Linux distributions don't seem to ship
with libpcap archives suitable for static linking, so either `-static` will
need to be removed (and victims will have to have libpcap installed), or
libpcap will have to be built statically manually, and the `LDFLAGS` and
`CPPFLAGS` environment variables will have to be set appropriately.

Future Features (Wishlist)
--------------------------
The following features may be implemented in the future:
- Encryption
- Standalone transports
- Windows tap device equivalent support

Pull requests are welcome.

license: Zlib

repository: stuartsec/pcapvpn

repo_name: stuartsec/pcapvpn


text:
The demo only applies to Highcharts area charts and only charts with single series are supported.

Drag on the graph from one point to another point and you can see the area in between is highlighted.

![Highcharts Highlighted Area](https://github.com/zoe2000/highcharts-highlight-area/blob/master/screenshot.png)

license: MIT

repository: Graxi/highcharts-highlight-area

repo_name: Graxi/highcharts-highlight-area


text:
---
title: "baseThemeArctic"
description: "Arctic theme"
nav_exclude: true
image: https://docs.madelineproto.xyz/favicons/android-chrome-256x256.png
---
# Constructor: baseThemeArctic
[Back to constructors index](/API_docs/constructors/index.html)

Arctic theme

### Type: [BaseTheme](/API_docs/types/BaseTheme.html)

### Example:

```
$baseThemeArctic = ['_' => 'baseThemeArctic'];
```

repository: danog/MadelineProtoDocs

gha_language: PHP

repo_name: danog/MadelineProtoDocs


text:
# Pin Check/Passcode plugin for Apache Cordova

[![NPM](https://nodei.co/npm/cordova-plugin-pincheck.png)](https://nodei.co/npm/cordova-plugin-pincheck/)

## Introduction

This plugin is for use with [Apache Cordova](http://cordova.apache.org/) and allows your application to check whether pin/keyguard or passcode is setup on iOS and Android phones.

### Supported platforms

  * Android
  * iOS (iOS 8 and above)

## Installation

Below are the methods for installing this plugin automatically using command line tools. For additional info, take a look at the [Plugman Documentation](https://cordova.apache.org/docs/en/latest/plugin_ref/plugman.html), [`cordova plugin` command](https://cordova.apache.org/docs/en/latest/reference/cordova-cli/index.html#cordova-plugin-command) and [Cordova Plugin Specification](https://cordova.apache.org/docs/en/latest/plugin_ref/spec.html).

### Cordova

The plugin can be installed via the Cordova command line interface:

* Navigate to the root folder for your phonegap project.
* Run the command:

```sh
cordova plugin add cordova-plugin-pincheck
```

## Plugin API

#### Detect whether pin is setup on device

```js
if(window.cordova && window.cordova.plugins.PinCheck){
      window.cordova.plugins.PinCheck.isPinSetup(function(success){
        console.log("pin is setup.");
      }, function(fail){
        console.log("pin not setup.");
      });
    }
```

## LICENSE

    The MIT License

    Copyright (c) 2015 Crypho AS.

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.

     IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    THE SOFTWARE.

repository: shangyilim/cordova-plugin-pincheck

gha_language: Java

repo_name: shangyilim/cordova-plugin-pincheck


text:
# Clean Task

Deletes folders and files. Uses [del](https://www.npmjs.com/package/del) under the hood.

By default this task will delete all files including those starting with a `.`.

## Parameters

| parameter | type               | note                                                                                |
| --------- | ------------------ | ---------------------------------------------------------------------------------------------------------------- |
| `pattern` | string
string[] | [Globs][1] files to delete (1)                                                                        |
| `*`       |                    | Any other parameter will be passed to `del` as configuration [option](https://www.npmjs.com/package/del#options) |

1. _Supports environment templates._

[1]: https://gulpjs.com/docs/en/api/concepts#globs

## Hooks

This task does not expose any hook.

## Example

```js
const $ = require('@wok-cli/core');
const { clean } = require('@wok-cli/tasks');

exports.copy = $.task(clean, {
  pattern: ['dist'],
});
```

repository: dwightjack/wok-pkgs

gha_license_id: MIT

repo_name: dwightjack/wok-pkgs


text:
Vision System Setup (First-Run) Instructions
====

1. Image a Raspberry Pi with Raspbian. Either headless or desktop environment is up to you.

2. Set the hostname of the Pi to either `pi_5333` or `pi_5663` depending on your team (done through `sudo raspi-config`)

3. Enable SSH on the Pi through `sudo raspi-config`

4. Reboot.

5. Run `./gradlew :common:vision:deploy`.

6. SSH into the Pi and run `cd /home/pi/setup; ./setupOpencv.sh`. This will take a while.


text:
Ansible Collection - hostadelic.devops
======================================

Miscellaneous elements for Hostadelic DevOps. Reusable but targeted to our
projects.

# Roles

## globals

A role to define various global variables:

- `paths`: Considering the playbook is one level deeper in the directory
  hierarchy than the root repository (e.g. `<root>/playbooks/main.yaml`),
  `paths` will contain variables as `prefix`, `libdir`, `datadir` etc. expanding
  to full paths equivalents of `<root>`, `<root>/lib`, `<root>/var` etc.
- `settings`: Content of `<root>/settings.yaml` if it exists.
- `secrets`: Content of `<root>/secrets.yaml` if it exists.

repository: hostadelic/ansible-collections

branch_name: refs/heads/main

repo_name: hostadelic/ansible-collections


text:
---
layout: post
title: "Apache Maven Wagon Version 3.4.1 Released"
date: 2020-05-22 21:13:25
comments: true
categories: [Neuigkeiten,BM,Maven,Maven-Plugins,Maven-Plugin-Releases]
---
The Apache Maven team is pleased to announce the release of
[Apache Maven Wagon 3.4.1](https://maven.apache.org/wagon/).

Apache Maven Wagon is a transport abstraction that is used in Mavens
artifact and repository handling code.

You can download the appropriate sources etc. from the [download page](https://maven.apache.org/wagon/download.cgi).

<!-- more -->

[Release Notes - Maven Wagon - Version 3.4.1](https://issues.apache.org/jira/secure/ReleaseNote.jspa?projectId=12318122&version=12348210)

* Bugs:

  * {%ajl WAGON-591 %} - Transfer event is not restarted when request is redirected
  * {%ajl WAGON-592 %} - Wagon fails when compiled on Java 9+ and run on Java 8 due to JDK API breakage
  * {%ajl WAGON-594 %} - http.route.default-proxy config property never passes protocol and port of proxy server

* Improvements:

  * {%ajl WAGON-595 %} - Add configuration property 'http.protocol.handle-content-compression'
  * {%ajl WAGON-596 %} - Add configuration property 'http.protocol.handle-uri-normalization'

* Task:

  * {%ajl WAGON-593 %} - Remove non-existent cache header

Enjoy,

- The Apache Maven team

repository: khmarbaise/octopress

gha_language: Ruby

repo_name: khmarbaise/octopress


text:
# How an input source work?
Each source format should have two functions: List() and Open()

List() generates a list of file locations.
Open() read from one location. Each row of input is sent to next dataset.

# Understand the code

We taking csv for example.

CsvInputFormat: a managerial type to manage CsvInputSplitter, CsvInputSplit, CsvInputSplitReader
CsvInput: any type
CsvInputSplitter: takes CsvInput, and produce a list of CsvInputSplit
CsvInputSplit: must be a serializable type, will be sent to executors
CsvInputSplitReader: runs on executors, read CsvInputSplit

When import this package:
  1. register mapping from "csv" to CsvInputFormat
On Driver:
  1. User specifiies CsvInput
  2. "csv"=>CsvInputFormat, +CsvInput => CsvSplitter.Split()/SplitBySize()/SplitByLines() => []CsvInputSplit
  3. send "csv", CsvInputSplit to each executor
On Executors:
  1. "csv"=>CsvInputFormat=>CsvInputFormat, CsvInputSplit, decode from []byte
  2. "csv"=>CsvInputFormat=>CsvInputSplitReader, read out lines by CsvInputSplit

# How to add one more input source?
1. Clone the csv or ints folder, rename all struct name first.
2. Make sure everything is mostly compiled.
3. add an import such as this in dataset_input.go file
	_ "github.com/chrislusf/gleam/source/csv"

repository: Mapz/gleam

repo_name: Mapz/gleam


text:
### Steps to reproduce
1.
2.
3.

### Expected behaviour
<!--
Tell us what should happen
-->

### Actual behaviour
<!--
Tell us what happens instead
-->

**Android OS version:**

**Device manufacturer and model:**

**List of installed add-ons (like languages, or themes):**

repository: AnySoftKeyboard/AnySoftKeyboard

repo_name: AnySoftKeyboard/AnySoftKeyboard


text:
# Doctor Lookup

##### A web application to search for doctors.

#### By Lan Dam, 08/10/2018.

## Description

Doctor Lookup is a web application that let user search for doctor in a given area base on doctor name or by medical symptoms.

## Setup

* Install DoctorLookup by cloning this repository
* Install all the modules by typing npm install
* Get an api key from developer.betterdoctor.com
* Create a .env file at the top level of the directory and place the api key there with the name exports.apiKey (example: exports.apiKey=YOUR_KEY_HERE)
* Build the app by typing npm run build
* The completed app will be in the dist folder

## Technologies Used

Application: JavaScript, Node.js, Webpack, Jasmine, Karma

## Support and Contact

For any questions or support details, please email:
<EMAIL_ADDRESS>
## Spec

* Allows user to enter a medical symptom and returns a list of doctors that can treat that symptom
* Allows user to enter a name and return returns a list of doctors that fit the search query
* If query response contains list of doctors, display the first name, last name, address, phone number, website, and wether or not doctor accept new patient for each doctor
* If API call results in an error (not 200 OK), returns a notification of error message
* If query response doesn't include any doctor, returns a message no doctor meet the criteria

### Legal

Copyright (c) 2018 **Lan Dam**

This software is licensed under the MIT license.


text:
Unreal C++ An In-Depth Guide to Creating Interactive Actors

Demo project for my tutorial about creating interactive actors using C++.

This is the demo project for the tutorial at [Unreal C++ An In-Depth Guide to Creating Interactive Actors](https://robertcorponoi.com/unreal-c-an-in-depth-guide-to-creating-interactive-actors/) which explains how to setup an actor that can have one or more interactive parts which the player can interact with such as opening a drawer or turning on a light.

This demo was created with Unreal 4.25.3

## Instructions

All you have to do is clone or download the repo and open it up in Unreal. Make sure that you load up the MainLevel under Levels/MainLevel and when you hit play you can walk up to the desk and look at the drawer to open/close it or the lamp to turn it on/off.

## **License**

MIT


text:
# Recommendations with IBM
## Introduction
> For this project I have analyzed the interactions that users have with articles on the IBM Watson Studio platform,
and made recommendations to them about new articles thatv I thought they would like.

Here is an example of what the dashboard could look like displaying articles on the IBM Watson Platform.

## Get the repository:
`git clone https://github.com/Apucs/recommendation-with-IBM.git`

## Project details:

1. Exploratory Data Analysis:

Before making recommendations of any kind, I have explored the data you was working with for the project.
Some basic, required questions were answered about the data that I have will be working with throughout the
rest of the notebook.

2. Rank Based Recommendations:

To get started in building recommendations, firstly, I found the most popular articles simply based on the most interactions.
Since there were no ratings for any of the articles, it was easy to assume the articles with the most interactions were the
most popular. These are then the articles we might recommend to new users (or anyone depending on what we know about them).

3. User-User Based Collaborative Filtering:

In order to build better recommendations for the users of IBM's platform, I have looked at users that are similar in terms of
the items they have interacted with. These items could then be recommended to the similar users. This would be a step in the
right direction towards more personal recommendations for the users. I have implemented this in this part.

4. Matrix Factorization:

Finally, you completed a machine learning approach to building recommendations. Using the user-item interactions, I built out a matrix
decomposition. Using that decomposition, I got an idea of how well I can predict new articles an individual might interact with.

LICENSE: This project is licensed under the terms of the MIT license.

repository: Apucs/recommendation-with-IBM

gha_language: HTML

repo_name: Apucs/recommendation-with-IBM


text:
---
user-guide-title: Adobe Experience Manager as a Cloud Service Tutorials
user-guide-description: A collection of tutorials for Adobe Experience Manager as a Cloud Service.
breadcrumb-title: AEM as a Cloud Service Tutorials
sub-product: cloud-service
team: TM
---

# Adobe Experience Manager as a Cloud Service Tutorials {#cloud-service}

+ [Overview](./overview.md)
+ Introduction to AEM as a Cloud Service{#introduction}
  + [What is AEM as a Cloud Service?](./introduction/what-is-aem-as-a-cloud-service.md)
  + [Evolution](./introduction/evolution.md)
  + [Architecture](./introduction/architecture.md)
  + [Cloud Manager](./introduction/cloud-manager.md)
+ Underlying Technology {#underlying-technology}
  + [AEM Architecture](./underlying-technology/introduction-architecture.md)
  + [OSGi](./underlying-technology/introduction-osgi.md)
  + [Java Content Repository](./underlying-technology/introduction-jcr.md)
  + [Sling](./underlying-technology/introduction-sling.md)
  + [Author and Publish Services](./underlying-technology/introduction-author-publish.md)
  + [Dispatcher](./underlying-technology/introduction-dispatcher.md)
+ Cloud Manager {#cloud-manager}
  + [Programs](./cloud-manager/programs.md)
  + [Environments](./cloud-manager/environments.md)
  + [CI/CD Production Pipeline](./cloud-manager/cicd-production-pipeline.md)
  + [CI/CD Non-Production Pipeline](./cloud-manager/cicd-non-production-pipeline.md)
  + [Activity](./cloud-manager/activity.md)
  + Dev Ops{#devops}
    + [Deploying Code](./cloud-manager/devops/deploy-code.md)
    + [Merge Projects](./cloud-manager/devops/merge-projects.md)
    + [Configure Pipelines](./cloud-manager/devops/configure-pipelines.md)
    + [Continuous Integration](./cloud-manager/devops/continuous-integration.md)
    + [Analyze Test Results](./cloud-manager/devops/analyze-test-results.md)
    + [Dispatcher Configurations](./cloud-manager/devops/dispatcher-configurations.md)
    + [Cloud Manager APIs](./cloud-manager/devops/cloud-manager-apis.md)
+ Local Development Environment Setup {#local-development-environment-set-up}
  + [Overview](./local-development-environment/overview.md)
  + [Development Tools](./local-development-environment/development-tools.md)
  + [Local AEM Runtime](./local-development-environment/aem-runtime.md)
  + [Local Dispatcher Tools](./local-development-environment/dispatcher-tools.md)
+ Developing{#developing}
  + Development Basics{#basics}
    + [AEM SDK](./developing/basics/aem-sdk.md)
    + [Local Development Environment](./developing/basics/local-development-environment.md)
    + [AEM Project Archetype](./developing/basics/aem-project-archetype.md)
    + [AEM Project Structure](./developing/basics/project-structure.md)
    + [Mutable vs. Immutable Content](./developing/basics/mutable-immutable.md)
    + [Repository Structure Package](./developing/basics/repository-structure-package.md)
    + [Content Publishing](./developing/basics/content-publishing.md)
    + [OSGi Configurations](./developing/basics/osgi-configurations.md)
    + [Dispatcher Configuration Migration](./developing/basics/dispatcher-configuration.md)
  + AEM Projects{#aem-projects}
    + [AEM Maven Project](./developing/projects/maven-project-structure.md)
    + [Cleaning an AEM Maven Project](./developing/projects/remove-samples.md)
  + OSGi Services{#osgi-services}
    + [OSGi Service Basics](./developing/osgi-services/basics.md)
    + [OSGi Component Lifecycle](./developing/osgi-services/lifecycle.md)
    + [OSGi Configurations Basics](./developing/osgi-services/configurations.md)
    + [OSGi Configurations using OCD](./developing/osgi-services/configurations-ocd.md)
  + Advanced{#advanced}
    + [Service Users](./developing/advanced/service-users.md)
  + [AEM SDK API JavaDocs](https://javadoc.io/doc/com.adobe.aem/aem-sdk-api/latest/index.html)
+ Debugging AEM{#debugging}
  + Debugging the AEM SDK{#debugging-aem-sdk}
    + [Overview](./debugging/aem-sdk-local-quickstart/overview.md)
    + [Logs](./debugging/aem-sdk-local-quickstart/logs.md)
    + [Remote Debugging](./debugging/aem-sdk-local-quickstart/remote-debugging.md)
    + [OSGi web console](./debugging/aem-sdk-local-quickstart/osgi-web-consoles.md)
    + [Dispatcher Tools](./debugging/aem-sdk-local-quickstart/dispatcher-tools.md)
    + [Other tools](./debugging/aem-sdk-local-quickstart/other-tools.md)
  + Debugging AEM as a Cloud Service{#debugging-aem-as-a-cloud-service}
    + [Overview](./debugging/cloud-service/overview.md)
    + [Logs](./debugging/cloud-service/logs.md)
    + [Build and Deployment](./debugging/cloud-service/build-and-deployment.md)
    + [Developer Console](./debugging/cloud-service/developer-console.md)
    + [CRXDE Lite](./debugging/cloud-service/crxde-lite.md)
+ Accessing AEM{#accessing}
  + [Overview](./accessing/overview.md)
  + [Adobe IMS users](./accessing/adobe-ims-users.md)
  + [Adobe IMS user groups](./accessing/adobe-ims-user-groups.md)
  + [Adobe IMS product profiles](./accessing/adobe-ims-product-profiles.md)
  + [AEM users, groups, and permissions](./accessing/aem-users-groups-and-permissions.md)
  + [Configuring access to AEM walk-through](./accessing/walk-through.md)
+ Migration {#migration}
  + [Content Transfer Tool](./migration/content-transfer-tool.md)
  + [Bulk Import of assets](./migration/bulk-import.md)

  + Moving to AEM as a Cloud Service {#moving-to-aem-as-a-cloud-service}
    + [Introduction](./migration/moving-to-aem-as-a-cloud-service/introduction.md)
    + [Onboarding](./migration/moving-to-aem-as-a-cloud-service/onboarding.md)
    + [Cloud Manager](./migration/moving-to-aem-as-a-cloud-service/cloud-manager.md)
    + [BPA and CAM](./migration/moving-to-aem-as-a-cloud-service/bpa-and-cam.md)
    + [AEM Modernization tools](./migration/moving-to-aem-as-a-cloud-service/aem-modernization-tools.md)
    + [Repository Modernization](./migration/moving-to-aem-as-a-cloud-service/repository-modernization.md)
    + [Asset Compute Microservices](./migration/moving-to-aem-as-a-cloud-service/asset-compute-microservices.md)
    + [Dispatcher](./migration/moving-to-aem-as-a-cloud-service/dispatcher.md)
    + [Search and Indexing](./migration/moving-to-aem-as-a-cloud-service/search-and-indexing.md)
    + Content Migration {#content-migration}
      + [Bulk Import Service](./migration/moving-to-aem-as-a-cloud-service/content-migration/bulk-import-service.md)
      + [Content Transfer Tool](./migration/moving-to-aem-as-a-cloud-service/content-migration/content-transfer-tool.md)
    + [Troubleshooting](./migration/moving-to-aem-as-a-cloud-service/troubleshooting.md)
    + AEM Forms as a Cloud Service {#aem-forms}
      + [Introduction](./migration/moving-to-aem-as-a-cloud-service/aem-forms/introduction.md)
      + [Digital Enrollment](./migration/moving-to-aem-as-a-cloud-service/aem-forms/digital-enrollment.md)
      + [Communications](./migration/moving-to-aem-as-a-cloud-service/aem-forms/communications.md)

  + Cloud Acceleration Manager {#cloud-acceleration-manager}
    + [Introduction](./migration/cloud-acceleration-manager/introduction.md)
    + [Readiness and Best Practice Analyzer](./migration/cloud-acceleration-manager/readiness-and-best-practice-analyzer.md)
    + [Implementation phase](./migration/cloud-acceleration-manager/implementation-phase.md)
    + [Content Transfer Tool](./migration/cloud-acceleration-manager/content-transfer-tool.md)
    + [Code Refactoring tools](./migration/cloud-acceleration-manager/code-refactoring-tools.md)
    + [Code Repository Modernizer](./migration/cloud-acceleration-manager/code-repository-modernizer.md)
    + [Dispatcher Converter](./migration/cloud-acceleration-manager/dispatcher-converter.md)
    + [Index Converter](./migration/cloud-acceleration-manager/index-converter.md)
    + [Asset Workflow Migration Tool](./migration/cloud-acceleration-manager/asset-workflow-migration-tool.md)
    + [Navigating the Cloud Acceleration Manager](./migration/cloud-acceleration-manager/navigating.md)
    + [Using the Cloud Acceleration Manager](./migration/cloud-acceleration-manager/using.md)
+ Forms{#forms}

    + Developing for Forms as a Cloud Service{#developing-for-cloud-service}
        + [Getting started](./forms/developing-for-cloud-service/getting-started.md)
        + [Install IntelliJ](./forms/developing-for-cloud-service/intellij-set-up.md)
        + [Setup Git](./forms/developing-for-cloud-service/setup-git.md)
        + [Sync IntelliJ with AEM](./forms/developing-for-cloud-service/intellij-and-aem-sync.md)
        + [Build a form](./forms/developing-for-cloud-service/deploy-your-first-form.md)
        + [Include Cloud Services and FDM](./forms/developing-for-cloud-service/azure-storage-fdm.md)
        + [Push to Cloud Manager](./forms/developing-for-cloud-service/push-project-to-cloud-manager-git.md)
        + [Deploy to development environment](./forms/developing-for-cloud-service/deploy-to-dev-environment.md)

    + Create Adaptive Form{#create-first-af}
        + [Introduction](./forms/create-first-af/introduction.md)
        + [Create Theme](./forms/create-first-af/create-theme.md)
        + [Create Template](./forms/create-first-af/create-template.md)
        + [Create Fragment](./forms/create-first-af/create-fragments.md)
        + [Create Form](./forms/create-first-af/create-af.md)
        + [Configure root panel](./forms/create-first-af/configure-root-panel.md)
        + [Configure people panel](./forms/create-first-af/configure-people-panel.md)
        + [Configure income panel](./forms/create-first-af/configure-income-panel.md)
        + [Configure assets panel](./forms/create-first-af/configure-assets-panel.md)
        + [Configure start panel](./forms/create-first-af/configure-start-panel.md)
        + [Add and Configure toolbar](./forms/create-first-af/add-configure-toolbar.md)
    + Document Cloud API and AEM Forms CS{#doc-cloud-sdk}
        + [Introduction](./forms/doc-cloud-sdk/introduction.md)
        + [Create Adobe IO Project](./forms/doc-cloud-sdk/create-document-cloud-credentials.md)
        + [Create OSGI Configuration](./forms/doc-cloud-sdk/create-doc-cloud-configuration.md)
        + [Define Interface](./forms/doc-cloud-sdk/create-interface.md)
        + [Implement Interface](./forms/doc-cloud-sdk/implement-interface.md)
        + [Create JSON Part](./forms/doc-cloud-sdk/get-content-analyzer.md)
        + [Custom Process Step](./forms/doc-cloud-sdk/custom-process-step.md)
    + Azure Portal Storage{#forms-cs-azure-portal}
        + [Introduction](./forms/forms-cs-azure-portal/introduction.md)
        + [Create Form Data Model](./forms/forms-cs-azure-portal/create-fdm.md)
        + [Store form data in Azure Storage](./forms/forms-cs-azure-portal/create-af.md)
        + [Prefill form](./forms/forms-cs-azure-portal/prefill-af-storage.md)
        + [Query submissions](./forms/forms-cs-azure-portal/query-submitted-data.md)

    + Create Review Workflow{#create-aem-workflow}
        + [Create workflow model](./forms/create-aem-workflow/create-workflow.md)
        + [Trigger workflow](./forms/create-aem-workflow/configure-af.md)
    + Adobe Sign with AEM Forms{#forms-and-sign}
        + [Introduction](./forms/forms-and-sign/introduction.md)
        + [Adobe Sign API Application](./forms/forms-and-sign/create-sign-api-application.md)
        + [Adobe Sign Cloud Configuration](./forms/forms-and-sign/create-adobe-sign-cloud-configuration.md)
        + [Create Adaptive Form](./forms/forms-and-sign/create-adaptive-form.md)
        + [Configure for fill and sign](./forms/forms-and-sign/configure-form-fill-and-sign.md)
    + Integrate with Salesforce{#integrate-with-salesforce}
        + [Introduction](./forms/integrate-with-salesforce/introduction.md)
        + [Create connected app](./forms/integrate-with-salesforce/create-connected-app.md)
        + [Create swagger file](./forms/integrate-with-salesforce/describe-rest-api.md)
        + [Create data source](./forms/integrate-with-salesforce/create-data-source.md)
        + [Create form data model](./forms/integrate-with-salesforce/create-form-data-model.md)
        + [Test form submission](./forms/integrate-with-salesforce/create-lead-submitting-form.md)
        + [Test click event](./forms/integrate-with-salesforce/create-lead-click-event.md)
+ Asset Compute Extensibility{#asset-compute}
    + [Overview](./asset-compute/overview.md)
    + Set up{#set-up}
        + [Account and service provisioning](./asset-compute/set-up/accounts-and-services.md)
        + [Local development environment](./asset-compute/set-up/development-environment.md)
        + [Adobe Project Firefly](./asset-compute/set-up/firefly.md)
    + Develop{#develop}
        + [Create an Asset Compute project](./asset-compute/develop/project.md)
        + [Configure environment variables](./asset-compute/develop/environment-variables.md)
        + [Configure the manifest.yml](./asset-compute/develop/manifest.md)
        + [Develop a worker](./asset-compute/develop/worker.md)
        + [Use the Development Tool](./asset-compute/develop/development-tool.md)
    + Test and Debug{#test-debug}
        + [Test a worker](./asset-compute/test-debug/test.md)
        + [Debug a worker](./asset-compute/test-debug/debug.md)
    + Deploy{#deploy}
        + [Deploy to Adobe I/O Runtime](./asset-compute/deploy/runtime.md)
        + [Integrate with AEM](./asset-compute/deploy/processing-profiles.md)
    + Advanced{#advanced}
        + [Metadata workers](./asset-compute/advanced/metadata.md)
    + [Troubleshooting](./asset-compute/troubleshooting.md)
+ [AEM Experts Series](./aem-experts-series.md)
+ Multi-step Tutorials{#multi-step-tutorials}
    + [AEM Sites development](https://experienceleague.adobe.com/docs/experience-manager-learn/getting-started-wknd-tutorial-develop/overview.html)
    + [GraphQL](https://experienceleague.adobe.com/docs/experience-manager-learn/getting-started-with-aem-headless/graphql/overview.html)
    + [SPA Editor (React)](https://experienceleague.adobe.com/docs/experience-manager-learn/spa-react-tutorial/overview.html)
    + [SPA Editor (Angular)](https://experienceleague.adobe.com/docs/experience-manager-learn/spa-angular-tutorial/overview.html)
    + [AEM Sites and Adobe Target](https://experienceleague.adobe.com/docs/experience-manager-learn/aem-target-tutorial/overview.html)
    + [Token-based authentication](https://experienceleague.adobe.com/docs/experience-manager-learn/getting-started-with-aem-headless/authentication/overview.html)


text:
# Maven Java Quickstart Archetype

Just a simple alternative to the Maven Quickstart archetypes that comes with:

 - a recent JUnit version
 - Hamcrest and its additional matchers
 - logback runtime and test configurations
 - a `.editorconfig` file with encoding setup correctly

## Usage

```
  mvn archetype:generate \
    -DarchetypeGroupId=de.bripkens \
    -DarchetypeArtifactId=java-quickstart \
    -DarchetypeVersion=0.2.0
```

repository: profwpollock/java-quickstart

repo_name: profwpollock/java-quickstart


text:
+++
title = "Delaware Lottery Website Redesign"
client = "Delaware Lottery"
short_description = "Winning millions."
roles = ["Research", "UX Design", "Usability Study", "Visual Design", "Front-End Development"]
year = "2017"
url = "/projects/delaware-lottery"
url_external = "https://delottery.com"
featured_image = "v1521473680/work/delottery/DELottery-Featured.jpg"
primary_color = "#007cc2"
weight = 2
+++

## Overview
Ticket sales for The Delaware Lottery had been on the decline for years. So, they came to AB&C to help get players excited about the lottery again.
<!--more-->

{{< image
        src="v1521476971/work/delottery/site-on-devices.jpg"
        class="img img--expanded"
        alt="Fully responsive site experience at delottery.com" >}}

## Strategy
To build excitement, we knew the campaign had to feel big. So we set out to showcase the Delaware Lottery, by highlighting the one thing all Americans can agree on: winning millions. Along with an updated website, Billboards, change mats, print ads and transit ads with playful lines were created.

{{< image
        src="v1521481424/work/delottery/drawing-games.jpg"
        class="img img--expanded"
        alt="Lottery drawing game cards" >}}

A TV spot with alternate lyrics to “The Star-Spangled Banner” and a radio spot with that “four score and seven years ago” feeling rounded out the campaign. Other digital tactics, such as banner ads and social media posts, were also created, all to help support the new website.

{{< image
        src="v1521480595/work/delottery/location-map.jpg"
        class="img"
        alt="Where to Buy map - VueJS map component, with autocomplete, live record updating, and geolocation." >}}

## Success
Ticket sales in just the first few weeks of the campaign dramatically outpaced all years prior. Website traffic has tripled since it's launch.  AB&C’s social strategy and online games also garnered positive traction. With the added web traffic, the Lottery has been able to launch two new drawing games and over ten new scratch games.


text:
# Collybia dryophila var. aurata Quél., 1886 VARIETY

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Enchir. fung. (Paris) 31 (1886)

#### Original name
Collybia dryophila var. aurata Quél., 1886

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Marasmiaceae/Gymnopus/Gymnopus dryophilus/ Syn. Collybia dryophila aurata/README.md

repo_name: mdoering/backbone


text:
<img src="https://user-images.githubusercontent.com/28607713/139576077-5c322bfa-d71b-414b-9b63-ff4c53ec9a8d.png"
     alt="planet-logo-white-no-bg"
     width="120">

# Planet backend-assignment
Backend position skill assessment home assignment.

## Overview
This repository holds the basic project structure for implementing a NodeJS based API and service
used in a fictitious software solution that provides stock exchange data services.

Disclaimer: The purpose and usage of this repo is solely for insight adquisition regarding problem-solving,
and does not represent an existing and ongoing implementation task.

PD: We provide this structure as an starting point but you may discard it and approach the task in
any other way.

## The problem
The solution you are required to design and implement is geared towards collecting historic exchange
prices from the currencies the API user wants to EUR. With this in mind we need a system that provides
an API for adding, removing and listing the currencies that are being followed at the moment, and an
additional endpoint for retrieving such historic data.

The workflow that the system should support is:
1. The API user adds or removes currencies from the followed ones, by the currency code.
2. The API user is able to see the followed currencies using the corresponding endpoint
3. The system, periodically, fetches the stock exchange price from each followed currency to Euros (EUR).
4. The API user can retrieve the historical data for a subset of the followed currencies, which
     includes basic data such as ask, bid, and spread; and additional calculated stats.

> We recommend using the [alphavantage API](https://www.alphavantage.co/) for retrieving the data as
> it is free and the endpoint for retrieving the data is well documented and easy to use.
> _See the docs: [https://www.alphavantage.co/documentation/#crypto-exchange](https://www.alphavantage.co/documentation/#crypto-exchange)_

## Tasks
The required functionality can be summarized in the following three tasks:
- Implement three endpoints for adding (by the currency code), removing and listing the followed currencies.
     _We don't enforce a REST API design with `[POST]/currency [DELETE]/currency [GET]/currency` endpoints._
- Implement an endpoint for retrieving the exchange price history of the followed currencies. This endpoint
     must allow specifying the currencies to be included and the fields to include; at least the following
     fields must be included: bid, ask, spread, bid-diff (the difference between the bid and the previous
     hour mean bid), ask-diff (the difference between the ask and the previous hour mean ask), and spread-diff
     (the difference between the spread and the previous hour mean spread).
- Implement the periodic historic data retrieval.

## Evaluation
We are in search for a backend developer who is capable of implementing API requirements, can work
databases and can design "future-proof" (if that even exists) solutions.

Therefore we will evaluate the assignment having the following things in mind:
- Home assignment completition: Whether you completed all tasks and how you prioritized time.
- Code versioning: We are not too picky regarding Git, but do appreciate feature branchs and a clean
  repo history that could help us understand how you approached this assignment.
- Task-specific implementation details:
  - Currency endpoints implementation. We would appreciate it if you took into account the following
    aspects: _How would you document the API?_, _What would happen if we wanted to support newer data sources?_
  - Price history endpoint. We would appreciate it if you took into account the following
    aspects: _How would you allow the user to specify a time range?_ _What would happen if we wanted to support more statistics?_
  - Periodic data retrieval. We would appreciate it if you took into account the following
    aspects: _What would happen if we wanted to support more types of data sources?_
- Extras: Providing extra documentation, identifying any improvement opportunity (even if you didn't
  implement it), or having a fluent communication during your process (just let us know how you are
  doing) will be positively taken into account.

## Repository structure
The code is laid down in a monorepo fashion with make commands for easier admin tasks. The two services
that you can find find are the **api** and **service** services.

The **api** service is an Express server with hot code reloading, while **service** generic service with a
Node setup that runs the script periodically and that you may use -or not- for any recurring process; this
later service can be run manually without the cron job.

You can use the `make` command (from the root directory) to run the platform. We have set it up for two main
use cases:
* Having the API up (with hot-reloading), along with the generic service (with**out** hot-reloading) running periodically using cron:
     ```bash
     make backend-up
     ```
* Having the API up (with hot-reloading) without the generic service. You can then execute the generic service
     once or have it execute each time the code has changed:
     ```bash
     make backend-up-slim
     # execute the generic service once
     make service-run
     # execute the generic service each time the code changes (hot-reloading)
     make service-dev
     ```

Following is a more-in-depth list of the available command for each service:
- The _services/api_ directory holds the code for the API. The following make commands are available:
     - `backend-build` Builds the corresponding Docker images.
     - `backend-up` Raises the platform.
     - `backend-up-slim` Raises the platform without the service _service_ running in the background (just the db and API).
     - `backend-down` Shuts down the platform. _Requires having the platform up (you can use make backend-up)_
     - `backend-dump` Dumps the database contents to a _dump_ folder. _Requires having the platform up (you can use make backend-up)_
     - `backend-load` Loads the database contents from a _dump_ folder. _Requires having the platform up (you can use make backend-up)_
     - `backend-dbshell` Connects to the database shell. _Requires having the platform up (you can use make backend-up)_
     - `backend-test` Runs the API tests with database dump and restore. _Requires having the platform up (you can use make backend-up)_

- The _services/services_ directory holds the code for the API. The following make commands are available:
     - `service-build` Builds the corresponding Docker images.
     - `backend-run` Executes just once the service.. _Requires having the platform up (you can use make backend-up)_
     - `backend-dev` Executes the service each time the code changes. _Requires having the platform up (you can use make backend-up)_
---

# backend-assignment
Backend position skill assessment home assignment.

**[Place here any extra documentation or comments you want us to have.]**

repository: JaviCodx/backend-assignment

repo_name: JaviCodx/backend-assignment


text:
# Exercise scenario

## Overview

FrostyICS was used to conduct training. Following is general structure of the training and the attack path to obtain two objectives.

The initial state of the scenario is shown in figure bellow. In this scenario enterprise network is divided into two segments. One is the office network, where the attacker has gained initial access and has established a command and control channel. In this case office network does not contain any devices as it is out of scope for this exercise and is not required to complete attacks in the IACS network. The displayed structure has informative nature for participants to facilitate the overall idea of the scenario. Therefore, only the IACS network contains actual devices.

![image-20210527222141520](../img/image-20210527222141520.png)

Adversary attacks usually consist of multiple steps to achieve the objectives. Each of these steps includes TTPs are adversary behavior where tactics are high-level procedures and techniques are specific actions the attacker makes in the context of the specific technique. The chain of these steps is called the kill chain. In other words, the cyberattack kill chain is steps that trace stages of a cyberattack from the initial reconnaissance stage to the final actions.  It worth mentioning that the cyber kill chain is a concept used for defense to understand and predict attacker TTPs. For this research purposes kill chain is not used for defense but for attack scenario structure development.

## Objectives

In this scenario, the participant plays as the red team and has two main objectives, which can be achieved by any tools possible, but mainly self-created Python scripts are encouraged:

- Switch off warehouse lights and alarm, and prevent system recovery;
- Damage heating plant and prevent system recovery.

## Scenario

Based on MITRE ATT\&CK TTPs knowledge base participants should take following steps to achieve objectives:

- Tactics in office network:
  - Discovery - looking for available devices in the office network;
  - Lateral movement - attacker spreading to other devices;
  - Persistence - attacker gains stable access network devices to gains access to IACS network;
  - Command and control - attacker uses techniques to establish communication with the compromised system.
- Tactics in IACS network:
  - Discovery - Looking for available devices in the IACS network, discovering open ports, and discovering IACS processes controlled by the IACS network;
  - Collection - Extracting detailed information about IACS elements and their purpose;
  - Impact - actions on objectives.

Visualized attack scenario

![image-20210527223259245](../img/image-20210527223259245.png)

Detailed participant movement to IACS network are described in more detail here - https://github.com/austrisu/master_thesis

## Objective Nr.1 - warehouse attack

To achieve first objective attacker performs Modbus attack on LOGO 8.2

To perform control manipulation, the attacker uses information gathered from the collection phase. For the attacker to switch off the lights and alarms, he needs to control a specific LOGO! 8.2 variables V10.1 and V10.2. Derived from LOGO! 8.2 user documentation are Modbus address mapping . Using this information attacker sends Modbus commands, changing the state of addresses 82 and 83 from true to false. Created Modbus frame is encapsulated in TCP/IP packet and sent to the destination. Python script example created by the author for this scenario can be seen in https://github.com/austrisu/ICS_poc

## Objective Nr.2 - heat plant attack

During the impact stage, the attacker tries to manipulate, disrupt or impair IACS systems and controlled physical processes. The main vulnerabilities of S7-1200 are bound to the S7comm protocol. For the attacker to exploit protocol vulnerabilities, he needs to understand the program structure gathered during collection phase.

From the downloaded S7-1200 program, the attacker can determine what tags are responsible for specific physical function control. These tags are shown in table bellow. Each tag name has assigned the data block number and memory offset within that data block. These are the parameters necessary to send the S7comm control request to the PLC.

| Tag name             | Data type | Memory offset | Data block |
| -------------------- | --------- | ------------- | ---------- |
| temperature_setpoint | int       | 0.0           | DB6        |
| max_presure          | int       | 2.0           | DB6        |
| pump_speed           | int       | 0.0           | DB9        |
| valve_state          | int       | 2.0           | DB9        |

The attacker can send crafted S7comm requests to PLC using Python script with S7comm library called Snap7. Before using the Snap7 library, it should be compiled from the source, and the high-level Python wrapper can use the Snap7 library. Python script example created by the author for this scenario can be seen in https://github.com/austrisu/ICS_poc

repository: austrisu/frostyICS

repo_name: austrisu/frostyICS


text:
# Delete a Branch from the Origin

First, use `git branch -r` to list all remote repositories. Assuming you see one you want to delete, use the command `git push origin --delete <branch>` to remove it from the origin until it is republished.

repository: rocheio/til

repo_name: rocheio/til


text:
# Spike: Velero

## Background

28 June, 2019 - Can we use Velero for disaster/recovery?

## Purpose

 * Disaster Recovery
Sudden loss of cluster, all config and persisted data. Goal is to restore Radix platform itself as well as running applications with minimal downtime and user intervention.
 * Planned migration
Need to move configuration and persistent data from one healthy cluster to another with minimal downtime. We want to use Planned migration to also reduce configuration drift.

 * Possible other use-cases
Clone a cluster and do a test-upgrade on the shadow cluster.
Snapshot before in-place upgrade. Provides a possible way of roll-back in case of problems after upgrade.

#### Constraints/limitations

We do not support cross-cloud DR since that would involve transporting backups to a different cloud vendor causing all kinds of new challenges.

DR: User secrets cannot be backed up long term without consent.
Migration: We cannot guarantee that software is not re-built and re-deployed and may also run different versions simultaneously on both clusters for a short period. Secrets: Problem: Velero cannot back up locally, only to remote storage. Is this acceptable even if remote storage is deleted once migration is complete?

## Tools

velero - (previously heptio ark, bought by vmware) - version 1.0.0 released in may 2019.
https://github.com/pieterlange/kube-backup (not updated since feb. 22 2019) - Dumps all K8s objects to git. Optionally encrypted for secrets.
reshifter - https://github.com/mhausenblas/reshifter - (last commit dec 2018)

## Architecture

Velero uses Azure Blob Storage for config backup (etcd) and volume snapshots of Azure managed disks to back up persistent storage.

## Client installation

    wget https://github.com/heptio/velero/releases/download/v1.0.0/velero-v1.0.0-linux-amd64.tar.gz
    tar zxvf velero-v1.0.0-linux-amd64.tar.gz
    sudo mv velero-v1.0.0-linux-amd64/velero /usr/bin/

## Storage setup

    az account set --subscription "Omnia Radix Development"

    # Create a Resource Group that will contain the backups. This is to separate permissions since velero needs Contributor access to the whole resource group.
    AZURE_BACKUP_RESOURCE_GROUP=Velero_Backups
    az group create -n $AZURE_BACKUP_RESOURCE_GROUP --location NorthEurope

    # Create a new storage account ID (yes, the name is weird because of weird name constraints and requirements of global uniqueness)
    AZURE_STORAGE_ACCOUNT_ID="radixvelerobackupsdev"
    az storage account create --name $AZURE_STORAGE_ACCOUNT_ID --resource-group $AZURE_BACKUP_RESOURCE_GROUP --sku Standard_GRS --encryption-services blob --https-only true --kind BlobStorage --access-tier Hot

    BLOB_CONTAINER=velero
    az storage container create -n $BLOB_CONTAINER --public-access off --account-name $AZURE_STORAGE_ACCOUNT_ID

    # Get subscription ID
    AZURE_SUBSCRIPTION_ID=`az account list --query '[?isDefault].id' -o tsv`
    AZURE_TENANT_ID=`az account list --query '[?isDefault].tenantId' -o tsv`

    # Create a new service principal. Optionally specify a password with `--password xxx`
    # az ad sp create-for-rbac --name "http://velero" --role "Contributor"

    RG_PATH=`az group show --name ${AZURE_BACKUP_RESOURCE_GROUP} | jq -r ".id"`

    # Get service principal password and client ID
    AZURE_CLIENT_SECRET=`az ad sp create-for-rbac --name "velero" --scope="${RG_PATH}" --role "Contributor" --query 'password' -o tsv`
    AZURE_CLIENT_ID=`az ad sp list --display-name "velero" --query '[0].appId' -o tsv`

    # Put credentials into file

    cat << EOF  > ./velero-credentials
    AZURE_SUBSCRIPTION_ID=${AZURE_SUBSCRIPTION_ID}
    AZURE_TENANT_ID=${AZURE_TENANT_ID}
    AZURE_CLIENT_ID=${AZURE_CLIENT_ID}
    AZURE_CLIENT_SECRET=${AZURE_CLIENT_SECRET}
    EOF

    # Upload credentials to KeyVault
    az keyvault secret set \
        --vault-name radix-vault-dev \
        --name velero-credentials \
        --file velero-credentials

## Cluster installation

    # Download credentials file
    az keyvault secret download \
        --vault-name radix-vault-dev \
        --name velero-credentials \
        --file velero-credentials

    # Copy from above
    BLOB_CONTAINER=velero
    AZURE_BACKUP_RESOURCE_GROUP=Velero_Backups
    AZURE_STORAGE_ACCOUNT_ID=radixvelerobackupsdev

    # Add cluster specific MC group to credentials file
    CLUSTERNAME=stian-dr-g
    AZURE_RESOURCE_GROUP=MC_clusters_${CLUSTERNAME}_northeurope

    echo "AZURE_RESOURCE_GROUP=${AZURE_RESOURCE_GROUP}" >> velero-credentials

    # Install velero
    velero install --provider azure --prefix $CLUSTERNAME --bucket $BLOB_CONTAINER --secret-file ./velero-credentials --backup-location-config resourceGroup=$AZURE_BACKUP_RESOURCE_GROUP,storageAccount=$AZURE_STORAGE_ACCOUNT_ID --snapshot-location-config apiTimeout=300s --wait

## Cluster removal (partial)

If for some reason you need to re-install Velero you need to do some manual cleanup first. If you update credentials and other information `velero install` will NOT update the corresponding secrets and backup locations in the cluster as you might expect.

    kubectl delete ns velero

    or

    kubectl delete secret -n velero cloud-credentials
    kubectl delete deployment -n velero velero
    kubectl delete BackupStorageLocation -n velero default
    kubectl delete volumesnapshotlocations -n velero default

## Operation

Gotcha: After running velero in `--restore-only` mode it's easy to forget to revert to "read/write" mode. You will still be able to create new backup jobs but they will be queued in pending until you remove `--restore-only` with no warnings or notifications that the jobs are only queued and might never start.

To find out if velero is in

    --restore-only mode:
    kubectl get deploy/velero -n velero -o=jsonpath='{.spec.template.spec.containers[0].args}'

Set read/write mode:

    kubectl patch deployment velero -n velero --patch '{"spec": {"template": {"spec": {"containers": [{"name": "velero","args": ["server"]}]}}}}'

Set restore-only mode:

    kubectl patch deployment velero -n velero --patch '{"spec": {"template": {"spec": {"containers": [{"name": "velero","args": ["server", "--restore-only"]}]}}}}'

(Yes, this is the official way of changing between read only and read write according to Velero Slack)

This behaviour will change in version 1.1 when read/read-write will apply to the storage location rather than the server itself: https://github.com/heptio/velero/pull/1517

PS: If a restore has warnings (shown in `velero restore get`) they will not show up in the logs. You need to `velero restore describe backupname-1234` to view warnings (and probably errors).

### Ordering

In https://github.com/heptio/velero/issues/424 CRDs was added as a prioritized resource to be restored first. However, there is a time lag before the CRDs are "installed" in the cluster and if adding a CR before that will fail. There is a separate (open) issue here (https://github.com/heptio/velero/issues/964) about how to wait for CRDs to be ready before restoring CRs. Unfortunately the issue has been inactive for 8 months.

A work around to this might be to run two individual backups. One with ONLY CRDs and one excluding CRDs. Will investigate.

First backup: Resources in kube-system namespace AND global resources:

    velero backup create backup-system1 --exclude-namespaces velero --include-namespaces kube-system --include-cluster-resources=true --wait

    velero backup create backup-data1 --exclude-namespaces velero,kube-system --include-cluster-resources=false --wait

This does come with the possibility of inconsistencies if significant changes are done to global resources (CRDs) or kube-system in the time between the two backups, but the probability is very low.

### Scheduled backups

    velero schedule create full-daily --schedule="0 1 * * *" --selector 'backup notin (ignore)'

Default TTL for scheduled backups is 30 days but can be overwritten with --ttl 60d for example.

### On demand backups

    kubectl label secret -n velero cloud-credentials backup=ignore

    velero backup create backupname2 --selector 'backup notin (ignore)'

    kubectl logs -f -n velero deploy/velero

### Restore

#### Restore on to a blank cluster (disaster recovery)

    velero backup get

First set --restore-only on the new/target cluster, that way velero will not overwrite backups on the source storage before restore.

    kubectl patch deployment velero -n velero --patch '{"spec": {"template": {"spec": {"containers": [{"name": "velero","args": ["server", "--restore-only"]}]}}}}'

Then add the source bucket (prefix) as a new BackupStorageLocation:

    cat <<EOF | kubectl apply -n velero -f -
    apiVersion: velero.io/v1
    kind: BackupStorageLocation
    metadata:
        name: stian-dr-f
        labels:
            component: velero
    spec:
        provider: azure
        config:
            resourceGroup: Velero_Backups
            storageAccount: radixvelerobackupsdev
        objectStorage:
            bucket: velero
            prefix: stian-dr-f
    EOF

Restart velero by deleting the pod for it to pick up the new location

Then restore the system components and CRDs:

    velero restore create --from-backup system-hourly-20190628110044 --wait

And finally the actual component objects:

    velero restore create --from-backup data-hourly-20190628110044 --wait

Delete the source backup location after restoring before enabling read/write mode again:

    kubectl delete BackupStorageLocation sourcebucket -n velero
    kubectl patch deployment velero -n velero --patch '{"spec": {"template": {"spec": {"containers": [{"name": "velero","args": ["server"]}]}}}}'

PS: In an upcomming release of velero it will be possible to set read/write on a per location basis rather than per server.

##### Post-restore actions

Prometheus will not start since it's PersistentVolume is gone. Fix by deleting the StatefulSet and let prometheus-operator re-create it from scratch.

    kubectl delete pvc prometheus-prometheus-operator-prometheus-db-prometheus-prometheus-operator-prometheus-0
    kubectl delete statefulset prometheus-prometheus-operator-prometheus

PS: On one restore the prometheus object was not actually restored. Had to restore `data-hourly` again for it to appear.

If the cluster you have restored from is still active we might get a trashing/update loop between the old and new external-dns instances. This again might cause us to be rate-limited (max 500 updates in 5 minutes) by Azure in addition to constantly flipping DNS records.

Scale the external-dns instance that is no longer needed with:

    kubectl patch deployment external-dns --patch '{"spec": {"replicas": 0}}'

The NetworkPolicies added by the operator to all user environments (that allows the ingress-controller and Prometheus to access user components) uses a label on the default namespace in the rules. Velero does not change/update/merge between new and existing objects so that label will not be added to the default namespace and hence block the ingress from forwarding traffic to user components. We fix it by adding the label:

    kubectl label namespace default purpose=radix-base-ns

#### Restore on to a cluster with latest base components and Radix apps (migration)

# Big oops: `install_base_components.sh` cannot run on a new cluster
Due to the script relying on the cluster name being the cluster name. Which after a restore it's not actually any more.

## Metrics

Velero introduced metrics in https://github.com/heptio/velero/issues/84 , however it uses the not-recommended annotation way of exposing itself. The preferred way is using ServiceMonitors but https://github.com/coreos/kube-prometheus/pull/16 contains the code snippet to add the necessary config to make it work using the prometheus-operator helm chart.

Prometheus advices against using annotations because if limited flexibility in https://github.com/coreos/prometheus-operator/issues/1547 and https://github.com/prometheus/prometheus/pull/4131 and several other issues.

It does however work for simple use cases so I consider it best to enable support for annotations than adding custom service and servicemonitors to velero.

Adding support for prometheus scrape annotations in https://github.com/equinor/radix-platform/pull/161

Available metrics:

    # HELP velero_backup_attempt_total Total number of attempted backups
    # TYPE velero_backup_attempt_total counter
    velero_backup_attempt_total{schedule=""} 0
    # HELP velero_backup_deletion_attempt_total Total number of attempted backup deletions
    # TYPE velero_backup_deletion_attempt_total counter
    velero_backup_deletion_attempt_total{schedule=""} 0
    # HELP velero_backup_deletion_failure_total Total number of failed backup deletions
    # TYPE velero_backup_deletion_failure_total counter
    velero_backup_deletion_failure_total{schedule=""} 0
    # HELP velero_backup_deletion_success_total Total number of successful backup deletions
    # TYPE velero_backup_deletion_success_total counter
    velero_backup_deletion_success_total{schedule=""} 0
    # HELP velero_backup_failure_total Total number of failed backups
    # TYPE velero_backup_failure_total counter
    velero_backup_failure_total{schedule=""} 0
    # HELP velero_backup_partial_failure_total Total number of partially failed backups
    # TYPE velero_backup_partial_failure_total counter
    velero_backup_partial_failure_total{schedule=""} 0
    # HELP velero_backup_success_total Total number of successful backups
    # TYPE velero_backup_success_total counter
    velero_backup_success_total{schedule=""} 0
    # HELP velero_backup_total Current number of existent backups
    # TYPE velero_backup_total gauge
    velero_backup_total 0
    # HELP velero_restore_attempt_total Total number of attempted restores
    # TYPE velero_restore_attempt_total counter
    velero_restore_attempt_total{schedule=""} 1
    # HELP velero_restore_failed_total Total number of failed restores
    # TYPE velero_restore_failed_total counter
    velero_restore_failed_total{schedule=""} 0
    # HELP velero_restore_partial_failure_total Total number of partially failed restores
    # TYPE velero_restore_partial_failure_total counter
    velero_restore_partial_failure_total{schedule=""} 1
    # HELP velero_restore_success_total Total number of successful restores
    # TYPE velero_restore_success_total counter
    velero_restore_success_total{schedule=""} 0
    # HELP velero_restore_total Current number of existent restores
    # TYPE velero_restore_total gauge
    velero_restore_total 2
    # HELP velero_restore_validation_failed_total Total number of failed restores failing validations
    # TYPE velero_restore_validation_failed_total counter
    velero_restore_validation_failed_total{schedule=""} 0
    # HELP velero_volume_snapshot_attempt_total Total number of attempted volume snapshots
    # TYPE velero_volume_snapshot_attempt_total counter
    velero_volume_snapshot_attempt_total{schedule=""} 0
    # HELP velero_volume_snapshot_failure_total Total number of failed volume snapshots
    # TYPE velero_volume_snapshot_failure_total counter
    velero_volume_snapshot_failure_total{schedule=""} 0
    # HELP velero_volume_snapshot_success_total Total number of successful volume snapshots
    # TYPE velero_volume_snapshot_success_total counter
    velero_volume_snapshot_success_total{schedule=""} 0

## Other

We cannot add labels to all namespaces: https://github.com/kubernetes/kubernetes/issues/52326

Notes: Documentation is a bit sparse. Backed up files should be viewable manually by downloading from the remote storage. Mentions of possible problems when restoring service objects due to LoadBalancer IP assignments and integrations with cloud providers.

Moving customer secrets out of Kubernetes objects will greatly improve security overall as well as simplify backups. (Or maybe not, what if we back up the KeyVault credentials? Chicken-and-egg problem).

We should probably talk to users how they view the tradeoff of downtime requiring manual intervention after disaster recovery and maybe migration to avoid storing their credentials, or having their credentials persisted outside clusters in case of emergencies.

Out-of-cluster secrets:
sops - only CLI to encrypt yaml/json
kubesec - does not support Azure (inspired by sops)
https://github.com/Azure/kubernetes-keyvault-flexvol - does not provide stuff as env vars, only mount files. Will also be a hassle to integrate since it requires lots of pod values to be specified as well as a secret with credentials.
https://github.com/futuresimple/helm-secrets - wraps sops. encrypts secret portions of values.yaml files. Uses PGP.
https://github.com/StackExchange/blackbox - general git file encryption

# Protips

When working with velero logs, looking for errors and warnings is difficult. Filter out all `info` messages:

    velero restore logs backup-system2-20190620182150|grep -v "level=info"

repository: equinor/radix-platform

gha_language: Shell

repo_name: equinor/radix-platform


text:
# GitHub Workflow
This document describes the workflow used in our development process.

## 1. The GitHub Workflow
As a small team, we literally follow the so-called [GitHub Workflow](https://guides.github.com/introduction/flow/). It is also explained in the [GitHub Workflow Blog](http://scottchacon.com/2011/08/31/github-flow.html):

> It is very simple, very effective and works for fairly large teams - GitHub is 35 employees now, maybe 15-20 of whom work on the same project (github.com) at the same time. I think that most development teams - groups that work on the same logical code at the same time which could produce conflicts - are around this size or smaller. Especially those that are progressive enough to be doing rapid and consistent deployments.

Every team member should fully understand the workflow. Youtube https://youtu.be/oFYyTZwMyAg has a short tutorial for pull, reveiw and merge.

## 2. Basic Workflow
Each service has a repository that can be built, tested, released and deployed independently. For each repository, we use the following workflow:

1. The team creates a new repository for a new service/task.
2. A developer creates a branch (https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/) for a new feature or bug fix. Naming your branch with an meaningful name, such as fixCartNotExistBug, not fixbug.
3. A developer creates, edits, renames, moves, or deletes files.
4. Send a pull request (https://help.github.com/articles/using-pull-requests/).
5. Ask a peer to do a code review -- optionally there are some discussions and changes.
6. Make changes on the branch as needed. The pull request will update automatically.
7. Once changes are approved by the reviewer, the developer merges the pull request(https://help.github.com/articles/merging-a-pull-request/), once the branch is ready to go, using the big green button.
8. Delete the branch (https://help.github.com/articles/deleting-unused-branches/) in the pull request or on the branches page.

## 3. Naming Conventions
Naming is very important therefore we have a section just for it.

The repository name shoud use the `lowercase-with-hyphens` style. The repository should be named after its primary business role such as "customer-authentication" or "product-category".

Branch naming convention suggested by GitHub team:
>When you want to start work on anything, you create a descriptively named branch off of the stable master branch. Some examples in the GitHub codebase right now would be user-content-cache-key, submodules-init-task or redis2-transition. This has several advantages - one is that when you fetch, you can see the topics that everyone else has been working on. Another is that if you abandon a branch for a while and go back to it later, it’s fairly easy to remember what it was.

## 4. Rules
1. The master branch is alway ready to release.
2. Every pull request must be reviewed before merge to the master.
3. Open small pull request, review and merge frequently.

A developer may want to combine multiple trivial local commits into one o commits (and give it a helpful message summurizing major changes) to be reviewed and merged. Please check http://stackoverflow.com/questions/5308816/how-to-use-git-merge-squash for details. The [squash or not squash](http://jamescooke.info/git-to-squash-or-not-to-squash.html) explains the squash tradeoffs.

## 5. Related Resources
The [Pull request review guide](./review_guide/pull_request_review_guide.md) give detail information about review purpose, what to review and how to review.

## 6. Create issue and association to a pull request
Create an issue to track an question or a bug, and is you are fix an issue, then association your pull request with the issue, by add link in comments of the issue. like:
```
See [pull request](your pull request link)
```

repository: lixiawss/development-process

repo_name: lixiawss/development-process


text:
mistral
======

#### Table of Contents

1. [Overview - What is the mistral module?](#overview)
2. [Module Description - What does the module do?](#module-description)
3. [Setup - The basics of getting started with mistral](#setup)
4. [Implementation - An under-the-hood peek at what the module is doing](#implementation)
5. [Limitations - OS compatibility, etc.]
6. [Development - Guide for contributing to the module](#development)
7. [Contributors - Those with commits](#contributors)

Overview
--------

The Mistral module itself is a workflow service for OpenStack cloud.

Module Description
------------------

The mistral module is an attempt to make Puppet capable of managing the
entirety of mistral.

Setup
-----

### Beginning with mistral

To use the mistral module's functionality you will need to declare multiple
resources.  This is not an exhaustive list of all the components needed; we
recommend you consult and understand the
[core of openstack](http://docs.openstack.org) documentation.

Implementation
--------------

### Mistral

puppet-mistral is a combination of Puppet manifests and ruby code to deliver
configuration and extra functionality through types and providers.

### Types

#### mistral_config

The `mistral_config` provider is a children of the ini_setting provider. It allows one to write an entry in the `/etc/mistral/mistral.conf` file.

```puppet
mistral_config { 'DEFAULT/verbose' :
  value => true,
}
```

This will write `verbose=true` in the `[DEFAULT]` section.

##### name

Section/setting name to manage from `mistral.conf`

##### value

The value of the setting to be defined.

##### secret

Whether to hide the value from Puppet logs. Defaults to `false`.

##### ensure_absent_val

If value is equal to ensure_absent_val then the resource will behave as if `ensure => absent` was specified. Defaults to `<SERVICE DEFAULT>`

Beaker-Rspec
------------

This module has beaker-rspec tests

To run:

``shell
bundle install
bundle exec rspec spec/acceptance
``

Development
-----------

Developer documentation for the entire puppet-openstack project.

* https://wiki.openstack.org/wiki/Puppet#Developer_documentation

Contributors
------------

* https://github.com/openstack/puppet-mistral/graphs/contributors

branch_name: refs/heads/stable/mitaka


text:
🗺
Neighborhood Map

Neighborhood Map is the eighth project for the Udacity Frontend Developer Nanodegree Program.

⭐ Show a demo of this app ⭐

## Table of contents

- [Getting Started](#getting-started)
- [Deployment](#deployment)
- [Built With](#built-with)
- [License](#license)
- [Acknowledgments](#acknowledgments)

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites

You need [Node.js®](https://nodejs.org/en/) and [npm](https://www.npmjs.com) to run this app.

The Node Package Manager (npm) is distributed with Node.js. When you download Node.js, you automatically get npm installed on your computer.

Download the latest stable release from [https://nodejs.org/en/download/]() and install it with default settings. On Linux and macOS, you can install Node via the package manager, [as described here](https://nodejs.org/en/download/package-manager/).

To verify your installation open your terminal and look up where node and npm were installed and check their versions:

```console
foo@bar:~$ which node && node -v
foo@bar:~$ which npm && npm -v
```

### Installing

1. **Clone or download this repository**
Change to a folder you want the app folder in. Then clone the files of this repo to a new directory and changee into it:

```console
foo@bar:~$ git clone https://github.com/Sixl-Daniel/fend-neighborhood-map.git NewAppDirectory
foo@bar:~$ cd NewAppDirectory
```

2. **Install project dependencies**

```console
foo@bar:~$ npm install
```

3. **Start the development server**

```console
foo@bar:~$ npm start
```

Then point your browser to [http://localhost:3000/]() to see the app.

## Deployment

Build the app for production to the `/build` folder:

```console
foo@bar:~$ npm run build-ui && npm run build
```

Open your `package.json` and add a homepage field, if needed. The app is now ready to be deployed.

You can use a static web hosting service like [surge](http://surge.sh/), [netlify](https://www.netlify.com/), [GitHub Pages](https://pages.github.com/) or [Zeit](https://zeit.co/) for fast and easy publishing.

## Built With

### Software

* [Create React App](https://github.com/facebook/create-react-app)
* [Semantic-UI-React](https://github.com/Semantic-Org/Semantic-UI-React)
* [React Toastify](https://github.com/fkhadra/react-toastify)

### API's

* [Google Maps](https://cloud.google.com/maps-platform/maps/)
* [Foursquare](https://developer.foursquare.com/)

### Services

## License

This project was submitted by Daniel Sixl as part of the Frontend Developer Nanodegree Program at Udacity.

As part of [Udacity Honor Code](https://www.udacity.com/legal/community-guidelines), your submissions must be your own work, hence submitting this project as yours will cause you to break the Udacity Honor Code and the suspension of your account. Me, the author of the project, allow you to check the code as a reference, but if you submit it, it's your own responsibility if you get expelled.

© 2018 Daniel Sixl

This project is licensed under the MIT License - see the [LICENSE.md](./LICENSE.md) file for details.

## Acknowledgments

* Using Axios with React
https://alligator.io/react/axios-react/

* A template to make good `README.md`
https://gist.github.com/PurpleBooth/109311bb0361f32d87a2

* How to use Semantic UI with a custom theme in your CRA app
https://jsramblings.com/2018/03/04/how-to-use-semantic-ui-with-a-custom-theme-in-your-CRA-app.html

* How to load the google maps api `<script>` in my react app only when it is required?
https://stackoverflow.com/questions/41709765/how-to-load-the-google-maps-api-script-in-my-react-app-only-when-it-is-require/41710341

* How to serialize an Object into a list of URL query parameters?
https://stackoverflow.com/questions/6566456/how-to-serialize-an-object-into-a-list-of-url-query-parameters

* Resize svg icon for google map marker
https://stackoverflow.com/questions/23264872/resize-svg-icon-for-google-map-marker

* Making Google Maps work with React
https://www.klaasnotfound.com/2016/11/06/making-google-maps-work-with-react/

repository: Sixl-Daniel/fend-neighborhood-map

repo_name: Sixl-Daniel/fend-neighborhood-map


text:
# ElasticSearch mixin

This is a [mixin](https://github.com/monitoring-mixins/docs) for the [Prometheus metrics exporter for ElasticSearch from justwatch.com](https://github.com/justwatchcom/elasticsearch_exporter).

repository: grafana/jsonnet-libs

gha_language: Jsonnet

gha_license_id: NOASSERTION

repo_name: grafana/jsonnet-libs


text:
<!-- badges: start -->
  [![R build status](https://github.com/kelshmo/sageseqr/workflows/R-CMD-check/badge.svg)](https://github.com/kelshmo/sageseqr/actions)
<!-- badges: end -->
# Installation
`remotes::install_github("Sage-Bionetworks/sageseqr")`

# RNA-seq normalization workflow in R

The `sageseqr` package integrates the [`drake` R package](https://github.com/ropensci/drake/), the [`config` package for R](https://cran.r-project.org/web/packages/config/vignettes/introduction.html), and [Synapse](https://www.synapse.org/). `drake` tracks dependency relationships in the workflow and only updates data when it has changed. A `config` file allows inputs and parameters to be explicitly defined in one location. Synapse is a data repository that allows sensitive data to be [stored and shared responsibly](https://docs.synapse.org/articles/article_index.html#governance).

The workflow takes RNA-seq gene counts and sample metadata as inputs, normalizes counts by conditional quantile normalization [(CQN)](https://bioconductor.org/packages/release/bioc/html/cqn.html), removes outliers based on a user-defined threshold, empirically selects meaningful covariates and returns differential expression analysis results. The data is also visualized in several ways to help you understand meaningful trends. The visualizations include a heatmap identifying highly correlated covariates, a sample-specific x and y marker gene check, boxplots visualizing the distribution of continuous variables and a principal component analysis (PCA) to visualize sample distribution.

# The Targets

The series of steps that make up the workflow are called targets. The target objects are stored in a cache and can either be read or loaded into your environment with the `drake` functions `readd` or `loadd`. Source code for each target can be visualized by setting `show_source = TRUE` with `loadd` and `readd`.

Importantly, running `clean` will remove the data stored as targets ([but, the data is never completely gone!](https://books.ropensci.org/drake/walkthrough.html)). You may specific targets by name by passing them to the `clean` function.

The targets are called by the `sageseqr` `rnaseq_plan()` function and are:

Raw data:
- `import_metadata`- imports the raw metadata directly from synapse
- `import_counts` - imports the raw counts directly from synapse
- `biomart_results` - the complete list of genes with biomaRt annotations.

Exploratory data visualizations:
- `gene_coexpression` - the distribution of correlated gene counts.
- `boxplots` - the distribution of continuous variables.
- `sex_plot` - the distribution of samples by x and y marker genes.
- `sex_plot_pca` - a PCA of sex-specific expression to visualize more
                   dimensionality than `sex_plot`.
- `correlation_plot` - the correlation of covariates.
- `significant_covariates_plot` - the correlation of covariates to gene
                                  expression.
- `outliers` - the clustering of samples by PCA.
- `plot_de_volcano` - volcano plot of differentially expressed genes.

Transformed or normalized data:
- `clean_md` - metadata with factor and numeric types.
- `filtered_counts` - counts matrix with low gene expression removed.
- `biotypes` - gene proportions summarized by biotype.
- `cqn_counts` - CQN normalized counts.
- `model` - model selected by multivariate forward stepwise regression
            (evaluated by Bayesian Information Criteria (BIC)).
- `de` - differential expression results including adjusted p-values and gene list.
- `report` - output markdown report rendered as HTML.

# Access to Data

Anyone can create a [Synapse account](https://docs.synapse.org/articles/getting_started.html) and access public data in a variety of disciplines: [Alzheimer's Disease Knowledge portal](https://adknowledgeportal.synapse.org/), [CommonMind Consoritum](https://www.synapse.org/#!Synapse:syn2759792/wiki/69613).

repository: tmonjo/sageseqr

repo_name: tmonjo/sageseqr


text:
# USSF
Universal Silent Switch Finder

# Disclaimer
I wrote this about 10 years ago learning AutoIt, when I was playing
with Windows automation and had no real programming experience.

I am no longer maintaining this (obviously), so if you want to do
something with it, fork it and post your work on MSFN forums [1],
where it originated.

Thanks MSFN for the fun I had working on this, it surely brings up
memories :)

# AutoIt compatibility
Check [2] for a full list of changes in AutoIt that might require
updating the code; or just use an older version of AutoIt.

A quick look at [2] indicates that AutoIt 3.3.6 or newer requires
at least:
- include new-style headers (EditConstants, ComboConstants etc.);
- rewrite or remove code using "InetGetActive";

[1] http://www.msfn.org/board/
[2] https://www.autoitscript.com/autoit3/docs/script_breaking_changes.htm


text:
React stack nav
==========
Simple universal navigation for React Native and React

- **Universal** Works in iOS, Android, and Web
- **Familiar API** Has the same API as the web's [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API)
- **Back/forward button support** Automatic support for Android back button and back/forward buttons on web
- **Deep linking support** Automatic support for deep linking
- **Server-side rendering** Simple as pre-loading redux state with the requested url
- **Composable and declarative** Uses React's component tree to compose and handle routes
- **Use any navigation paradigm** Abstract enough to let you build the navigation with any UI components you want
- **Easy to understand** You can read the source! Only ~300 lines of code

### Examples

iOS | Android | Web
:---:|:---:|:---:
| **[Drawer example](https://github.com/tuckerconnelly/react-stack-nav-examples/tree/master/Drawer)** |
![iOS drawer Example](https://cloud.githubusercontent.com/assets/4349082/20870986/9dd28bc6-ba5e-11e6-9dfb-0f22e334f95e.gif)  |  ![Android drawer example](https://cloud.githubusercontent.com/assets/4349082/20870990/a194c5ee-ba5e-11e6-923b-7a82d0d1e3d3.gif)  |  ![web drawer example](https://cloud.githubusercontent.com/assets/4349082/20870981/9a86f06a-ba5e-11e6-8762-6220955ce10a.gif)
| **[Bottom nav with stacks example](https://github.com/tuckerconnelly/react-stack-nav-examples/tree/master/BottomNavWithStacks)** |
![iOS bottom nav Example](https://cloud.githubusercontent.com/assets/4349082/20981756/dc85dac2-bc83-11e6-85d6-b2733e16b8dd.gif)  |  ![Android Bottom nav example](https://cloud.githubusercontent.com/assets/4349082/20982072/0a2000ce-bc85-11e6-9b6a-9cd56f3d2bb6.gif)  |  ![web bottom nav example](https://cloud.githubusercontent.com/assets/4349082/20981759/e114fc76-bc83-11e6-8165-85202f231fbf.gif)

The examples repo is [over here](https://github.com/tuckerconnelly/react-stack-nav-examples).

You can also check out a real-world example in the [Carbon UI Docs source](https://github.com/tuckerconnelly/carbon-ui-docs).

### What it looks like

A navigation component (drawer, tabs, anything):
```js
import React from 'react'
import { Button, View } from 'react-native'
import { connect } from 'react-redux'
import { pushState } from 'react-stack-nav'

const Navigation = ({ pushState }) =>
  <View>
    <Button onPress={() => pushState(0, 0, '')}>Go to home</Button>
    <Button onPress={() => pushState(0, 0, '/myRoute')}>Go to My Route</Button>
  </View>

const mapDispatchToProps = { pushState }

export default connect(null, mapDispatchToProps)(Navigation)
```

A component receives and handles the first fragment of the url:
```js
import React from 'react'
import { Text, View } from 'react-native'
import { createOrchestrator } from 'react-stack-nav'

const Index = ({ routeFragment }) =>
  <View>
    {routeFragment === '' && <Text>Home</Text>}
    {routeFragment === 'myRoute' && <Text>My route</Text>}
  </View>

export default createOrchestrator()(Index)
```

### Installation

```
npm -S i react-stack-nav
```

Then match your redux setup to this:

```js
import { createStore, applyMiddleware, compose, combineReducers } from 'redux'
import thunk from 'redux-thunk'
import { navigation, attachHistoryModifiers } from 'react-stack-nav'
import { BackAndroid, Linking } from 'react-native'

import app from './modules/duck'

const rootReducer = combineReducers({ navigation })

export default (initialState = {}) =>
  createStore(
    rootReducer,
    initialState,
    compose(
      applyMiddleware(thunk),
      attachHistoryModifiers({ BackAndroid, Linking }),
    ),
  )
```

If you want deep linking to work, make sure you set it up per instructions [here](https://facebook.github.io/react-native/docs/linking.html).

### Principles

- Treat the redux store as a single-source-of-truth for routing
- Use URLs and the History API, even in React Native
- Treat the URL as a stack, and "pop" off fragments of the URL to orchestrate transitions between URLs
- Leave you in control, favor patterns over frameworks

### Usage

At the core of react-stack-nav is the `navigation` reducer, whose state looks like this:

```js
{
  index: 0, // The index of the current history object
  history: [{ statObj, title, url }], // An ordered list of history objects from pushState
}
```

If you want to navigate to a new url/page, use the `pushState` action creator in one of your components (it's the same as [history.pushState](https://developer.mozilla.org/en-US/docs/Web/API/History_API)!):

```js
import { pushState } from 'react-stack-nav'

class MyComponent {
  _handleClick = () => this.props.pushState({ yo: 'dawg' }, 'New Route', '/newRoute')
}
```

That'll push a new object onto `state.navigation.history`, so your new navigation reducer state might look like this:

```js
{
  index: 1,
  history: [
    { stateObj: {}, title: '', url: '' },
    { stateObj: {}, title: 'New Route', '/newRoute' }
  ]
}
```

Now say you clicked back in the browser (or hit the android back button), your state would automatically update to:

```js
{
  index: 0,
  history: [/* same as above */]
}
```

With `index: 0` to say, hey, we're on the first history entry.

 Orchestrators pops off an element in the stack and declaratively handles transitions when it changes:

```
 users     -------> Popped off and handled by first orchestrator in component tree
-------
   1       -------> Popped off and handled by second orchestrator in component tree
-------
profile    -------> Popped off and handled by third orchestrator in component tree
```

The first orchestrator found in the component tree would handle changes to the top of the stack:

```js
import { createOrchestrator } from 'react-stack-nav'

const Index = ({ routeFragment }) => {
  <View>
    {routeFragment === 'users' && <UsersIndex />}
    {routeFragment === 'pictures' && <PicturesIndex />}
  </View>
}

export default createOrchestrator()(Index)
```

The next orchestrators found in the tree would handle the next layer of the url stack, so `UsersIndex` might look like this:

```js
class UsersIndex extends Component {
  async componentWillReceiveProps(next) {
    const { routeFragment } = this.props
    if (routeFragment !== next.routeFragment) return

    this.setState({ user: await fetchUserData(routeFragment) })
  }

  render() {
    <View>
     {/* Use this.state.user info */}
    </View>
  }
}

export default createOrchestrator('users')(UsersIndex)
```

`createOrchestrator()` accepts a string or a regular expression for that particular layer of that stack. If it doesn't match the current layer of the url, `props.routeFragment` will be undefined.

You could create orchestrators _ad inifitum_ all the way down the component tree to handle as much of the URL stack as you want:

```js
const UserIndex = ({ routeFragment }) => {
  <View>
    {routeFragment === 'profile' && <ProfileIndex />}
    {routeFragment === 'settings' && <SettingsIndex />}
  </View>
}

export default createOrchestrator(/\d+/)(UserIndex)
```

```js
const ProfileIndex = ({ routeFragment }) => {
  <View>
    {/* Would handle /users/${userId}/profile/posts */}
    {routeFragment === 'posts' && <UserPosts />}
    {/* Would handle /users/${userId}/profile/pictures */}
    {routeFragment === 'pictures' && <UserPictures />}
  </View>
}

export default createOrchestrator('profile')(ProfileIndex)

```

### API

- `attachHistoryModifiers` - Store enhancer for redux, handles android back-button presses, browser back/forward buttons, and deep linking
- `createOrchestrator(fragment: string | regexp)` -- Higher-order-component that creates an orchestrator
- `navigation` -- `navigation` reducer for setting up your store

#### Action creators

These are the same as the [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) :

- `pushState(stateObj: object, title: string, url: string)`: Pushes a new state onto the history array
- `replaceState(stateObj: object, title: string, url: string)`: Replaces the current state on the history array
- `back(reduxOnly: bool)`: Moves the `navigation.index` back one. If `reduxOnly` is true, it won't change the browser `history` state (this is mostly for internal use)
- `forward(reduxOnly: bool)`: Moves the `navigation.index` forward one, reduxOnly is the same as for `back()`
- `go(numberOfEntries: int)`: Moves the `navigation.index` forward/backward by the passed number (`go(1)` is the same as `forward()`, for example).
- `replaceTop(stateObj: object, title: string, toUrl: string)`: Like `replaceState`, but appends the `toUrl` to the current url instead of replacing it outright. Primarily used for index redirects.
- `pushTop(stateObj: object, title: string, toUrl: string)`: Like `pushState`, but appends the `toUrl` to the current url instead of replacing it outright. Primarily used for card stacks.

### Connect

Follow the creator on Twitter, [@TuckerConnelly](https://twitter.com/TuckerConnelly)

### License
MIT

repository: wickedest/react-stack-nav

repo_name: wickedest/react-stack-nav


text:
# jshell
Find the docker-repository here: https://hub.docker.com/r/kawe/jshell/

Simple wetty (web-based tty) JShell (Java 9) image for fast and quick java-prototyping.

Start this container - start your browser - goto http://localhost:8080 - enjoy the power of JShell

This container is based on wetty (web-based tty) and the official jdk-9 image brining the joy of JShell into your browser. No need to have anythink locally installed - prototype your JDK 9 features in seconds and remote.

__Login with password: shell__

Happy coding!

```
docker run -p 8080:8080 kawe/jshell
```
or
```
docker-compose up
```

repository: kai-wegner/jshell

repo_name: kai-wegner/jshell


text:
# Shairport Sync addon for Home Assistant

[![GitHub Release][releases-shield]][releases]
[![License][license-shield]](LICENSE)

Enables Airplay audio streaming to Home Assistant.

## Docker status

![Supports armhf Architecture][armhf-shield]
![Supports armv7 Architecture][armv7-shield]
![Supports aarch64 Architecture][aarch64-shield]
![Supports amd64 Architecture][amd64-shield]
![Supports i386 Architecture][i386-shield]

[![Docker Layers][layers-shield]][microbadger]
[![Docker Pulls][pulls-shield]][dockerhub]

## Repository

To install use this [repository](https://github.com/v3rm0n/hassio)

[aarch64-shield]: https://img.shields.io/badge/architecture-aarch64-blue.svg
[armhf-shield]: https://img.shields.io/badge/architecture-armhf-blue.svg
[armv7-shield]: https://img.shields.io/badge/architecture-armv7-blue.svg
[amd64-shield]: https://img.shields.io/badge/architecture-amd64-blue.svg
[i386-shield]: https://img.shields.io/badge/architecture-i386-blue.svg
[license-shield]: https://img.shields.io/github/license/v3rm0n/addon-shairport-sync.svg
[dockerhub]: https://hub.docker.com/r/maidok/shairport-sync
[layers-shield]: https://images.microbadger.com/badges/image/maidok/shairport-sync.svg
[microbadger]: https://microbadger.com/images/maidok/shairport-sync
[pulls-shield]: https://img.shields.io/docker/pulls/maidok/shairport-sync.svg
[version-shield]: https://images.microbadger.com/badges/version/maidok/shairport-sync.svg
[releases-shield]: https://img.shields.io/github/release/v3rm0n/addon-shairport-sync.svg
[releases]: https://github.com/v3rm0n/addon-shairport-sync/releases

repository: dadge/addon-shairport-sync

repo_name: dadge/addon-shairport-sync