text:
# Cones

A 201x201 grid of cones, where the shapes are generated in code instead of using asset/prefab files. The lights and camera also oscillate based on game time.

This project started as a clone of Amethyst's [material](https://github.com/amethyst/amethyst/tree/master/examples/material) example, then I morphed it into what it is now.

Demo (YouTube):

[![Cones](https://img.youtube.com/vi/zli90-39Ft4/0.jpg)](https://www.youtube.com/watch?v=zli90-39Ft4)

repository: crsaracco/amethyst-playground

repo_name: crsaracco/amethyst-playground


text:
## AirLibre: A UBNT Python API For The Masses

The goal of AirLibre is to give Ubiquiti Networks (UBNT) users a way of managing their devices without being relient on UBNT's software.

### No GUI; Not for the Faint of Heart
This was by design so configuration changes can be as flexible as Python itself. If you want to build a GUI for it, I'm more than happy to cheer you on with pom poms!

### What It Is and What It Isn't
AirLibre is not a standalone program you can use to manage devices, it is an API (Application Programming Interface). Its purpose is to make working with UBNT radios and routers like working with any other kind of data.

## License
The software uses the Apache License (V.2) as described in LICENSE.txt.

## Disclaimer
I am not associated with UBNT in any form except or being a user and a community member. Cleartivly, UBNT is not responsible for this code, if you feel like you need to express your opinion about this software, please do so to me, not to them.

__TL;DR: I don't get paid for working on this this code!__

## Roadmap
- [x] Implement low level Web UI features through API
- [ ] Implement high level Web UI features through API
- [ ] Make usable for mass configuration

repository: TomMalvoRiddle/AirLibre

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: TomMalvoRiddle/AirLibre


text:
---
title: General Requirements
permalink: /safemanagement/general/
third_nav_title: Safe Management Requirements
---

To provide a safe working environment and to prevent virus transmission at the workplace, businesses are required to abide by the nation-wide general requirements for workplaces issued on 9 May 2020. Businesses should also adhere to the sector-specific requirements.

All businesses are to comply with the following requirements:
- Employers must ensure that employees who have been working from home continue to do so. Working from home should continue to be the default mode of working, to reduce physical interactions in the workplace and minimise the spread of COVID-19.
- Employees should only return to the workplace where it is demonstrably necessary, for purposes that cannot be carried out via telecommuting (e.g. to access specialised terminals or dedicated machines, or to complete a contract or transaction that is legally required to be completed in person and on-site).

Please view the infographic below for an overview of the safe management measures.

**Be Ready, Stay Safe**

**7 Key Requirements for Safe Management at Workplaces**

**Infographic**

[![Safe Management Practices](/images/infog.jpg)](/safemanagement/general/)

**Video**

**Resources for download**

|         Safe Management          |                                                                                Link                                                                                |
| :------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
|         Full Infographic         |                                                                                PDF                                                                                |
| Infographics - Individual frames | JPG
  JPG
  JPG
 JPG
 JPG
 JPG |

license: MIT

repository: ICA-STO-ED/govtech-gobusiness

repo_name: ICA-STO-ED/govtech-gobusiness


text:
# Talos CI
[![Docker Image CI](https://github.com/aspartame21/talos/workflows/Docker%20Image%20CI/badge.svg)](https://github.com/aspartame21/talos/packages/)
[![Maintainability](https://api.codeclimate.com/v1/badges/364696670d5fdc69a5ca/maintainability)](https://codeclimate.com/github/Talos-Project/talos-webhook/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/364696670d5fdc69a5ca/test_coverage)](https://codeclimate.com/github/Talos-Project/talos-webhook/test_coverage)

Talos CI is a webhook based application that is mainly focused on providing some extensions to existing platforms and automation for some events.
Because of its high modularity, every use case is a plugin. You can choose one of the existing plugins:

- [talos-welcome](https://github.com/aspartame21/talos-welcome)
- [talos-blunderbuss](https://github.com/aspartame21/talos-blunderbuss)
- [talos-testrunner](https://github.com/aspartame21/talos-testrunner)
- [talos-lgtm](https://github.com/aspartame21/talos-lgtm)
- [talos-approve](https://github.com/aspartame21/talos-approve)
- [talos-caturday](https://github.com/aspartame21/talos-caturday)

Or you can implement functionality for your business needs by writing your plugin. For such a case, you can start from forking [talos-plugin-boilerplate](https://github.com/aspartame21/talos-plugin-boilerplate).

## Getting Started

### Node Environment
Talos requires [Node.js](https://nodejs.org) v8+ to run.

Clone the repo and cd into it
```bash
git clone https://github.com/aspartame21/talos.git talos && cd $_
```
Install dependencies
```bash
npm i
```
Build the project
```bash
npm run build
```
If you are using Gitlab install gitlab-client
```bash
npm i talos-gitlab-client
```
Install plugins you want to include to your project (optional)
```bash
npm i <plugin name>
```
Following the [guide](#Configuration) configure the project and run
```bash
npm start
```

### Docker
Make sure you are logged in to docker.pkg.github.com from docker-cli. If you don't generate a Github OAuth token and use the following command to login
```bash
docker login docker.pkg.github.com -u <Github Username> -p <Github OAuth token>
```
Prepare the [config file](#Configuration) and run the following command
``` bash
docker run -v "$PWD/.talos.yaml:/usr/src/app/.talos.yaml" -p 3000:3000 docker.pkg.github.com/aspartame21/talos/talos-webhook
```

## Configuration
Create a file with name `.talos.yaml` and populate it with values. You can see all the [configuration options](#Configuration-Options) bellow.

### Configuration Options
Name | Description | Default Value
--- | --- | ---
git.client | Git Client Provider | talos-gitlab-client
git.host | Host of git server | https://gitlab.com/
git.token |  OAuth Token to perform actions | -
plugins | Plugins for webhook | []
> **Tip:**
> You can use `.talos.example.yaml` file as a reference

## Contribution
If you want to help the project grab an issue and send us a pull request :wink:

## Support
If you have any questions file an [issue](https://github.com/aspartame21/talos/issues) or join our [slack workspace](https://join.slack.com/t/talos-project/shared_invite/enQtODUyMTAyMDAzMzAwLTliNmNhZTk0NGQ0OTA4MGNlYTdiZDk2ZDEzMmI3NjJjZWUyNTNkYjU4ODE1NjI1NWYyNTk3MDA3MWU2MzRhODY).

## License

[MIT](https://github.com/aspartame21/talos/blob/master/LICENSE)

---
_Copyright 2019 [Talos CI](https://github.com/aspartame21/talos/graphs/contributors)_

repository: Talos-Project/talos-webhook

gha_language: TypeScript

gha_license_id: MIT

repo_name: Talos-Project/talos-webhook


text:
# Oculus - Demo Webview for minicap (on android container)

1. Make sure adb connected to device

2. Push minicap executables to remote android

   ```Bash
   ./run-device.sh push
   ```

3. Run minicap on remote

   ```Bash
   ./run-device.sh
   ```

4. Start nodejs application and browse to http://localhost:9002 for a demo.

   ```Bash
   run-node-ws.sh
   ```

See [README](./node-minicap-fp/README.md) for more help.

repository: FoilPlanet/oculus

repo_name: FoilPlanet/oculus


text:
# SAP and Azure integration demo with Microsoft Teams and Outlook365

# Introduction
The intention of this demo is to implement a basic scenario for integrating and displaying SAP ERP data in a Teams channel or an e-mail generated by Outlook.
This can be conveniently achieved by consuming OData-services of the SAP Netweaver Gateway Server with a Logic App.
To make this demo easily reproducible, the public SAP Gateway demo system [E5]( https://blogs.sap.com/2017/12/05/new-sap-gateway-demo-system-available/) is used. For productive scenarios utilizing interfaces like IDoc, BAPI, or RFC the new [Azure Logic Apps SAP Connector](https://docs.microsoft.com/en-us/azure/logic-apps/logic-apps-using-sap-connector) is recommended.

Ideally this first demo is an inspiration for more advanced Microsoft Modern Workplace integration demos.
For example creating a Teams based chatbot to communicate with SAP would be one potential scenario. Pushing [SAP S/4HANA Cloud Business Events](https://api.sap.com/package/SAPS4HANACloudBusinessEvents?section=Artifacts) to Teams could be a relevant scenario too.

The completed Logic App can be found [here](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/LogicApp.txt)

![Architecture]( https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/Architekture.png)

# Prerequisites

Optional:

For testing the SAP OData-services the recommendation is to utilize Visual Studio Code and the [REST Client extension](https://marketplace.visualstudio.com/items?itemName=humao.rest-client) for VS Code.

Basic knowledge how to install Visual Studio Code and the corresponding REST client extension is a prerequisite.
The REST client is required to acquire the JSON payload, which is later used for parsing the JSON in the Logic App.

To implement this demo Visual Studio Code is not mandatory, the generated payload for this specific service is stored in GitHub for your convenience.

Mandatory:

For implementing the demo an user for the SAP community is required and can be registered [here](https://www.sap.com/community/resources/registration-and-profile.html).

This SAP community user is the prerequisite to register a [E5](https://blogs.sap.com/2017/12/05/new-sap-gateway-demo-system-available/) demo system user.

Basic knowledge how to create a Logic App as a prerequisite, since this is not coved in this tutorial.

# Working with the sales orders service
For this demo, the SalesOrderSet OData service of the SAP Gateway Demo System will be utilized to display data in Teams:
https://sapes5.sapdevcenter.com/sap/opu/odata/iwbep/GWSAMPLE_BASIC/SalesOrderSet

For testing purposes, the service can be consumed via the browser by clicking on the URL.
The service returns set of sales orders.
To call the service from the REST Client the following command is required:

```
# @name getSalesOrders
GET https://sapes5.sapdevcenter.com/sap/opu/odata/iwbep/GWSAMPLE_BASIC/SalesOrderSet?$top=100  HTTP/1.1
Authorization: Basic YOURUSER YOURPWD
Accept: application/json;odata=verbose
```

Attention, there is a blank between the username and password!

After executing the GET command the payload for the sales order will be returned.
This payload will be required in the Logic App pipeline to parse the JSON.

# Creating the Logic App

1.	The first step is to create a Logic App with the name LAP_SAP_TEAMS_SALESORDER
2.	Create blank app
3.	Search for “recurrence” and insert the corresponding trigger

![Recurrence Trigger]( https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/Recurrence_Trigger.png)

4.	Now insert search for HTTP and insert the corresponding action:

![HTML ACTION](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/HTTP_ACTION.png)

Implement the HTTP action to get the top 50 SalesOrders:

```
URI:
https://sapes5.sapdevcenter.com/sap/opu/odata/iwbep/GWSAMPLE_BASIC/SalesOrderSet?$top=50

Headers:
Accept : application/json;odata=verbose

Authentication: Basic + Your user and pwd for the E5 demosystem

```

![HTML ACTION](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/HTTP_ACTION_1.png)

Now add a Parse JSON action and execute the following steps:
1.	Add the body output of the HTTP request
2.	Maintain the JSON payload of former service call by copying the [content](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/JSON_Payload.txt) of the file.

![PARSE_JSON](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/ParseJSON.png)

The next step is to initialize a variable with the name ArraySalesOrder of the type array.
The variable is used to store each row or sales order of the parsed JSON resultset.

![Variable](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/InitializeVariable.png)

After creating the variable a “For each” control is required.
Input for the for each statement is the variable “results” from “Parse JSON”

The next step is to embed a “Compose” action into the "For each" control.

![FOREACH](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/ForEach1.png)

In addition a “Compose” action has to be inserted into the “For each” element.

As next step this code needs to be inserted as “Inputs” for the “Compose” action:

```
{
        "BillingStatus": "@{items('For_each')?['BillingStatus']}",
        "BillingStatusDescription": "@{items('For_each')?['BillingStatusDescription']} ",
        "ChangedAt": "@{items('For_each')?['ChangedAt']}",
        "CreatedAt": "@{items('For_each')?['CreatedAt']}",
        "CurrencyCode": "@{items('For_each')?['CurrencyCode']}",
        "CustomerID": "@{items('For_each')?['CustomerID']}",
        "CustomerName": "@{items('For_each')?['CustomerName']}",
        "DeliveryStatus": "@{items('For_each')?['DeliveryStatus']}",
        "DeliveryStatusDescription": "@{items('For_each')?['DeliveryStatusDescription']}",
        "GrossAmount": "@{items('For_each')?['GrossAmount']}",
        "LifecycleStatus": "@{items('For_each')?['LifecycleStatus']}",
        "LifecycleStatusDescription": "@{items('For_each')?['LifecycleStatusDescription']}",
        "NetAmount": "@{items('For_each')?['NetAmount']}",
        "Note": "",
        "NoteLanguage": "@{items('For_each')?['NoteLanguage']}",
        "SalesOrderID": "@{items('For_each')?['SalesOrderID']}",
        "TaxAmount": "@{items('For_each')?['TaxAmount']}"
}

```

![FOREACH2](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/ForEach2.png)

After the creation of the mappings for the JSON elements in the collection, each record needs to be added to the variable ArraySalesOrder within the “For each” action. To achieve this a “Append to array variable” action needs to be added. The “value” will be the “Outputs” of “Compose”.

![FOREACH3](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/ForEach3.png)

In order to create a formatted message in Teams we pass the “ArraySalesOrders” variable to a "Ceate HTML Table" action.

![HTMLTABLE](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/HTML_TABLE.png)

The next step is to add the result of the HTML table (“Output”) to a Teams “Post a message V(3)” action:

![TEAMSMESSAGE](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/TEAMS_MESSAGE.png)

The result in Teams will look like:
![TEAMSDISPLAY](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/TEAMS_DISPLAY.png)

Finally a "Send an email (V2)" Outlook 365 action can utilizes to send the SAP sales order as e-mail:

![OUTLOOK365](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/Outlook365.png)

# Summary:
The intention of the tutorial was to demonstrate the easy integration of SAP data with Microsoft Teams or Outlook365. The Logic App and the dataflow is implemented in a graphical and therefore in a highly maintainable and reproducible fashion. Finally, no deep programming skills were required to implement this scenario. Next to the public SAP E5 demo-system, the [SAP API Business Hub](https://api.sap.com/) and [Microsoft Graph](https://developer.microsoft.com/en-us/graph/graph-explorer) provide countless options to integrate the Intelligent Cloud and the Intelligent Enterprise.

Update:
The layout and of the SAP data displayed in Teams has been improved by using an [Adaptive Card](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/LogicApp_AdaptiveCard.txt)

![ADAPTIVE_CARD](https://github.com/ROBROICH/SAP_AND_AZURE_TEAMS_DEMO/blob/master/AdaptiveCard.png)


text:
# Kata Containers Architecture

## Overview

Kata Containers is an open source community working to build a secure
container [runtime](#runtime) with lightweight virtual machines (VM's)
that feel and perform like standard Linux containers, but provide
stronger [workload](#workload) isolation using hardware
[virtualization](#virtualization) technology as a second layer of
defence.

Kata Containers runs on [multiple architectures](../../../src/runtime/README.md#platform-support)
and supports [multiple hypervisors](../../hypervisors.md).

This document is a summary of the Kata Containers architecture.

## Background knowledge

This document assumes the reader understands a number of concepts
related to containers and file systems. The
[background](background.md) document explains these concepts.

## Example command

This document makes use of a particular [example
command](example-command.md) throughout the text to illustrate certain
concepts.

## Virtualization

For details on how Kata Containers maps container concepts to VM
technologies, and how this is realized in the multiple hypervisors and
VMMs that Kata supports see the
[virtualization documentation](../virtualization.md).

## Compatibility

The [Kata Containers runtime](../../../src/runtime) is compatible with
the [OCI](https://github.com/opencontainers)
[runtime specification](https://github.com/opencontainers/runtime-spec)
and therefore works seamlessly with the
[Kubernetes Container Runtime Interface (CRI)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
through the [CRI-O](https://github.com/kubernetes-incubator/cri-o)
and [containerd](https://github.com/containerd/containerd)
implementations.

Kata Containers provides a ["shimv2"](#shim-v2-architecture) compatible runtime.

## Shim v2 architecture

The Kata Containers runtime is shim v2 ("shimv2") compatible. This
section explains what this means.

> **Note:**
>
> For a comparison with the Kata 1.x architecture, see
> [the architectural history document](history.md).

The
[containerd runtime shimv2 architecture](https://github.com/containerd/containerd/tree/main/runtime/v2)
or _shim API_ architecture resolves the issues with the old
architecture by defining a set of shimv2 APIs that a compatible
runtime implementation must supply. Rather than calling the runtime
binary multiple times for each new container, the shimv2 architecture
runs a single instance of the runtime binary (for any number of
containers). This improves performance and resolves the state handling
issue.

The shimv2 API is similar to the
[OCI runtime](https://github.com/opencontainers/runtime-spec)
API in terms of the way the container lifecycle is split into
different verbs. Rather than calling the runtime multiple times, the
container manager creates a socket and passes it to the shimv2
runtime. The socket is a bi-directional communication channel that
uses a gRPC based protocol to allow the container manager to send API
calls to the runtime, which returns the result to the container
manager using the same channel.

The shimv2 architecture allows running several containers per VM to
support container engines that require multiple containers running
inside a pod.

With the new architecture [Kubernetes](kubernetes.md) can
launch both Pod and OCI compatible containers with a single
[runtime](#runtime) shim per Pod, rather than `2N+1` shims. No stand
alone `kata-proxy` process is required, even if VSOCK is not
available.

## Workload

The workload is the command the user requested to run in the
container and is specified in the [OCI bundle](background.md#oci-bundle)'s
configuration file.

In our [example](example-command.md), the workload is the `sh(1)` command.

### Workload root filesystem

For details of how the [runtime](#runtime) makes the
[container image](background.md#container-image) chosen by the user available to
the workload process, see the
[Container creation](#container-creation) and [storage](#storage) sections.

Note that the workload is isolated from the [guest VM](#environments) environment by its
surrounding [container environment](#environments). The guest VM
environment where the container runs in is also isolated from the _outer_
[host environment](#environments) where the container manager runs.

## System overview

### Environments

The following terminology is used to describe the different or
environments (or contexts) various processes run in. It is necessary
to study this table closely to make sense of what follows:

| Type | Name | Virtualized | Containerized | rootfs | Rootfs device type | Mount type | Description |
|-|-|-|-|-|-|-|-|
| Host | Host | no `[1]` | no | Host specific | Host specific | Host specific | The environment provided by a standard, physical non virtualized system. |
| VM root | Guest VM | yes | no | rootfs inside the [guest image](guest-assets.md#guest-image) | Hypervisor specific `[2]` | `ext4` | The first (or top) level VM environment created on a host system. |
| VM container root | Container | yes | yes | rootfs type requested by user ([`ubuntu` in the example](example-command.md)) | `kataShared` | [virtio FS](storage.md#virtio-fs) | The first (or top) level container environment created inside the VM. Based on the [OCI bundle](background.md#oci-bundle). |

**Key:**

- `[1]`: For simplicity, this document assumes the host environment
  runs on physical hardware.

- `[2]`: See the [DAX](#dax) section.

> **Notes:**
>
> - The word "root" is used to mean _top level_ here in a similar
>   manner to the term [rootfs](background.md#root-filesystem).
>
> - The term "first level" prefix used above is important since it implies
>   that it is possible to create multi level systems. However, they do
>   not form part of a standard Kata Containers environment so will not
>   be considered in this document.

The reasons for containerizing the [workload](#workload) inside the VM
are:

- Isolates the workload entirely from the VM environment.
- Provides better isolation between containers in a [pod](kubernetes.md).
- Allows the workload to be managed and monitored through its cgroup
  confinement.

### Container creation

The steps below show at a high level how a Kata Containers container is
created using the containerd container manager:

1. The user requests the creation of a container by running a command
   like the [example command](example-command.md).
1. The container manager daemon runs a single instance of the Kata
   [runtime](#runtime).
1. The Kata runtime loads its [configuration file](#configuration).
1. The container manager calls a set of shimv2 API functions on the runtime.
1. The Kata runtime launches the configured [hypervisor](#hypervisor).
1. The hypervisor creates and starts (_boots_) a VM using the
   [guest assets](guest-assets.md#guest-assets):

   - The hypervisor [DAX](#dax) shares the
     [guest image](guest-assets.md#guest-image)
     into the VM to become the VM [rootfs](background.md#root-filesystem) (mounted on a `/dev/pmem*` device),
     which is known as the [VM root environment](#environments).
   - The hypervisor mounts the [OCI bundle](background.md#oci-bundle), using [virtio FS](storage.md#virtio-fs),
     into a container specific directory inside the VM's rootfs.

     This container specific directory will become the
     [container rootfs](#environments), known as the
     [container environment](#environments).

1. The [agent](#agent) is started as part of the VM boot.

1. The runtime calls the agent's `CreateSandbox` API to request the
   agent create a container:

   1. The agent creates a [container environment](#environments)
      in the container specific directory that contains the [container rootfs](#environments).

      The container environment hosts the [workload](#workload) in the
      [container rootfs](#environments) directory.

   1. The agent spawns the workload inside the container environment.

   > **Notes:**
   >
   > - The container environment created by the agent is equivalent to
   >   a container environment created by the
   >   [`runc`](https://github.com/opencontainers/runc) OCI runtime;
   >   Linux cgroups and namespaces are created inside the VM by the
   >   [guest kernel](guest-assets.md#guest-kernel) to isolate the
   >   workload from the VM environment the container is created in.
   >   See the [Environments](#environments) section for an
   >   explanation of why this is done.
   >
   > - See the [guest image](guest-assets.md#guest-image) section for
   >   details of exactly how the agent is started.

1. The container manager returns control of the container to the
   user running the `ctr` command.

> **Note:**
>
> At this point, the container is running and:
>
> - The [workload](#workload) process ([`sh(1)` in the example](example-command.md))
>   is running in the [container environment](#environments).
> - The user is now able to interact with the workload
>   (using the [`ctr` command in the example](example-command.md)).
> - The [agent](#agent), running inside the VM is monitoring the
>   [workload](#workload) process.
> - The [runtime](#runtime) is waiting for the agent's `WaitProcess` API
>   call to complete.

Further details of these steps are provided in the sections below.

### Container shutdown

There are two possible ways for the container environment to be
terminated:

- When the [workload](#workload) exits.

  This is the standard, or _graceful_ shutdown method.

- When the container manager forces the container to be deleted.

#### Workload exit

The [agent](#agent) will detect when the [workload](#workload) process
exits, capture its exit status (see `wait(2)`) and return that value
to the [runtime](#runtime) by specifying it as the response to the
`WaitProcess` agent API call made by the [runtime](#runtime).

The runtime then passes the value back to the container manager by the
`Wait` [shimv2 API](#shim-v2-architecture) call.

Once the workload has fully exited, the VM is no longer needed and the
runtime cleans up the environment (which includes terminating the
[hypervisor](#hypervisor) process).

> **Note:**
>
> When [agent tracing is enabled](../../tracing.md#agent-shutdown-behaviour),
> the shutdown behaviour is different.

#### Container manager requested shutdown

If the container manager requests the container be deleted, the
[runtime](#runtime) will signal the agent by sending it a
`DestroySandbox` [ttRPC API](../../../src/libs/protocols/protos/agent.proto) request.

## Guest assets

The guest assets comprise a guest image and a guest kernel that are
used by the [hypervisor](#hypervisor).

See the [guest assets](guest-assets.md) document for further
information.

## Hypervisor

The [hypervisor](../../hypervisors.md) specified in the
[configuration file](#configuration) creates a VM to host the
[agent](#agent) and the [workload](#workload) inside the
[container environment](#environments).

> **Note:**
>
> The hypervisor process runs inside an environment slightly different
> to the host environment:
>
> - It is run in a different cgroup environment to the host.
> - It is given a separate network namespace from the host.
> - If the [OCI configuration specifies a SELinux label](https://github.com/opencontainers/runtime-spec/blob/main/config.md#linux-process),
>   the hypervisor process will run with that label (*not* the workload running inside the hypervisor's VM).

## Agent

The Kata Containers agent ([`kata-agent`](../../../src/agent)), written
in the [Rust programming language](https://www.rust-lang.org), is a
long running process that runs inside the VM. It acts as the
supervisor for managing the containers and the [workload](#workload)
running within those containers. Only a single agent process is run
for each VM created.

### Agent communications protocol

The agent communicates with the other Kata components (primarily the
[runtime](#runtime)) using a
[`ttRPC`](https://github.com/containerd/ttrpc-rust) based
[protocol](../../../src/libs/protocols/protos).

> **Note:**
>
> If you wish to learn more about this protocol, a practical way to do
> so is to experiment with the
> [agent control tool](#agent-control-tool) on a test system.
> This tool is for test and development purposes only and can send
> arbitrary ttRPC agent API commands to the [agent](#agent).

## Runtime

The Kata Containers runtime (the [`containerd-shim-kata-v2`](../../../src/runtime/cmd/containerd-shim-kata-v2
) binary) is a [shimv2](#shim-v2-architecture) compatible runtime.

> **Note:**
>
> The Kata Containers runtime is sometimes referred to as the Kata
> _shim_. Both terms are correct since the `containerd-shim-kata-v2`
> is a container runtime, and that runtime implements the containerd
> shim v2 API.

The runtime makes heavy use of the [`virtcontainers`
package](../../../src/runtime/virtcontainers), which provides a generic,
runtime-specification agnostic, hardware-virtualized containers
library.

The runtime is responsible for starting the [hypervisor](#hypervisor)
and it's VM, and communicating with the [agent](#agent) using a
[ttRPC based protocol](#agent-communications-protocol) over a VSOCK
socket that provides a communications link between the VM and the
host.

This protocol allows the runtime to send container management commands
to the agent. The protocol is also used to carry the standard I/O
streams (`stdout`, `stderr`, `stdin`) between the containers and
container managers (such as CRI-O or containerd).

## Utility program

The `kata-runtime` binary is a utility program that provides
administrative commands to manipulate and query a Kata Containers
installation.

> **Note:**
>
> In Kata 1.x, this program also acted as the main
> [runtime](#runtime), but this is no longer required due to the
> improved shimv2 architecture.

### exec command

The `exec` command allows an administrator or developer to enter the
[VM root environment](#environments) which is not accessible by the container
[workload](#workload).

See [the developer guide](../../Developer-Guide.md#connect-to-debug-console) for further details.

### Configuration

See the [configuration file details](../../../src/runtime/README.md#configuration).

The configuration file is also used to enable runtime [debug output](../../Developer-Guide.md#enable-full-debug).

## Process overview

The table below shows an example of the main processes running in the
different [environments](#environments) when a Kata Container is
created with containerd using our [example command](example-command.md):

| Description | Host | VM root environment | VM container environment |
|-|-|-|-|
| Container manager | `containerd` | |
| Kata Containers | [runtime](#runtime), [`virtiofsd`](storage.md#virtio-fs), [hypervisor](#hypervisor) | [agent](#agent) |
| User [workload](#workload) | | | [`ubuntu sh`](example-command.md) |

## Networking

See the [networking document](networking.md).

## Storage

See the [storage document](storage.md).

## Kubernetes support

See the [Kubernetes document](kubernetes.md).

####  OCI annotations

In order for the Kata Containers [runtime](#runtime) (or any VM based OCI compatible
runtime) to be able to understand if it needs to create a full VM or if it
has to create a new container inside an existing pod's VM, CRI-O adds
specific annotations to the OCI configuration file (`config.json`) which is passed to
the OCI compatible runtime.

Before calling its runtime, CRI-O will always add a `io.kubernetes.cri-o.ContainerType`
annotation to the `config.json` configuration file it produces from the Kubelet CRI
request. The `io.kubernetes.cri-o.ContainerType` annotation can either be set to `sandbox`
or `container`. Kata Containers will then use this annotation to decide if it needs to
respectively create a virtual machine or a container inside a virtual machine associated
with a Kubernetes pod:

| Annotation value | Kata VM created? | Kata container created? |
|-|-|-|
| `sandbox` | yes | yes (inside new VM) |
| `container`| no | yes (in existing VM) |

#### Mixing VM based and namespace based runtimes

> **Note:** Since Kubernetes 1.12, the [`Kubernetes RuntimeClass`](https://kubernetes.io/docs/concepts/containers/runtime-class/)
> has been supported and the user can specify runtime without the non-standardized annotations.

With `RuntimeClass`, users can define Kata Containers as a
`RuntimeClass` and then explicitly specify that a pod must be created
as a Kata Containers pod. For details, please refer to [How to use
Kata Containers and containerd](../../../docs/how-to/containerd-kata.md).

## Tracing

The [tracing document](../../tracing.md) provides details on the tracing
architecture.

# Appendices

## DAX

Kata Containers utilizes the Linux kernel DAX
[(Direct Access filesystem)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/filesystems/dax.rst?h=v5.14)
feature to efficiently map the [guest image](guest-assets.md#guest-image) in the
[host environment](#environments) into the
[guest VM environment](#environments) to become the VM's
[rootfs](background.md#root-filesystem).

If the [configured](#configuration) [hypervisor](#hypervisor) is set
to either QEMU or Cloud Hypervisor, DAX is used with the feature shown
in the table below:

| Hypervisor | Feature used | rootfs device type |
|-|-|-|
| Cloud Hypervisor (CH) | `dax` `FsConfig` configuration option | PMEM (emulated Persistent Memory device) |
| QEMU | NVDIMM memory device with a memory file backend | NVDIMM (emulated Non-Volatile Dual In-line Memory Module device) |

The features in the table above are equivalent in that they provide a memory-mapped
virtual device which is used to DAX map the VM's
[rootfs](background.md#root-filesystem) into the [VM guest](#environments) memory
address space.

The VM is then booted, specifying the `root=` kernel parameter to make
the [guest kernel](guest-assets.md#guest-kernel) use the appropriate emulated device
as its rootfs.

### DAX advantages

Mapping files using [DAX](#dax) provides a number of benefits over
more traditional VM file and device mapping mechanisms:

- Mapping as a direct access device allows the guest to directly
  access the host memory pages (such as via Execute In Place (XIP)),
  bypassing the [guest kernel](guest-assets.md#guest-kernel)'s page cache. This
  zero copy provides both time and space optimizations.

- Mapping as a direct access device inside the VM allows pages from the
  host to be demand loaded using page faults, rather than having to make requests
  via a virtualized device (causing expensive VM exits/hypercalls), thus providing
  a speed optimization.

- Utilizing `mmap(2)`'s `MAP_SHARED` shared memory option on the host
  allows the host to efficiently share pages.

![DAX](../arch-images/DAX.png)

For further details of the use of NVDIMM with QEMU, see the [QEMU
project documentation](https://www.qemu.org).

## Agent control tool

The [agent control tool](../../../src/tools/agent-ctl) is a test and
development tool that can be used to learn more about a Kata
Containers system.

## Terminology

See the [project glossary](../../../Glossary.md).

repository: kata-containers/kata-containers

branch_name: refs/heads/main

gha_language: Rust

repo_name: kata-containers/kata-containers


text:
---
layout: post
title: Create a Windows 7 VM Vulnerable to MS17-010 EternalBlue
tags: pentesting
---
Recently in one of the CTF challenges conducted in my school's Security module, my team decided to build up a challenge involving MS17-010. We wanted to create a Windows Virtual Machine that is vulnerable to the MS17-010 EternalBlue exploit.

The steps involving the creation of the VM are provided below. Take note that this VM should be used for educational and research purposes only. Also, Windows 10 prevents the trivial selection and disabling of specific updates to be installed, so we will be using Windows 7 instead.

The basic process involves preventing the automatic update from patching the Windows VM, and setting up the environment for SMB to be active.

Steps to create the vulnerable VM

1) Download the IE8 on Win7 x86 (Virtualbox) and extract it. You can download the zipped OVA file here: https://developer.microsoft.com/en-us/microsoft-edge/tools/vms/

2) Launch Virtualbox, and import the downloaded VM into Virtualbox using “File > import appliance”

Select the unzipped ova file, hit Next, and import.

3) Before you start the VM, we want to prevent the VM from automatically update itself. Go to the VM Settings and disable the NAT connection, by unattaching the network adapter.

4) Boot up the VM. When you reach the Desktop, proceed to change the Windows Update setting to “check for updates but let me choose when to download and install them”

Do a simple search for windows update settings

5) Re-enable the NAT adapter

6) Install every important update except for those from Mar 2017 onwards (https://stackoverflow.com/questions/47531732/how-to-make-a-win7-pc-vulnerable-to-ms17-010-eternalblue)

7) Disable the Nat adapter, and enable the Host-only adapter (with DHCP client on Virtualbox)

8) Enable Windows Firewall inbound traffic for File and Printer Sharing (SMB-In) (Private and Domain) (and also Echo Request-ICMPv4-In Private and Domain for ping)

9) Change the Default username and password for IEUSER to be something not brute-forcible

10) Set Task Scheduler to launch explorer.exe with trigger as system startup, and without logon

11) Enable password on boot (https://www.sevenforums.com/tutorials/377-log-automatically-startup.html)

12) Take a snapshot, export the appliance

Test the MS17-010 on it! Try https://github.com/ElevenPaths/Eternalblue-Doublepulsar-Metasploit or something similar.

--SeraphimX


text:
---
layout: default
---

# 1997-02-05 - Re: Moderation [Tim,Sandy]

## Header Data

From<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)

To<EMAIL_ADDRESS>Message Hash: 18721c0315ff04c6d071fc593a99d6c6a151695c96ef47d55490c4c57d164409

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-02-05 04:20:57 UTC

Raw Date: Tue, 4 Feb 1997 20:20:57 -0800 (PST)

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)
Date: Tue, 4 Feb 1997 20:20:57 -0800 (PST)
To<EMAIL_ADDRESS>Subject: Re: Moderation [Tim,Sandy]
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Dale Thorn<EMAIL_ADDRESS>writes:
> > What Vulis and the rest (whom I killfiled long ago) have done is polluted a
> > common resource, making it unusable for the rest. It's the tragedy of the
> > commons. When all can speak without limit in a public forum, the drunken
> > boor can shout everyone else down.
>
> The drunk can be excluded, but when someone wants to use the drunk as
> an example to escalate the exclusion to other persons who are not in
> fact drunk, watch out!

If I get really really drunk, which happens very seldom, then I'm
too drunk to post. I don't mind an occasional beer, though.

Oksas, have you ever tried beer? :-)

---

Dr.Dimitri Vulis KOTM
Brighton Beach Boardwalk BBS, Forest Hills, N.Y.: +1-718-261-2013, 14.4Kbps

{% endraw %}
```

## Thread

+ Return to [February 1997](/archive/1997/02)

+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"
+ Return to "[Dale Thorn <dthorn@gte.net>](/authors/dale_thorn_dthorn_at_gte_net_)"
+ Return to "[Declan McCullagh <declan@pathfinder.com>](/authors/declan_mccullagh_declan_at_pathfinder_com_)"
+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"

+ 1997-02-04 (Mon, 3 Feb 1997 17:58:32 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/72745954ce5f19722a258bb9a03b9ca49e845436761b2333a7e943d32260c6b5) - _Adam Back<EMAIL_ADDRESS>  + 1997-02-04 (Tue, 4 Feb 1997 15:40:51 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/0cb9cf760c91779f025c0bd2dd8583fc0863513cc2042da9543246a9126eca4d) - _Declan McCullagh<EMAIL_ADDRESS>    + 1997-02-05 (Tue, 4 Feb 1997 18:41:02 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/491d394c233eda8fb3b04d99562fd0caccf3b1de209fe2c9056d59442687540a) - _Dale Thorn<EMAIL_ADDRESS>      + 1997-02-05 (Tue, 4 Feb 1997 20:20:57 -0800 (PST)) - Re: Moderation [Tim,Sandy] -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
        + 1997-02-05 (Tue, 4 Feb 1997 20:59:01 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/8c1c38e9d11cb5e7c0a440f0015033f83e4e1575d42b70b7a6bb31c5c93a006b) - _Dale Thorn<EMAIL_ADDRESS>          + 1997-02-05 (Wed, 5 Feb 1997 08:28:25 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/ecf55208ce2e80d98c9a2248e245bb148dddc001b6f7d7af687584cb31941684) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
            + 1997-02-06 (Wed, 5 Feb 1997 23:31:55 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/a44a429506bf157acb7311dc4184aee5f96d5e889482f38193755ba704414d33) - _Dale Thorn<EMAIL_ADDRESS>              + 1997-02-06 (Thu, 6 Feb 1997 06:05:09 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/87a4cd8329c92bc2ca6c3ee5c5d3c11f8d59332696bb78b6d62e8c0b954d9e88) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
    + 1997-02-05 (Wed, 5 Feb 1997 13:45:38 -0800 (PST)) - [Re: Moderation [Tim,Sandy]](/archive/1997/02/9d09e822b715eeb7dbcff9d8064d330a6c62e4281381296afb9645354e7ff0c8) - _Adam Back<EMAIL_ADDRESS>


text:
# Devkit

Yet another **dev**eloper tool**kit**.

## Installation

```
$ composer install
```

## Usage

```
$ app/bin/devkit
DevkitApp 0.1.0

Usage:
  command [options] [arguments]

Options:
  -h, --help            Display this help message
  -q, --quiet           Do not output any message
  -V, --version         Display this application version
      --ansi            Force ANSI output
      --no-ansi         Disable ANSI output
  -n, --no-interaction  Do not ask any interactive question
  -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

Available commands:
  help           Displays help for a command
  list           Lists commands
 docker
  docker:logs    Follow Docker logs
  docker:shell   Get a Bash shell in a running Docker container
  docker:start   Starts a service
  docker:stop    Stops a service
 env
  env:down       Shutdowns the development environment (stops and removes containers)
  env:reload     Reloads the environment (stop, build and up)
  env:setup      Set up the development environment
  env:up         Boots the development environment (starts Docker containers and installs dependencies)
 phpqa
  phpqa:list     List all available PHP QA tools
  phpqa:phan     A static analyzer for PHP
  phpqa:phpstan  PHPStan - PHP Static Analysis Tool
 vagrant
  vagrant:halt   Stops the Vagrant machine
  vagrant:up     Starts and provisions the Vagrant environment

```

Add commands as needed in `app/src/Application::construct()`.

## Copyright

Copyright (c) 2018 [Vítor Brandão](https://noiselabs.io). Licensed under the [MIT License](LICENSE).

repository: noiselabs/devkit

repo_name: noiselabs/devkit


text:
---
title: Home
section: home
---

BigFix Developer

This is the official repository of information for developing BigFix content, and it is tailored to satisfy the needs of both beginner and expert content developers.

If you are new to BigFix customization, start your navigation by clicking Getting Started.

Navigate the entries in the main toolbar to access all the available documentation and media about:

The Relevance Language for retrieving and manipulating information defined on clients or collected and stored in the BigFix database.

The Action Script Language for running configuration activities on clients and remediating lack of compliance.

The REST API for running operations available on the BigFix console from outside the console.

Other APIs for creating custom dashboards, implementing your reporting solution, and integrating with external applications on client systems.

The Tools, available with BigFix, useful for developing your custom BigFix solution.

Do not forget to read carefully the known best practices. They can help you to create your custom solution in a simpler and safer way by following a consolidated path.

Complete your 360-degree view of the BigFix development world!

Forum

Connect to the BigFix developers community and go through a topic-based list of Q&As.

bigfix.me

Share your custom content with other users and download available expressions and structures.

GitHub

Access the available development tools.

gha_language: JavaScript


text:
# akan-name
#### this one lets you know your traditional name from Ghanian tradition, 16-01-2020
#### By **Ian Joel Juma**
## Description
you neet to connect to the internet to acces the site.
## Setup/Installation Requirements
* connect to the internet.
link:https: //juma-359.github.io/akan-name1/

## Known Bugs
No burgs.
## Technologies Used
used HTML.
CSS.
javaScript.
## Support and contact details
Email<EMAIL_ADDRESS>Github: juma-359
### License

MIT License

Copyright (c) [2020] [Ian Joel Juma]

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.


text:
# 0.11.0

* Changed `ParserNode` method suffixes from `Value` to `Property`.
* Added missing parser methods to `ParserNode`.
* `GetEnum` in `ParserNode` no longer wraps enum in custom element.

# 0.10.1

Fixed analyzer issues.

# 0.10.0

* Increased minimum dart SDK to 2.6.0.
* Updated rxdart to `^0.23.1`.
* Replaced `Parser` for `ExpressionParser`.

# 0.9.0

* Renamed `ElementValue<T>` to `Property<T>`.
* `FormElement` and `Validation` now use property setters instead of `fill` method.
* Added base `FormElementParser` so parsers can be easily inherited from each other.

# 0.8.0

Fixed inconsistency in parsers.

# 0.7.0

Changed model hierarchy and parser naming.

# 0.6.1

Published FormElement propertyChanged Stream so it can have multiple subscribers.

# 0.6.0

Added possibility to parse single child component.

# 0.5.0

Removed screaming caps convention.

# 0.4.0

- Added abstraction over XML parser.
- Added JSON parser.

# 0.3.0

Specific models and parsers were moved to the flutter_dynamic_forms_components package.

# 0.2.0

FormManager API Changes.

# 0.1.1

Updated the project description.

# 0.1.0

Initial Version of the library.


text:
# rest-api-server

REST API Server based on nodejs and expressjs

# /users api

this api returns 5 users array; result is created using https://randomuser.me/api/?results=5 API


text:
## Installation

Then make sure you've got the following packages
installed:

    $ sudo apt-get install ffmpeg git python3-picamera python3-ws4py python3-pantilthat

Next, clone this repository:

    $ git clone https://github.com/waveform80/pistreaming.git

## Usage

Run the Python server script which should print out a load of stuff
to the console as it starts up:

    $ cd pistreaming
    $ python3 server.py
    Initializing HAT
    Initializing websockets server on port 8084
    Initializing HTTP server on port 8082
    Initializing camera
    Initializing broadcast thread
    Spawning background conversion process
    Starting websockets thread
    Starting HTTP server thread
    Starting broadcast thread

Now fire up your favourite web-browser and visit the address
`http://pi-address:8082/` - it should fairly quickly start displaying the feed
from the camera. You should be able to visit the URL from multiple browsers
simultaneously (although obviously you'll saturate the Pi's bandwidth sooner or
later).

If you find the video stutters or the latency is particularly bad (more than a
second), please check you have a decent network connection between the Pi and
the clients. I've found ethernet works perfectly (even with things like
powerline boxes in between) but a poor wifi connection doesn't provide enough
bandwidth, and dropped packets are not handled terribly well.

To shut down the server press Ctrl+C - you may find it'll take a while
to shut down unless you close the client web browsers (Chrome in particular
tends to keep connections open which will prevent the server from shutting down
until the socket closes).

### HTTP server

This is implemented in the `StreamingHttpServer` and `StreamingHttpHandler`
classes, and is quite simple:

* In response to an HTTP GET request for "/" it will redirect the client to
  "/index.html".
* In response to an HTTP GET request for "/index.html" it will serve up the
  contents of index.html, replacing @ADDRESS@ with the Pi's IP address and
  the websocket port.
* In response to an HTTP GET request for "/jsmpg.js" it will serve up the
  contents of jsmpg.js verbatim.
* In response to an HTTP GET request for "/do_orient?pan=0&tilt=0" it will
  orient the pan-tilt HAT to the specified values; the sliders present in
  "index.html" are hooked to some JavaScript which will make such requests
* In response to an HTTP GET request for anything else, it will return 404.
* In response to an HTTP HEAD request for any of the above, it will simply
  do the same as for GET but will omit the content.
* In response to any other HTTP method it will return an error.

### Websockets server

This is implemented in the `StreamingWebSocket` class and is ridiculously
simple. In response to a new connection it will immediately send a header
consisting of the four characters "jsmp" and the width and height of the video
stream encoded as 16-bit unsigned integers in big-endian format. This header is
expected by the jsmpg implementation. Other than that, the websocket server
doesn't do much. The actual broadcasting of video data is handled by the
broadcast thread object below.

### Broadcast output

The `BroadcastOutput` class is an implementation of a [picamera custom
output](http://picamera.readthedocs.org/en/latest/recipes2.html#custom-outputs).
On initialization it starts a background FFmpeg process (`avconv`) which is
configured to expect raw video data in YUV420 format, and will encode it as
MPEG1. As unencoded video data is fed to the output via the `write` method, the
class feeds the data to the background FFmpeg process.

### Broadcast thread

The `BroadcastThread` class implements a background thread which continually
reads encoded MPEG1 data from the background FFmpeg process started by the
`BroadcastOutput` class and broadcasts it to all connected websockets. In the
event that no websockets are currently connected the `broadcast` method simply
discards the data. In the event that no more data is available from the FFmpeg
process, the thread checks that the FFmpeg process hasn't finished (with
`poll`) and terminates if it has.

### Main

Finally, the `main` method may look long and complicated but it's mostly
boiler-plate code which constructs all the necessary objects, wraps several of
them in background threads (the HTTP server gets one, the main websockets
server gets another, etc.), configures the camera and starts it recording to
the `BroadcastOutput` object. After that it simply sits around calling
`wait_recording` until someone presses Ctrl+C, at which point it shuts
everything down in an orderly fashion and exits.


text:
# Hubot Mute

Allows channels to mute Hubot if quiet is required for whatever reasons. Hubot will not respond to any commands in a muted channel (other than `mute` commands).

[![Build Status](https://travis-ci.org/alexhouse/hubot-mute.png)](https://travis-ci.org/alexhouse/hubot-mute) [![NPM version](https://badge.fury.io/js/hubot-mute.png)](http://badge.fury.io/js/hubot-mute)

## Usage

* `hubot mute list` - List all individually muted channels
* `hubot global mute` - Globally mute all channels
* `hubot global unmute` - Globally unmute all channels (but keep individually muted)
* `hubot mute {channel}` - Mute specific channel
* `hubot unmute {channel}` - Unmute specific channel
* `hubot unmute all (the things)` - Unmute all individually muted channels

## Configuration

This script requires the env variable `HUBOT_MUTE_ROOM_PREFIX` to be set. This is used in determining how to respond to the channel.
This should **ALWAYS** be set - even if blank (i.e. hipchat)

For example, if you're on IRC or Slack you'll probably want this setting as `#`. Basecamp should be able to leave it as blank.

## Installation

Add the package `"hubot-mute": "*"` as a dependency in your Hubot package.json file. Then add `"hubot-mute"` to the list in the `external-scripts.json` file.

repository: alexhouse/hubot-mute

gha_language: CoffeeScript

repo_name: alexhouse/hubot-mute


text:
# Cabo Verde Startup Cluster

### Welcome

Cabo Verde Startup Cluster is a west-african organization that aims to create an supportive and effective environment to spur inovation and accelerate an enterpreneur spirit in Cape Verde to tacke local and global challenges with a special focus on climate change, clean tech and sustainable businesses that doesnt hurt the planet.

[Visit our website](http://cvstartupcluster.org)

repository: cvstartup-cluster/cvstartupcluster

gha_language: HTML

repo_name: cvstartup-cluster/cvstartupcluster


text:
## Zig const pointers

Constant pointers which alias a mutable variable
can be defined as follows:
```
var v: u64 = 123;	// A mutable variable
const cp: *u64 = &v;	// A constnat pointer to a mutable variable
```
Such pairs have the following properties:
- v: mutable
- cp: must be initialized when defined and never mutated
- cp == &v: always
- cp.\* == v: always

Previous failing cases are now fixed and all tests are now passing.

license: Unlicense

repository: winksaville/zig-const-ptr

repo_name: winksaville/zig-const-ptr


text:
Send SMS code using `sendSmsCode` method.

```java
String phone = "phone number";
authenticationClient.sendSmsCode(phone).execute();
```

repository: Authing/docs

repo_name: Authing/docs


text:
Load a specific configuration on a node.  The configuration to load is defined by a 16-byte configuration id. It is recommended that configuration id zero is the default configuration.

The optional control byte can be used to request a reset if the device after configuration is loaded.

CLASS1.CONFIGURATION, VSCP_TYPE_CONFIGURATION_LOAD_ACK should be sent by the node after loading the new configuration to acknowledge a successful load of configuration data.

CLASS1.CONFIGURATION, VSCP_TYPE_CONFIGURATION_LOAD_NACK should be sent by the node after loading the new configuration to negative acknowledge a failed load of configuration data.

 | Byte | Description |
 | :----: | ----------- |
 | 0    | Index.                |
 | 1    | Zone.                 |
 | 2    | Subzone.              |
 | 3    | Configuration id MSB. |
 | 4    | Configuration id LSB. |
 | 5    | Control byte (optional). |

##### Control byte

| Bit | Description |
| :----: | ----------- |
| 0-6    | Reserved.   |
| 7    | Reboot device after configuration is loaded.   |

repository: grodansparadis/vscp-classes

gha_language: C

repo_name: grodansparadis/vscp-classes


text:
Yii2 RelatedPolymorphic Behavior
---
This behavior helps to establish polymorphic behaviors easily.
Forget about endless dictionary tables in your storage.

---
[![Build Status](https://travis-ci.org/Oxyaction/yii2-polymorphic-relation-behavior.svg?branch=master)](https://travis-ci.org/Oxyaction/yii2-polymorphic-relation-behavior)
[![Latest Stable Version](https://poser.pugx.org/oxyaction/yii2-polymorphic-relation-behavior/v/stable)](https://packagist.org/packages/oxyaction/yii2-polymorphic-relation-behavior)
[![Latest Unstable Version](https://poser.pugx.org/oxyaction/yii2-polymorphic-relation-behavior/v/unstable)](https://packagist.org/packages/oxyaction/yii2-polymorphic-relation-behavior)
[![License](https://poser.pugx.org/oxyaction/yii2-polymorphic-relation-behavior/license)](https://packagist.org/packages/oxyaction/yii2-polymorphic-relation-behavior)

### Problem
Often you have some entity related to multiple entities in your system.
For example `Comment` entity can belong to both `Article`, `Photo`, `Post` etc.
You can create a comment table for each of this entities (`ArticleComment`,
 `PhotoComment`, `PostComment`), but this solution is
not so good and not DRY at all.

The best solution will be creating the single `Comment` entity table
and establishing polymorphic relations. The `comment` table is required to have
`type` column that will indicate to which entity type comment belongs
and `external_id` column that will be used as foreign key column.

```php
class Article extends ActiveRecord
{
    const ARTICLE = 1;

    public function behaviors()
    {
        return [
            'polymorphic' => [
                'class' => RelatedPolymorphicBehavior::className(),
                'polyRelations' => [
                    'comments' => Comment::className()
                ],
                'polymorphicType' => self::TYPE_ARTICLE
            ]
        ];
    }
}

class Photo extends ActiveRecord
{
    const PHOTO = 2;

    public function behaviors()
    {
        return [
            'polymorphic' => [
                'class' => RelatedPolymorphicBehavior::className(),
                'polyRelations' => [
                    'comments' => Comment::className()
                ],
                'polymorphicType' => self::TYPE_PHOTO
            ]
        ];
    }
}
```
Then you can query relations as always
```
$article->comments;
$photo->comments;
```
### Options

#### Has many
Short:
```php
...
public function behaviors()
{
    return [
        'polymorphic' => [
            'class' => RelatedPolymorphicBehavior::className(),
            'polyRelations' => [
                'comments' => Comment::className()
            ],
            'polymorphicType' => 'article'
        ]
    ];
}
...
```
Same as
```php
public function behaviors()
{
    return [
        'polymorphic' => [
            'class' => RelatedPolymorphicBehavior::className(),
            'polyRelations' => [
                'comments' => [
                    'type' => RelatedPolymorphicBehavior::HAS_MANY,
                    'class' => Comment::className(),
                    'pkColumnName' => 'id',
                    'foreignKeyColumnName' => 'external_id',
                    'typeColumnName' => 'type',
                    'deleteRelated' => false,
                ]
            ],
            'polymorphicType' => 'article'
        ]
    ]
}

```
#### Many to many
Often we need to establish polymorphic relation with many to many.
in this case `type` and `external_id` columns will be in junction table.
```php
public function behaviors()
{
    return [
        'polymorphic' => [
            'class' => RelatedPolymorphicBehavior::className(),
            'polyRelations' => [
                'tags' => [
                    'type' => RelatedPolymorphicBehavior::MANY_MANY,
                    'class' => Tag::className(),
                    'viaTable' => 'taggable_tag',
                ]
            ],
            'polymorphicType' => 'article'
        ]
    ]
}
```
All available options:
```php
public function behaviors()
{
    return [
        'polymorphic' => [
            'class' => RelatedPolymorphicBehavior::className(),
            'polyRelations' => [
                'tags' => [
                    'type' => RelatedPolymorphicBehavior::MANY_MANY,
                    'class' => Tag::className(),
                    'viaTable' => 'taggable_tag',
                    'pkColumnName' => 'id',
                    'foreignKeyColumnName' => 'external_id',
                    'otherKeyColumnName' => 'tag_id',
                    'typeColumnName' => 'type',
                    'relatedPkColumnName' => 'id',

                ]
            ],
            'polymorphicType' => 'photo'
        ]
    ]
}
```
Some options can be set on per behavior or per relation level.
For example `polymorphicType` from example above is set on behavior level,
while `typeColumnName` on relation level. In case if you set option on
behavior level you won't need to duplicate it for multiple relations
while relation option will take precedence.

| Option | Description | Required | Default | Level | Type |
| --- | --- | --- | --- | --- | --- |
| `type` |  `RelatedPolymorphicBehavior::MANY_MANY` or `RelatedPolymorphicBehavior::HAS_MANY` | Yes | | relation |
| `class` | related model class name | Yes | | relation |
| `polymorphicType` | type of the polymorphic entity | Yes | | behavior, relation |
| `viaTable` | junction table name | Yes | | relation | `MANY MANY`
| `pkColumnName` | source model pk column name | | fetched from schema | behavior, relation |
| `foreignKeyColumnName` | foreign key | | `external_id` | behavior, relation |
| `typeColumnName` | column name for type of polymorphic model | | `type` | behavior, relation |
| `deleteRelated` | delete related values, after removing primary model | | false |relation | `HAS MANY` |
| `otherKeyColumnName` | related model's foreign key column name in junction table | | fetched from schema | relation | `MANY MANY`
| `relatedPkColumnName` | related model's pk column name | | fetched from schema | relation | `MANY MANY`

#### Final example

```php
class Article extends ActiveRecord {
    public function behaviors()
    {
        return [
            'polymorphic' => [
                'class' => RelatedPolymorphicBehavior::className(),
                'polyRelations' => [
                    'tags' => [
                        'type' => RelatedPolymorphicBehavior::MANY_MANY,
                        'class' => Tag::className(),
                        'viaTable' => 'taggable_tag',
                    ],
                    'images' => [
                        'type' => RelatedPolymorphicBehavior::HAS_MANY,
                        'class' => Image::className(),
                    ],
                    'comments' => [
                        'type' => RelatedPolymorphicBehavior::HAS_MANY,
                        'class' => Comment::className(),
                    ],
                ],
                'polymorphicType' => 'article',
                'pkColumnName' => 'ID',
                'foreignKeyColumnName' => 'some_external_id',
                'typeColumnName' => 'entity_type',
            ]
        ]
    }
}
```

This will assume that `taggable_tag`, `image` and `comment` tables
have `some_external_id` and `entity_type` columns, for `Article`
entity it will be filled with `article` value and `Article` primary key
column name is `ID`.

#### Warning

Since `external_id` of the polymorphic target entity links to multiple
entities, you can not use foreign key constraints and need to check
data consistency on application level.


text:
## Feature Example - Creating REST API endpoints

This project demonstrates how to create REST endpoints by extending Keystone's express app and using the Query API to execute queries against the schema.

## Instructions

To run this project, clone the Keystone repository locally, run `yarn` at the root of the repository then navigate to this directory and run:

```shell
yarn dev
```

This will start the Admin UI at [localhost:3000](http://localhost:3000).

You can use the Admin UI to create items in your database.

To run the seed data script, pass the `--seed-data` flag when starting the app.

repository: dorucioclea/keystone

repo_name: dorucioclea/keystone


text:
# Installation

Depending on your development environment, you can use different ways to install the solver:

## Install with Python

The functionality of `vrp-cli` is published to [pypi.org](https://pypi.org/project/vrp-cli/), so you can just install it
using pip and use from python:

```shell
pip install vrp-cli
python examples/python-interop/example.py # run test example
```

Alternatively, you can use [maturin](https://github.com/PyO3/maturin) tool to build solver locally.

You can find extra information in [python example section](https://reinterpretcat.github.io/vrp/examples/interop/python.html)
of the docs. The [full source code](./examples/python-interop/example.py) of python example is available in the repo which
contains useful model wrappers with help of `pydantic` lib.

## Install from Docker

Another fast way to try vrp solver on your environment is to use `docker` image (not performance optimized):

* **run public image** from `Github Container Registry`:

```bash
    docker run -it -v $(pwd):/repo --name vrp-cli --rm ghcr.io/reinterpretcat/vrp/vrp-cli:1.22.1
```

* **build image locally** using `Dockerfile` provided:

```bash
docker build -t vrp_solver .
docker run -it -v $(pwd):/repo --rm vrp_solver
```

Please note that the docker image is built using `musl`, not `glibc` standard library. So there might be some performance
implications.

## Install from Cargo

You can install vrp solver `cli` tool directly with `cargo install`:

    cargo install vrp-cli

Ensure that your `$PATH` is properly configured to source the crates binaries, and then run solver using the `vrp-cli` command.

## Install from source

Once pulled the source code, you can build it using `cargo`:

    cargo build --release

Built binaries can be found in the `./target/release` directory.

Alternatively, you can try to run the following script from the project root:

    ./solve_problem.sh examples/data/pragmatic/objectives/berlin.default.problem.json

It will build the executable and automatically launch the solver with the specified VRP definition. Results are
stored in the folder where a problem definition is located.

repository: reinterpretcat/vrp

repo_name: reinterpretcat/vrp


text:
# SpinLMM

By: Dave Hein

Language: Spin, Assembly

Created: Apr 16, 2013

Modified: May 20, 2013

SpinLMM is an enhancement to the Spin interpreter by integrating an LMM PASM interpreter. This enables PASM routines to be run in the same cog that is executing Spin code. A demo program is included that implements a serial port and basic floating pointer routines in LMM PASM. These rouines run in a single cog along with the main program, which is written in Spin.

Note: There is an error in the SpinLMM.pdf document that uses pcurr instead of dcurr when referring to the Spin stack pointer. This is corrected in the document SpinLMM10a.html.

repository: parallaxinc/propeller

gha_language: Propeller Spin

repo_name: parallaxinc/propeller


text:
# Examples in Project

The following examples have been implemented in PHP to demostrate the concepts described in [Clounce.com](https://www.clounce.com/) articles

| Concept | Library Method | Example |
|:---------|:----------------|:---------|
| [Arithmetic Mean](http://www.clounce.com/mathematics/arithmetic_mean) | ClouncMath\MeanAverages::arithmeticMean | php arithmetic_mean.php |
| [Mode](http://www.clounce.com/mathematics/mode) | ClouncMath\MeanAverages::mode | php mode.php |
| [Median](http://www.clounce.com/mathematics/median) | ClouncMath\MeanAverages::median | php median.php |
| [Geometric Mean](http://www.clounce.com/mathematics/geometric_mean) | ClouncMath\MeanAverages::geometricMean | php geometric_mean.php |

| Sequence Concept | Library Method | Example |
|:---------|:----------------|:---------|
| [Jacobsthal](https://www.clounce.com/mathematics/jacobsthal-number-sequence) |  ClouncMath\Sequences::jacobsthalNumbers
 ClounceMath\Sequences::jacobsthalNumberGenerator | php jacobsthal_numbers.php |
| [Kappa](https://www.clounce.com/mathematics/kappa-sequence) |  ClouncMath\Sequences::kappaNumber
 ClounceMath\Sequences::kappaNumberGenerator | php kappa_numbers.php |

| Algorithm | Library Method | Example |
|:---------|:----------------|:---------|
| [Arithmetic Mean Sequence](http://www.clounce.com/mathematics/algorithm/arithmetic-mean-sequence) |  ClouncMath\SequenceSolver::arithmeticMeanSequence | php arithmetic_mean_sequence.php |

gha_language: C#


text:
# .NET Driver Version 2.0.0 Release Notes

This is a major release which supports all MongoDB server versions since 2.4.

An online version of these release notes is available at:

https://github.com/mongodb/mongo-csharp-driver/blob/master/Release%20Notes/Release%20Notes%20v2.0.0.md

The full list of JIRA issues resolved in this release is available at:

https://jira.mongodb.org/issues/?jql=project%20%3D%20CSHARP%20AND%20fixVersion%20%3D%202.0%20ORDER%20BY%20key%20ASC

Documentation on the .NET driver can be found at:

https://mongodb.github.io/mongo-csharp-driver/

## New Features

Notable new features are listed below. For a full list, see the full list of JIRA issues linked above.

### Async

As has been requested for a while now, the driver now offers a full async stack. Since it uses Tasks, it is fully usable
with async and await.

While we offer a mostly backwards-compatible sync API, it is calling into the async stack underneath. Until you are ready
to move to async, you should measure against the 1.x versions to ensure performance regressions don't enter your codebase.

All new applications should utilize the New API.

### New API

Because of our async nature, we have rebuilt our entire API. The new API is accessible via MongoClient.GetDatabase.

- Interfaces are used (`IMongoClient`, `IMongoDatabase`, `IMongoCollection<TDocument>`) to support easier testing.

- A fluent Find API is available with full support for expression trees including projections.

	``` csharp
	var names = await db.GetCollection<Person>("people")
		.Find(x => x.FirstName == "Jack")
		.SortBy(x => x.Age)
		.Project(x => x.FirstName + " " + x.LastName)
		.ToListAsync();
	```

- A fluent Aggregation API is available with mostly-full support for expression trees.

	``` csharp
	var totalAgeByLastName = await db.GetCollection<Person>("people")
		.Aggregate()
		.Match(x => x.FirstName == "Jack")
		.GroupBy(x => x.LastName, g => new { _id = g.Key, TotalAge = g.Sum(x => x.Age)})
		.ToListAsync();
	```

- Support for dynamic.

	``` csharp
	var person = new ExpandoObject();
	person.FirstName = "Jane";
	person.Age = 12;
	person.PetNames = new List<dynamic> { "Sherlock", "Watson" }
	await db.GetCollection<dynamic>("people").InsertOneAsync(person);
	```

## Upgrading

As 2.0 is a major revision, there are some breaking changes when coming from the 1.x assemblies. We've tried our best to mitigate those breaking changes, but some were inevitable. These changes may not affect everyone, but take a moment to review the list of known changes below:

### System Requirements

- .NET 3.5 and .NET 4.0 are no longer supported. If you still must use these platforms, the 1.x series of the driver will continue to be developed.
- [CSHARP-952](https://jira.mongodb.org/browse/CSHARP-952): We've removed support for partially trusted callers.

### Packaging

- The nuget package [mongocsharpdriver](http://nuget.org/packages/mongocsharpdriver) now includes the legacy driver. It depends on 3 new nuget packages, [MongoDB.Bson](http://nuget.org/packages/MongoDB.Bson), [MongoDB.Driver.Core](http://nuget.org/packages/MongoDB.Driver.Core), and [MongoDB.Driver](http://nuget.org/packages/MongoDB.Driver). [MongoDB.Driver](http://nuget.org/packages/MongoDB.Driver) is the replacement for [mongocsharpdriver](http://nuget.org/packages/mongocsharpdriver).
- [CSHARP-616](https://jira.mongodb.org/browse/CSHARP-616): We are no longer strong naming  our assemblies. Our previous strong naming was signed with a key in our public repository. This did nothing other than satisfy certain tools. If you need MongoDB assemblies to be strongly named, it is relatively straight-forward to build the assemblies yourself.

### BSON

- [CSHARP-933](https://jira.mongodb.org/browse/CSHARP-933): Improved the BSON Serializer infrastructure. Anyone who has written a custom serializer will be affected by this. The changes are minor, but were necessary to support dynamic serializers as well as offering great speed improvements and improved memory management.
- Certain methods, such as `BsonMemberMap.SetRepresentation` have been removed. The proper way to set a representation, for instance, would be to use `SetSerializer` and configure the serializer with the appropriate representation.
- [CSHARP-939](https://jira.mongodb.org/browse/CSHARP-939): Dynamic DictionaryRepresentation has been removed. Its intent was to store, in some manner, anything in a .NET dictionary. In practice, this leads to the same values getting stored in different ways depending on factors such as a "." inside the key name. We made the decision to eliminate this variability. This means that documents that used to serialize correctly may start throwing a BsonSerializationException with a message indicating the key must be a valid string. [CSHARP-1165](https://jira.mongodb.org/browse/CSHARP-1165) has a solution to this problem. It should be noted that we will continue to read these disparate representations without error.

### Driver
- [CSHARP-979](https://jira.mongodb.org/browse/CSHARP-979): `MongoConnectionStringBuilder` has been removed. Use the documented mongodb connection string format and/or `MongoUrlBuilder`.
- `MongoServer` is a deprecated class. Anyone using `MongoClient.GetServer()` will encounter a deprecation warning and, depending on how your build is setup, may receive an error. It is still safe to use this API until your code is ported to the new API. *Note that this API requires the use of the [mongocsharpdriver](http://nuget.org/packages/mongocsharpdriver) to include the legacy API.
- [CSHARP-1043](https://jira.mongodb.org/browse/CSHARP-1043) and [CSHARP-1044](https://jira.mongodb.org/browse/CSHARP-1044): `ReadPreference` and `WriteConcern` were rewritten. These classes are now immutable. Any current application code that sets values on these classes will no longer function. Instead, you should use the With method to alter a `ReadPreference` or `WriteConcern`.

	``` csharp
	var writeConcern = myCurrentWriteConcern.With(journal: true);
	```

repository: mongodb/mongo-csharp-driver

path: /Release Notes/Release Notes v2.0.0.md

filename: Release Notes v2.0.0.md

repo_name: mongodb/mongo-csharp-driver


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]
### Added
- Refactor repeated code in action branching

## [0.1.4] - 2019-05-13
### Added
- Changelog
- Mulit-action custom rules
- Add role inheritance API

## [0.1.3] - 2019-04-02
### Added
- npm deploy

## [0.1.1] - 2019-04-02
### Added
- ACL class and base functionality
- accesscontrol dependency
- ownerFunctions
- custom rules

[Unreleased]: https://github.com/AckeeCZ/axesor/compare/v0.1.4...HEAD
[0.1.4]: https://github.com/AckeeCZ/axesor/compare/v0.1.3...v0.1.4
[0.1.3]: https://github.com/AckeeCZ/axesor/compare/v0.1.1...v0.1.3
[0.1.1]: https://github.com/AckeeCZ/axesor/compare/c996543...v0.1.1

repository: AckeeCZ/axesor

repo_name: AckeeCZ/axesor


text:
# how to use timeline tool to do profile

1. Add `with profiler.profiler(...)` to the main training loop. After run, the code will generate a profile record file `/tmp/profile`. **Warning**: Please do not run too many batches when use profiler to record timeline information, for the profile record will grow with the batch number.

	```python
	with profiler.profiler('All', 'total', '/tmp/profile') as prof:
	    for pass_id in range(pass_num):
	        for batch_id, data in enumerate(train_reader()):
	            exe.run(fluid.default_main_program(),
	                    feed=feeder.feed(data),
	                    fetch_list=[],
	                    use_program_cache=True)
	            ...
	```

1. Run `python paddle/tools/timeline.py` to process `/tmp/profile`, it will generate another
file `/tmp/timeline` by default. You can change the path by cmd parameter, please take a look at
[timeline.py](https://github.com/PaddlePaddle/Paddle/blob/develop/tools/timeline.py) for details.

1. Open chrome and visit <chrome://tracing/>, use `load` button to load the generated `timeline` file.

	![chrome tracing](./tracing.jpeg)

1. The resulting timeline should be like:

	![chrome timeline](./timeline.jpeg)


text:
---
id: contributing-workflow
title: Contributing Workflow
sidebar_label: Workflow
---

Once you've identified a good project to work on as well as an issue, then it's time to get started with your contibution.

The general steps you want to follow are:

1. **Claim the issue**: Let the project owner and community know that you want to tackle the issue. You can comment on an existing issue or create a new one if it doesn't exist.
1. **Discuss your solution**: Get buy in from the community by outlining how you intend to solve the issue. This may prevent unnecessary changes down the line.
1. **Work on your changes**: Fork the repository, clone your fork locally, and implement your changes.
1. **Create a pull request**: Push your changes to your clone of the repo then create a pull request to the original repo.
1. **Make review changes**: Update your work based on any review feedback.

If you completed the [initial training](ContributingGettingStarted.md#initial-training) then you should be familiar with the workflow involved with making your changes. We've provided them here in case you need a reference or more details.

## Implementation Workflow

### Fork the GitHub repository

Follow these [GitHub instructions](https://help.github.com/articles/fork-a-repo/) to fork the repository. A fork is basically a copy of the original repository. You want to work on your own copy so you can make changes without affecting the original project.

### Clone your fork

Example for this project:

```bash
git clone https://github.com/YOUR-USERNAME/fbmentorship
```

Where `YOUR-USERNAME` should be replaced with your GitHub username.

### Create a branch

You can create a branch either on [GitHub](https://help.github.com/articles/creating-and-deleting-branches-within-your-repository/) or via the command line. You're likely going to want to do this on the command line since you've already created a local clone of your fork in the previous step.

Go to the directory where you cloned your fork of the repository and run the following:

```bash
git checkout -b SOME-BRANCH-NAME
```

Replace `SOME-BRANCH-NAME` with something that describes the enhancement of fix you're making. For example if you're adding Android documentation for native modules in React Native, you could name your branch `android-add-native-modules-doc`.

After you run this command you'll be switched to the newly created branch. The command above is equivalent to the following:

```bash
git branch SOME-BRANCH-NAME
git checkout SOME-BRANCH-NAME
```

The first command creates a new branch and the second switches to the specified branch.

### Make your changes

Using your favorite editor and tools related to the project, make code changes. Always keep in mind the contributing guidelines for a project. For example, you can find [React Native's guidelines here](https://github.com/facebook/react-native/blob/master/CONTRIBUTING.md).

Typically the guidelines should give you info on style guides and testing requirements.

### Test your changes

You'll want to make sure your code is working per instructions for the project.

### Commit your changes locally

You can do this multiple times before you're completely done.

```bash
git add LIST-OF-CHANGED-FILES
git commit -m "some commit message"
```

Replace `LIST-OF-CHANGED-FILES` with the actual changed file names.

Whenever you're ready to send over your pull request, rebase to squash any multiple commits into one.

```bash
git rebase
```

Check out this [GitHub reference](https://help.github.com/articles/using-git-rebase-on-the-command-line/) for more info and advice on rebasing.

## Push your local changes to your cloned repo

Run the following command to push your local changes up to GitHub:

```bash
git push origin SOME-BRANCH-NAME
```

Replace `SOME-BRANCH-NAME` with the actual name of your branch.

### Initiate the pull request

Now that your changes are up on your cloned repository, you can initiate a pull request to the original project. If this is your first pull request, you may want to run it by your mentor to get their feedback.

Check out docs on [creating a pull request](https://help.github.com/articles/creating-a-pull-request/) for more details.

When you make a pull request, be sure to conform to any guidelines or templates from the original project. Some projects require you to give details test plan info. The more info you give, the easier you'll make the reviewer's life.

Once you've gone through this process, there should be a new pull request in the original project.

### Make any review changes

At this point it's in the reviewer's plate. They may come back with changes after reviewing your code.

Be sure to visit your pull request frequently or pay attention to GitHub notifications to see if there are any required changes.

### Keeping your fork up to date

Before you can sync your fork with an upstream repository, you must [configure a remote that points to the upstream repository](https://help.github.com/articles/configuring-a-remote-for-a-fork/) in Git.

Once you're done there, run the following commands to keep your fork and your feature branch up to date with any changes upstream:

```bash
git fetch upstream
git checkout master
git rebase upstream/master
git push origin master
git checkout feature-branch
git rebase master
```

## Additional Resources

You can also check out these helpful resources if you run into any issues:

* [Pro Git book](https://git-scm.com/book/en/v2) by Scott Chacon and Ben Straub.

* [Using the Fork-and-Branch Git Workflow](http://blog.scottlowe.org/2015/01/27/using-fork-branch-git-workflow/) by Scott Lowe.

* [Beginning Git](https://videos.raywenderlich.com/courses/86-beginning-git/lessons/1) and [Mastering Git](https://videos.raywenderlich.com/courses/87-mastering-git/lessons/1) video tutorial from [raywenderlich.com](https://www.raywenderlich.com/).

* [Git Cheatsheet](https://services.github.com/kit/downloads/github-git-cheat-sheet.pdf) from GitHub.

repository: Ngugisenior/fbmentorship

repo_name: Ngugisenior/fbmentorship


text:
**INTRODUCTION**

To test the performance of the different revocation methods we defined a testcase. The testcase is based on the use case driving licence.
Driving licences are a document with a high distribution and revocation is a crucial feature for a digital driving licence.

***Assessment setup***

The assessment setup is based on statistic figures from Germany and Austria.
The details can be found in the follwing spreadsheet:
https://docs.google.com/spreadsheets/d/1B6Koo8_wUoN4SPDvX7gaKBtkKBr6efOLwKIeVoy4mdI/edit?usp=sharing

**Assessment***

The assessment will be done per method. The results will be recorded in the above spreadsheet.

repository: swcurran/revocation

repo_name: swcurran/revocation


text:
---
hrs_structure:
  division: '2'
  volume: '11'
  title: '26'
  chapter: 489E
  section: '489E-2'
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0489E-0002
    parent: HRS0489E
    name: 489E-2 Definitions
weight: 70010
title: Definitions
full_title: 489E-2 Definitions
---
**[§489E-2] Definitions.** In this chapter:

"Agreement" means the bargain of the parties in fact, as found in their language or inferred from other circumstances and from rules, regulations, and procedures given the effect of agreements under laws otherwise applicable to a particular transaction.

"Automated transaction" means a transaction conducted or performed, in whole or in part, by electronic means or electronic records, in which the acts or records of one or both parties are not reviewed by an individual in the ordinary course in forming a contract, performing under an existing contract, or fulfilling an obligation required by the transaction.

"Computer program" means a set of statements or instructions to be used directly or indirectly in an information processing system in order to bring about a certain result.

"Contract" means the total legal obligation resulting from the parties' agreement as affected by this chapter and other applicable law.

"Electronic" means relating to technology having electrical, digital, magnetic, wireless, optical, electromagnetic, or similar capabilities.

"Electronic agent" means a computer program or an electronic or other automated means used independently to initiate an action or respond to electronic records or performances in whole or in part, without review or action by an individual.

"Electronic record" means a record created, generated, sent, communicated, received, or stored by electronic means.

"Electronic signature" means an electronic sound, symbol, or process attached to or logically associated with a record and executed or adopted by a person with the intent to sign the record.

"Governmental agency" means an executive, legislative, or judicial agency, department, board, commission, authority, institution, or instrumentality of the federal government or of a state or of a county, municipality, or other political subdivision of a state.

"Information" means data, text, images, sounds, codes, computer programs, software, databases, or the like.

"Information processing system" means an electronic system for creating, generating, sending, receiving, storing, displaying, or processing information.

"Person" means an individual, corporation, business trust, estate, trust, partnership, limited liability company, association, joint venture, governmental agency, public corporation, or any other legal or commercial entity.

"Record" means information that is inscribed on a tangible medium or that is stored in an electronic or other medium and is retrievable in perceivable form.

"Security procedure" means a procedure employed for the purpose of verifying that an electronic signature, record, or performance is that of a specific person or for detecting changes or errors in the information in an electronic record. The term includes a procedure that requires the use of algorithms or other codes, identifying words or numbers, encryption, or callback or other acknowledgment procedures.

"State" means a state of the United States, the District of Columbia, Puerto Rico, the United States Virgin Islands, or any territory or insular possession subject to the jurisdiction of the United States. The term includes an Indian tribe or band, or Alaskan native village, which is recognized by federal law or formally acknowledged by a state. "This State" refers to the State of Hawaii.

"Transaction" means an action or set of actions occurring between two or more persons relating to the conduct of business, commercial, or governmental affairs. [L 2000, c 282, pt of §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
---
published: true
layout: post
title: Mule business event logging via ServerNotificationListener
---
Mule CE 3.5.0 does not have any sort of business monitoring. Only logs with lots of technical information.

So you must setup your own infrastructure, for example using [Graylog](http://graylog.org/) or [Logstash + Kibana](http://thepracticalsysadmin.com/introduction-to-logstashelasticsearchkibana/).

But first of all how to get high level information about flows and events in your Mule ESB?

1) Do not init listeners via registry-bootstrap.properties as described in [Start Me Oh So Gently](http://blogs.mulesoft.org/start-me-oh-so-gently/)

The MuleContext instance and internal NotificationManager and it`s Policy field will be overwritten later in process with new instance (this only applies to running in standalone mode, somehow running flow in IDE does not produce such behaviour)

2) Use standard syntax in your flow XML file:

```
<spring:bean name="logger1" class="class implementing MessageProcessorNotificationListener"/>
<spring:bean name="logger1" class="class implementing EndpointMessageNotification"/>

<notifications dynamic="true">
  <notification event="MESSAGE-PROCESSOR"/>
  <notification event="ENDPOINT-MESSAGE"/>
  <notification-listener ref="logger1"/>
  <notification-listener ref="logger1"/>
</notifications>
```

I recommend listening at least on these two events (MessageProcessorNotification and EndpointMessageNotification). The first one produces information about message being processed and sent to outbound endpoints. The second one generate event with information about message received from inbound endpoint.

3) Do the code to extract information from events

```java
public class EMLogger implements EndpointMessageNotificationListener<EndpointMessageNotification> {
  private Logger log = Logger.getLogger(getClass().getName());

  public void onNotification(EndpointMessageNotification m) {
    MuleMessage msg = m.getSource();
    Object payload = msg.getPayload();
    String ref = payload != null ? payload.toString() : "null";

    boolean inc = true;
    if (m.getAction() != EndpointMessageNotification.MESSAGE_RECEIVED) {
      inc = false;
    }

    if (inc) {
      log.warn(msg.getMessageRootId() + " [INBOUND] Message " + ref + " <- " + m.getEndpoint());
    }
  }
}

public class MPLogger implements MessageProcessorNotificationListener<MessageProcessorNotification> {
  private Logger log = Logger.getLogger(getClass().getName());

  public void onNotification(MessageProcessorNotification m) {
    MuleEvent ev = m.getSource();
    MuleMessage msg = ev.getMessage();
    Object payload = msg.getPayload();
    String ref = payload != null ? payload.toString() : "null";

    MessageProcessor proc = m.getProcessor();
    boolean inc = true;
    inc = inc && (proc instanceof LoggerMessageProcessor ? false : true);
    inc = inc && (proc instanceof AsyncDelegateMessageProcessor ? false : true);

    if (m.getAction() != MessageProcessorNotification.MESSAGE_PROCESSOR_PRE_INVOKE) {
      inc = false;
    }

    boolean outgoing = proc instanceof DefaultOutboundEndpoint;

    if (inc) {
      if (outgoing) {
        AbstractEndpoint ep = (AbstractEndpoint) proc;
        log.warn(msg.getMessageRootId() + " [OUTBOUND] Message " + ref + " -> " + ep.getEndpointURI());
      } else {
        log.warn(msg.getMessageRootId() + " [PROCESSING] Message " + ref + " <> " + proc.getClass().getSimpleName());
      }
    }
  }
}
```

4) Write it to different Log4j logger and separate file (mule-standalone-3.5.0/conf/log4j.properties)

```
log4j.appender.my = org.apache.log4j.FileAppender
log4j.appender.my.layout = org.apache.log4j.PatternLayout
log4j.appender.my.layout.ConversionPattern = %d %m%n
log4j.appender.my.Append = true
log4j.appender.gpb.File = ../logs/my.log

log4j.logger.package.with.listeners = INFO, my
log4j.additivity.package.with.listeners = false
```


text:
---
title: Projects
layout: blank
permalink: /projects/
---

“Can I Pass?” Android Application

I wrote a tiny application in Android Studio to help students calculate their
marks. The app tells you what mark you need to get your desired mark in a
course.
I have not had a lot of time to work on it recently, but I would like to expand
the app to track your marks throughout the term, and tell you whether you are
on track to get your desired mark.
You can download the apk of my app [here](canipass.apk)!

WiCS UW Website

As part of my work on the Women in CS committee at UWaterloo, I help to
develop our official website [`wics.uwaterloo.ca`](http://wics.uwaterloo.ca).
Our code is available publicly in our [Github repo](http://githib.com/wicsuw/website).
Working on this website has taught me how to contribute to an open-source project,
as well as how to use Git and Markdown.

Other Open-Source Technology

Recently I have been trying to contribute to open-source technolgies. You can
see my contributions on my [GitHub profile](http://github.com/fboxwala)!

This Website!

My personal website is developed mostly in Markdown and Sass, and is powered
using Jekyll. You can view all the source code for my site in my [public repo](http://github.com/fboxwala/fboxwala/github.io).

repository: fboxwala/fboxwala-github-io-old

repo_name: fboxwala/fboxwala-github-io-old


text:
---
'@emotion/react': major
'@emotion/styled': major
---

Reworked TypeScript definitions so it's easier to provide a type for Theme. Instead of creating custom instances (like before) you can augment builtin Theme interface like this:

```ts
declare module '@emotion/react' {
  export interface Theme {
    primaryColor: string
    secondaryColor: string
  }
}
```

repository: kennethnym/emotion

repo_name: kennethnym/emotion


text:
Remoting 3 Compatibility Notes
=====

This page describes compatibility of the Remoting 3 library.
It addresses binary compatibility and also functional compatibility with old remoting and Java versions.

## Establishing connection between Remoting 2.x and 3.x

Remoting 3 library still contains JNLP1-connect, JNLP2-connect
  and JNLP3-connect [protocols](protocols.md).
When any of these protocols is enabled on both sides,
  remoting versions will be able to establish connection between each other.
This is a **default** behavior.

If JNLP4-connect is the only enabled protocol on one of the sides,
  Remoting 2.x and 3.x versions will be unable to establish the connection between each other.
It may happen only in the case of the custom configuration via [system properties](configuration.md).

## Java compatibility

In Remoting 3 the required Java version is updated from Java 6 to Java 7.

In **Jenkins** project:

* Nothing changes, starting from 1.610 Java 6 is not supported in Jenkins,
  on both master and agents
* In particular cases it was possible to run Jenkins agents on Java 6 with Remoting 2.x,
  but this configuration was not officially supported

In other projects:

* For projects using Java 7 or 8, the upgrade is safe
* For projects using Java 6, Remoting 3.x cannot be used there without upgrade to Java 7
  * Remoting 2.x stable version can be temporarily used instead

## Binary compatibility

Formally Remoting 3.x is not binary compatible with Remoting 2.x,
  but the scope of changes is limited to a single change with a limited impact.

Protocol class hierarchy change:

* `JnlpProtocol` / `JnlpProtocol1` / `JnlpProtocol2` / `JnlpProtocol3` classes were removed.
  Their functionality has been moved to the JnlpProtocolHandler class and its subclasses.
* JnlpServerHandshake class and all its subclasses have been removed from the library
* Several dependent internal classes have been removed or modified

The only **known** usage of the classes was in the Jenkins core,
  the incompatibility is fixed in the [pull-request #2492](https://github.com/jenkinsci/jenkins/pull/2492).

Impact of the changes on **Jenkins** plugins:

* No impact if the plugins do not implement their own Remoting protocols
* There is no such plugins in **open-source** Jenkins plugins available in the main update center or hosted on GitHub
* There may be impact on other plugin implementation

Impact of the changes on other projects:

* Protocol implementations and protocol handling logic may require an update
* [Pull request #2492](https://github.com/jenkinsci/jenkins/pull/2492) can be used as a reference

repository: ivojonker/remoting

repo_name: ivojonker/remoting


text:
You will visualize and make calculations from medical examination data using python.
The rows in the dataset represent patients and the columns represent information like body measurements, results from various blood tests, and lifestyle choices. You will use the dataset to exploring the relationship between cardiac disease, body measurements, blood markers, and lifestyle choices.

Medical data visualizer CSV file link is generated in medical_visualizer.py

Medical_visualizer.py : Draw heat map and categorical plot to understand data
Unit tests are written for you under testing.py

Development:

For development, you can use main.py to test your functions. Click the "run" button and main.py will run.

Testing:

We imported the tests from testing.py to main.py for your convenience. The tests will run automatically whenever you hit the "run" button.

Heat Map : ![IMG_20210605_230302](https://user-images.githubusercontent.com/68240991/120900532-c59dc080-c652-11eb-843c-9aad51d28d6a.jpg)

Categorical Plot : ![IMG_20210605_230130](https://user-images.githubusercontent.com/68240991/120900555-e239f880-c652-11eb-9649-74c15189c474.jpg)