text:
# Stellar app for the Ledger Nano S and Ledger Blue

## Introduction

This is a wallet app for the [Ledger Nano S](https://www.ledgerwallet.com/products/ledger-nano-s) and [Ledger Blue](https://www.ledgerwallet.com/products/ledger-blue) that makes it possible to store your [Stellar](https://www.stellar.org/)-based assets on those devices.

A companion [Javascript library](https://github.com/lenondupe/stellar-ledger-api) is available to communicate with this app. It also includes some scripts with which to test the app.

## Building and installing

To build and install the app on your Nano S or Blue you must set up the Nano Ledger S or Blue build environment. Please follow the Getting Started instructions at the [Ledger Nano S github repository](https://github.com/LedgerHQ/ledger-nano-s).

Alternatively, you can set up the Vagrant Virtualbox Ledger environment maintained [here](https://github.com/fix/ledger-vagrant). This sets up an Ubuntu virtual machine with the Ledger build environment already set up.

The command to compile and load the app onto the device is:

```$ make load```

To remove the app from the device do:

```$ make delete```

## Testing

The `./test` directory contains files for testing the xdr transanction parser and some printing utilities. To build and execute the tests run `./test.sh`.

### XDR parsing

When a transaction is to be signed it is sent to the device as an [XDR](https://tools.ietf.org/html/rfc1832) serialized binary object. To show the transaction details to the user on the device this binary object must be read. This is done by a purpose-built parser shipped with this app. The parser currently supports single operation transactions where the operation is one of createAccount, payment, changeTrust, and managerOffer. Other types of transactions should be signed by sending the transaction hash.

## Key pair validation

The operation to retrieve the public key implements an optional keypair verification method. Along with the request to retrieve the public key a small message is sent that is to be signed by the device. Back on the host the returned signature can be checked against the returned public key. This is to guard against incompatibility between the keypairs generated by the Ledger device and the ones expected by the Stellar network, whatever the reason for this might be. The extra precaution prevents users from sending funds to an address they are not able to sign transactions for.

## Approving a transaction

There are two ways a transaction may be approved by the device. In the case of a single operation transaction the transaction can be sent to the device in its xdr representation. The app then parses the xdr and shows the transaction details on the device for approval.
Alternatively, if a transaction contains more than a single operation and/or contains other types of operations than mentioned above a different method must be used that takes only the transaction hash. In this case the details of the operation cannot be shown to the user. A warning is shown that no data is available and you then a summary of the hash is shown. Only approve the transaction if you trust the companion application you are using on the host, because in this case you cannot be sure the host sent you the transaction you prepared there or has sent a different transaction to the device to sign.

## Troubleshooting

#### TypeError: argument must be string or read-only buffer, not bytearray

After installing a new development environment I ran into this issue while loading the app. It could be related to an incompatible python version. I got around it by editing hexLoader.py. It seems the icon sometimes causes the data type of data object to be converted from string to byte array. On line 148 change
```python
data += struct.pack('>B', len(icon)) + icon
```
to
```python
data += struct.pack('>B', len(icon)) + str(icon)
```


text:
# Tueble - A Vuejs table component
[![npm version](https://badge.fury.io/js/tueble.svg)](https://badge.fury.io/js/tueble)

> Work in progress!

## Properties

### Tueble (Root Table Component)

| Property           | Required? | Default Value      | Description                                                                                |
| ------------------ | --------- | ------------------ | ------------------------------------------------------------------------------------------- |
| data               | Yes       | --                 | Data that will be used to render the table                                                  |
| default-sort-by    | No        | --                 | Initial order of the table                                                                  |
| default-sort-order | No        | asc                | Initial sort order. `asc` for ascending and `desc` for descending                           |
| table-class        | No        | --                 | Classes that will be added to the table                                                     |
| table-body-class   | No        | --                 | Classes that will be added to the table body (`tbody`)                                      |
| filter-text        | No        | --                 | Term used to filter the table. Applies only to columns with the filterable property enabled |
| filter-min-size    | No        | 2                  | Minimal length of the filter search field to filter the table                               |
| filter-min-size    | No        | 2                  | Minimal length of the filter search field to filter the table                               |
| no-data-text       | No        | "No results found" | Text to show when the filtered dataset is empty                                             |

### Column Component

| Property            | Required? | Default Value | Description                                                                                |
| ------------------- | --------- | ------------- | ---------------------------------------------------------------------------------------------------------------------- |
| show                | No        | --            | Sets which object's property to display. Must be provided if `index` prop is `false`                                   |
| sortable            | No        | `true`        | Sets the column as sortable                                                                                |
| filterable          | No        | `true`        | If true, the search text will be compared to the column contents                                                       |
| label               | Yes       | --            | Sets the text of the column header                                                                                |
| index               | No        | `false`       | If `true` column will show row number                                                                                |
| column-class        | No        | --            | Classes that will be added to column                                                                                |
| column-header-class | No        | --            | Classes that will be added to column header                                                                            |
| highlight           | No        | `false`       | If true finds specified terms in your input text and adds HTML tag around them. Does not apply when using custom slots |

### Filter By Domain Component

| Property      | Required? | Default Value | Description                                          |
| ------------- | --------- | ------------- | ---------------------------------------------------- |
| filter-by     | Yes       | `Array`       | Set of elements to be checked in the column provided |
| filter-column | Yes       | `String`      | Name of the column to be searched for                |

license: MIT

repository: marcosdefontes/tueble

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: marcosdefontes/tueble


text:
# Deep Neural Networks for Full-Reference and No-reference Audio-Visual Quality Assessment
[![License](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](License)

## Description
ANNAVQA code for the following papers:

- Y. Cao, X. Min, W. Sun and G. Zhai, "Deep Neural Networks For Full-Reference And No-Reference Audio-Visual Quality Assessment,"
  2021 IEEE International Conference on Image Processing (ICIP), 2021, pp. 1429-1433, doi: 10.1109/ICIP42928.2021.9506408.

## Test Demo
The test video should be provided in raw `YUV 4:2:0` format. The test audio should be provided in `wav` format.
### Saliency Detection
You should first run sal_position.m in Matlab to get `test_position.mat`.
```
sal_position ./dis_test.yuv 1080 1920
```
You need to specify the `distorted video`, `video height` and `video width`.

### Quality Prediction
#### Full-Reference Model Quality Prediction
The FR model weights provided in `./models/FR_model` are the saved weights when running on LIVE-SJTU.
```
python FR_LS_test.py --ref_video_path='./ref_test.yuv' --dis_video_path='./dis_test.yuv' --dis_audio_path='./dis_test.wav' --ref_audio_path='./ref_test.wav' --frame_rate=24
```
You need to specify the `referenced video path`, `referenced audio path`, `distorted video path`, `distorted audio path` and `frame rate`.
Because the video resolution of LIVE-SJTU is `1080p`, our default settings of height and width are 1080 and 1920.
You can change by `--video_width=` and `--video_height=`.

#### No-Reference Model Quality Prediction
The NR model weights and NR model weights provided in `./models/NR_model` are the saved weights when running on LIVE-SJTU.
```
python NR_LS_test.py --dis_video_path='./dis_test.yuv' --dis_audio_path='./dis_test.wav' --frame_rate=24
```
You need to specify the `distorted video path`, `distorted audio path` and `frame rate`.
Because the video resolution of LIVE-SJTU is `1080p`, our default settings of height and width are 1080 and 1920,
which you can change by `--video_width=` and `--video_height=`.

### Requirement
- PyTorch 1.5.0
- Matlab R2020b

Note: we will upload the training code of ANNAVQA later. When you use `./models/FR_model`  and
`./models/NR_model` we trained, the model extracts features of the first 192 frames.
### Contact
<EMAIL_ADDRESS>

branch_name: refs/heads/main


text:
app.path()

Returns the canonical path of the app, a string.

```js
var app = express();
var blog = express();
var blogAdmin = express();

app.use("/blog", blog);
blog.use("/admin", blogAdmin);

console.dir(app.path()); // ''
console.dir(blog.path()); // '/blog'
console.dir(blogAdmin.path()); // '/blog/admin'
```

The behavior of this method can become very complicated in complex cases of mounted apps:
it is usually better to use [req.baseUrl](#req.baseUrl) to get the canonical path of the app.


text:
theia-cli

    CLI for bootstrapping Tsuki-style projects! 🚀

    Explore the docs »

    View Demo
    ·
    Report Bug
    ·
    Request Feature

# Table of Contents

- [Getting Started](#getting-started)
- [Installing](#installing)
- [Built With](#built-with)
- [Versioning](#versioning)
- [Author(s)](<#author(s)>)
- [License](#license)

## Getting Started

To get started using running this project, you should have [Nodejs](https://nodejs.org/en/) installed on your local dev machine, Nodejs by defaults
comes with
[NPM](https://www.npmjs.com/), or you can use the alternative [Yarn](https://yarnpkg.com/en/).

### Installing

Yarn it!

```bash
yarn
```

Or use NPM

```bash
npm install
```

## Built With

- [Typescript](https://www.typescriptlang.org/) - Typescript enables JavaScript developers to use highly-productive development tools and practices
  like static checking and code refactoring when developing JavaScript applications.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/MoonTory/theia-cli/tags).

## Author(s)

- **Gustavo Quinta** - _Initial work_ - [MoonTory](https://github.com/moontory)

## License

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

repository: MoonTory/theia-cli

branch_name: refs/heads/develop

repo_name: MoonTory/theia-cli


text:
# Deployboard Resource

[![Build Status](https://travis-ci.org/cosee-concourse/deployboard-resource.svg?branch=master)](https://travis-ci.org/cosee-concourse/deployboard-resource)
[![Docker Repository on Quay](https://quay.io/repository/cosee-concourse/deployboard-resource/status "Docker Repository on Quay")](https://quay.io/repository/cosee-concourse/deployboard-resource)

Finds html surefire reports and uploads the to S3.

## Source Configuration

* `AWS_ACCESS_KEY`: *Required* Access Key for the AWS Account the S3 Bucket belongs to
* `AWS_SECRET_KEY`: *Required* Secret Key for the AWS Account the S3 Bucket belongs to

## Behavior

### `out`: Post messages to Slack

* Uploads html reports to an S3 bucket.

#### Parameters

* `version`: *Required* Filepath to `semver` version file
* `directory`: *Required* The directory that will be searched for surefire reports
* `bucket`: *Required* The name of the bucket to upload the reports to

### `check`: no-op

* Since this resource does not have a version itself `check` returns an empty JSON.

### `in`: no-op

* Simply returns the provided version

## Example Configuration

### Resource Type
``` yaml
- name: deployboard-resource
  type: docker-image
  source:
    repository: quay.io/cosee-concourse/deployboard-resource
```
### Resource

``` yaml
- name: deployboard
  type: deployboard-resource
  source:
    AWS_ACCESS_KEY: AKAIMFHEFIWNL43579HFKFEHIEUFH384759
    AWS_SECRET_KEY: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```

### Plan

``` yaml
  - put: slack
    params:
      version: version/number
      directory: junit
      bucket: test-bucket
```

repository: cosee-concourse/deployboard-resource

repo_name: cosee-concourse/deployboard-resource


text:
# Keras implementation of Image OutPainting

## Get Started
1. Prepare Data:
      ```sh
      # Downloads the beach data and converts to numpy batch data
      # saves the Numpy batch data to 'data/prepared_data/'
      sh prepare_data.sh
      ```
2. Build Model
    * To build Model from scratch you can directly run 'outpaint.py'

OR

## References
* [Painting Outside the Box: Image Outpainting](https://cs230.stanford.edu/projects_spring_2018/posters/8265861.pdf)

gha_language: Python


text:
Queue-length-based Generic Congestion Control
===========================================

Queue-length-based Generic Congestion Control is a window-based congestion control algorithm, which adjust its congestion window based on the feedback from the SDCCP controller.

This repo is developed based on [Generic Congestion Avoidance CC of ccp-project](https://github.com/ccp-project/generic-cong-avoid).

## Notes

- In order to use this algorithm for congestion control, you also need to install a CCP datapath.
If you see errors about not being able to install a datapath program, it means that you have
either not installed a datapath, or the IPC mechanism between the algorithm and datapath is not
configured properly.

license: ISC

repository: sdccp-project/queue-based-generic-cc

repo_name: sdccp-project/queue-based-generic-cc


text:
# Nebula
![](/images/logos/Nebula-logo-small.png)

# Programming in a Multidemensional Environment
Nebula is a programming language intended for expression. Its use of multidimensional logical constructs to perform actions between nodes likens it to a Turing Machine. These nodes are powerful; rather than simply holding data and linking to other structures, they can trigger actions on the global environment and ultimately cause the execution of functions whose return values may ripple back to the original node. Inspirations for the project include JavaScript, Python, Go, and Haskell. Many of the constructs in Nebula's standard library as well as its primitive structures and types are derived from these languages. Though it borrows some ideas from some of these well-known programming languages, Nebula also offers a new programming paradigm, "spatial programming", an intuitive and fresh way to work with scoping.

See the Nebula Lang Website: https://nebulalang.github.io/

# Features
- _Dynamic_: Dynamically typed by default, but optional static typing can be enforced
- _Asynchronous_: Designed for asynchronous programming; can wait for events while retaining state
- _Functional_: The eager loading of parameters allows for the power of a functional language but also the flexibility of an imperative language
- _Object Oriented_: Editable properties can be attached to every construct in the language, and these objects can be mutable or immutable
- _Spatially Scoped_: Spatial programming is a brand new way of determining the realms within which variables and objects exist

# Hello, World!
Let's take a look at hello-world.star, a basic program written in Nebula. Additional, more complex, examples can be found below.
### Nebula Text
```
Origin default "hello" (0,0,0)
  Result void <0,0,1>

Function "print" (0,1,0)
  Parameter "message" <0,1,0>
    initialize string "Hello, world!"
  Return <0,2,0>

Link (0,3,0) (0,0,1)
```
### Symbolic Diagram
![hello world](/example-programs/hello_world.png)

Unlike most programming languages, Nebula doesn't evaluate anything in order. A Nebula program is essentially a collection of linked nodes whose parameter values rely on the actions of other nodes. In hello-world.star, the action begins at the Result statement. Realizing that it requires a value, the Result statement queries its Control. The Control leads to a simple print function that does what you'd expect... writes to stdout. The print function has its own parameter to satisfy, and as denoted by the diagram, it has been linked to a primitive: the string "Hello, World!". Now, as the data ripples forward, the Result statement's Control query is satisfied. Note that every construct in the program text has an associated coordinate. This is because Nebula is built for programming in virtual reality. The location of every construct in 3D space is important for the spatial scoping and visual layout of the language, so coordinate tracking is necessary.

# Symbol Key

Nebula has both a textual and symbolic representation, and it is important to understand both. Here is a symbol key that should provide a better understanding of any symbolic diagrams of Nebula programs.

![symbol key](/images/symbol-key.png)

# Program Examples

## Fibonacci Sequence: Recursive
### Nebula Text
```
Origin default "_fib" (0,0,0)
  Argument number "n" <0,0,1>
  Result number <0,0,2>

Function "ternary" (1,0,0)
  Parameter "true" <0,0,1>
    access number "n"
  Parameter "false" <0,0,2>
  Parameter "condition" <0,0,3>
  Return <0,0,4>

Function "lessThanOrEqual" (1,1,0)
  Parameter "p1" <0,0,1>
    access number "n"
  Parameter "p2" <0,0,2>
    initialize number 1
  Return <0,0,3>

Function "add" (2,0,0)
  Parameter "p1" <0,0,1>
  Parameter "p2" <0,0,2>
  Return <0,0,3>

Function "_fib" (3,0,0)
  Parameter "n" <0,0,1>
  Return <0,0,2>

Function "subtract" (3,1,0)
  Parameter "p1" <0,0,1>
    access number "n"
  Parameter "p2" <0,0,2>
    initialize number 1
  Return <0,0,3>

Function "_fib" (4,0,0)
  Parameter "n" <0,0,1>
  Return <0,0,2>

Function "subtract" (4,1,0)
  Parameter "p1" <0,0,1>
    access number "n"
  Parameter "p2" <0,0,2>
    initialize number 2
  Return <0,0,3>

Link (1,0,4) (0,0,2) # ternary return <-> result
Link (1,1,3) (1,0,3) # p1 <= p2 <-> ternary condition
Link (2,0,3) (1,0,2) # p1 + p2 <-> ternary false
Link (3,0,2) (2,0,1) # _fib result <-> p1
Link (3,1,3) (3,0,1) # p1 - p2 <-> _fib n
Link (4,0,2) (2,0,2) # _fib result <-> p2
Link (4,1,3) (4,0,1) # p1 - p2 <-> _fib n
```
### Symbolic Diagram
![recursive fibonacci](/example-programs/recursive_fib.png)

# Grammar (Ohm)
```
Nebula {
    Program         =  newline* (Object newline*)* newline*
    Object          =  Origin | Function | Link | Accessor | Conditional

    Origin          =  "Origin" "default"? strlit Location newline OriginBlock
    OriginBlock     =  indent Argument* Result dedent
    Argument        =  "Argument" type strlit Location newline
    Result          =  "Result" type Location newline (indent (Access | Initialize | Evaluate)? Control dedent)?

    Function        =  "Function" strlit Location newline FunctionBlock
    FunctionBlock   =  indent Parameter* Return dedent
    Parameter       =  "Parameter" strlit Location newline (indent (Access | Initialize) dedent)?
    Return          =  "Return" Location newline (indent Control dedent)?

    Initialize      =  "initialize" ("string" strlit | "boolean" boollit | "number" numlit) newline
    Access          =  "access" type strlit newline
    Evaluate        =  "evaluate" strlit newline

    Conditional     =  "Conditional" Location newline indent Condition TrueControl FalseControl dedent
    Condition       =  "Parameter" "condition" Location newline (indent ( Access | Evaluate ) dedent)?
    TrueControl     =  "Control" "true" Location newline
    FalseControl    =  "Control" "false" Location newline

    Accessor        =  "Accessor" strlit Location newline AccessorBlock
    AccessorBlock   =  indent (Access | Initialize | SetParameter | Evaluate) Control? dedent
    SetParameter    =  "Parameter" "\"set\"" type Location newline

    traitLabel      =  "evaluate"

    Link            =  "Link" Location Location
    Location        =  "(" Coordinate ")" | "<" Coordinate ">"
    Control         =  "Control" Location newline
    Coordinate      =  NonemptyListOf<numlit, ",">

    type            =  "number" | "string" | "boolean" | "void"
    numlit          =  "-"? digit+ ("." digit+)?
    strlit          =  "\"" (~"\\" ~"\"" ~"\n" any | escape)* "\""
    boollit         =  "true" | "false"
    escape          =  "\\" ( "\'" | "\"" | "r" | "n" | "\\" | "u")      -- simple
                    |  "\\u" hexDigit hexDigit hexDigit hexDigit         -- codepoint
    indent          =  "⇨"
    dedent          =  "⇦"

    newline         =  "\n"+
    space           :=  " " | "\t" | comment
    comment         =  "#" (~"\n" any)*
}
```

repository: CapnSquirrel/nebula

repo_name: CapnSquirrel/nebula


text:
> Back to [Table of Contents](https://github.com/jpfluger/examples)

# Private NPM Registry with Sinopia

Sinopia is a npm server installed locally. It caches public repositories published by [npmjs.org](https://www.npmjs.org/) and at the same time allows private repositories to be published locally (not sent to npmjs.org).

Many of the examples below came from [Sinopia](https://github.com/rlidwka/sinopia) on GitHub and Dylan Smith's [instructive tutorial](https://blog.dylants.com/2014/05/10/creating-a-private-npm-registry-with-sinopia/).

My additions incorporate using Sinopia with nvm and sysvinit. For a detailed implementation of these refer to the Ubuntu 14.04 [post-install](https://github.com/jpfluger/examples) section.

## Installation

Sinopia uses [node-gyp](https://github.com/TooTallNate/node-gyp/) to cross-compile native addon modules to NodeJS. Install these baseline dependencies for node-gyp to function correctly.

```bash
$ sudo apt-get install -y python-software-properties python g++ make
```

---

List node versions currently installed.

```bash
$ sudo nvm ls

#OUTPUT
  v0.10.28
  v0.10.32
  v0.11.14
current: 	v0.10.32
```

Running the following npm command will by default use node version 0.10.32 to install Sinopia.

```bash
$ sudo npm install -g sinopia
```

---

Warning: do not install an npm module globally, such as

```bash
$ sudo nvm run 0.10.28 /usr/local/nvm/v0.10.28/lib/node_modules/npm/bin/npm-cli.js uninstall -g sinopia
```

because doing so will not create the desired global link in `/usr/bin` or `/usr/local/bin`. Rather when we run sinopia individually, we can tell nvm to run the specific node-version against it. This is what we will tell our custom SysVinit script to do as well.

---

Create where the private npm will reside.

```bash
$ mkdir ~/sinopia; cd ~/sinopia
```

Run sinopia.

```bash
$ sinopia

#OUTPUT
Config file doesn't exist, create a new one? (Y/n)
===========================================================
 Creating a new configuration file: "./config.yaml"

 If you want to setup npm to work with this registry,
 run following commands:

 $ npm set registry http://localhost:4873/
 $ npm set always-auth true
 $ npm adduser
   Username: admin
   Password: XXXXXXXXXXXX
```

Type `ctrl-c` to force the server to stop.  Save the password on display. This is the admin password for the local Sinopia server that allows publishing rights (locally). Before we get to logging in with npm, there are tasks to first complete.

> [Dylant's blog](https://blog.dylants.com/2014/05/10/creating-a-private-npm-registry-with-sinopia/) provides more detail on what is going on here. For the background story, please read through his tutorial.

In this directory, find the `config.yaml` file.

```bash
$ ls

#OUTPUT
config.yaml
```

## Change the default url

If multiple developers need access to this repository, change the default url in `config.yaml`.

Open `config.yaml`.

```bash
$ vim ~/config.yaml
```

Find the line beginning with `listen` and edit as needed.

```bash
listen: <IP_ADDRESS>:4873
```

If you are using Nginx to proxy sinopia, then comment in the following line with the desired url. Note that the default has `https` in the url string. I have tried publishing packages using Nginx-proxying with this line commented out and in. It must be commented in or will not work.

```bash
# if you use nginx with custom path, use this to override links
url_prefix: https://sinopia.example.com/
```

## Setup the SysVinit script

When Sinopia starts, `config.yaml` is read and because Sinopia was installed globally, we need to make certain Sinopia knows to read the `~/sinopia/config.yaml` file. The good news is that the SysVInit script automatically changes to `~/sinopia` and by default uses this folders `config.yaml` file. If `config.yaml` changes, then the Sinopia server must be restarted.

Create the Sinopia SysVInit file.

```bash
$ sudo vim /etc/init.d/sinopia
```

Copy into your editor this [template](https://github.com/jpfluger/examples/blob/master/ubuntu-14.04/sysvinit/node-app), replacing the example values with those required by Sinopia.

```sh
### BEGIN INIT INFO
# Provides:          sinopia
# Required-Start:    $local_fs $remote_fs $network $syslog $named
# Required-Stop:     $local_fs $remote_fs $network $syslog $named
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: starts the sinopia web server
# Description:       starts sinopia using start-stop-daemon
### END INIT INFO

#Set the path env variable
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

#Installed? "whereis nvm"
#Example: IF node ONLY (NO nvm) DAEMON=/usr/local/bin/node
DAEMON=/usr/local/bin/nvm

#This becomes the name of the pid and log file.
APPNAME="sinopia"
DESC="sinopia: a private npm repository"

PIDFILE="/var/run/$APPNAME.pid"
LOGFILE="/var/log/$APPNAME.log"

#Set the working directory. The command below will first "cd" into this directory before executing nvm
APPROOT="/path/to/working/directory/for/sinopia/"

#Format is "filename ARGS"
#Example: DAEMON_ARGS="server.js ADDITIONAL-ARGS-HERE"
DAEMON_ARGS="/usr/local/bin/sinopia"

#First check this was installed with "nvm ls" and if not install with "nvm install nodejs-version"
NODE_VERSION="0.10.32"

#Example: IF node ONLY (NO nvm): NODECMD="cd $APPROOT && exec $DAEMON $DAEMON_ARGS >>$LOGFILE 2>&1"
NODECMD="cd $APPROOT && exec $DAEMON run $NODE_VERSION $DAEMON_ARGS >>$LOGFILE 2>&1"

#Set the user:group id that this process will be run under
NODEUSER=node-app-ps:node-app-ps
```

Start the service.

```bash
$ sudo service sinopia start
```

Check that a process started for nvm and sinopia.

```bash
$ sudo ps aux | grep nvm

#OUTPUT
node-app-ps    1701  0.0  0.0  26760  2144 ?        S    15:40   0:00 /bin/bash /usr/local/bin/nvm run 0.10.32 /usr/local/bin/sinopia
```

Check if sinopia is listening on the expected port. Note that we do not `grep node` because nvm's target is the globally installed `sinopia`.

```bash
$ sudo netstat -ntulp | grep LISTEN | grep sinopia

#OUTPUT
tcp        0      0 <IP_ADDRESS>:4873          <IP_ADDRESS>:*               LISTEN      1732/sinopia
```

If everything checks out, update the rc.d scripts so the script will start on boot.

```bash
$ sudo update-rc.d sinopia defaults 92
```

## Configure npm to use Sinopia

Tell npm to use the Sinopia server.

```bash
$ npm set registry "http://localhost:4873/"
```

Verify that a `.npmrc` file has been created in your home folder.

```bash
$ cat ~/.npmrc

#OUTPUT
registry=http://localhost:4873/
```

Now no matter what version of npm is run for the current user, npm will use Sinopia to manage private packages and interaction with the npm public repository.

> Be wary of running the `npm set registry` command with `sudo`. Doing so creates the same file in the same location but only the root user has read-write access.

## Using npm, login to Sinopia

Let's use npm to login to Sinopia. Use the password saved above.

```bash
npm login
Username: admin
Password:
Email: (this IS public<EMAIL_ADDRESS>```

After you finish, the `.npmrc` file gets updated with additional properties.

## Sinopia private repositories

Edit `config.yaml`. You should already be in the sinopia directory.

```bash
$ sudo vim config.yaml
```

Add the yaml code, as appropriate to your situtation. `loc-*:` signifies that any npm package prefixed by `loc-` will be treated as a private repository. For example, `loc-myapp` or `loc-clientapp`. The section for `*` tells Sinopia that all other packages should be reconciled against `npmjs`. The `allow_publish` command is set to `none`, which will help control accidental publishing.

```yaml
'loc-*':
	# allow all users to read packages ('all' is a keyword)
	# this includes non-authenticated users
	allow_access: all

	# allow 'admin' to publish packages
	allow_publish: admin

	# no proxies, all request should be internal only

'*':
	# allow all users to read packages (including non-authenticated users)
	#
	# you can specify usernames/groupnames (depending on your auth plugin)
	# and three keywords: "$all", "$anonymous", "$authenticated"
	allow_access: $all

	# allow 'admin' to publish packages
	allow_publish: none

	# if package is not available locally, proxy requests to 'npmjs' registry
	proxy: npmjs
```

## package.json

In the module to be published privately, add this to `package.json`.

```vim
"publishConfig" : "http://<IP_ADDRESS>:4873",
```

As Dylant's [says](https://blog.dylants.com/2014/05/10/creating-a-private-npm-registry-with-sinopia/), "This forces users who issue a npm publish command to publish to your Sinopia server rather than the external registry.npmjs.org."

## Publishing modules

Because we are running npm using nvm, it is required to publish npm modules with sudo.

```bash
$ cd /directory/of/npm/module
$ sudo npm publish
```

## Logs

SysVinit outputs Sinopia logs to `/var/log`.

```bash
$ cat /var/log/sinopia.log | less
```

## Notes

Debug as I might, I have one annoying "warning" that I have not been able to get rid of. When restarting Sinopia via the service command, I get the following output:

```bash
$ sudo service sinopia restart

#OUTPUT
Restarting sinopia: a private npm repository pid=/var/run/sinopia.pid
start-stop-daemon: warning: failed to kill 28251: No such process
```

When I check which nvm-sinopia process ids and ports are open for listening, I find sinopia successfully restarts. I've tried a few techniques to get rid of this warning but have not been successful. Perhaps in the move to systemd, this will be easier to resolve.


text:
# Add a binary resource to a PE file

 This simple program will add (or replace) a resource in a PE file. Run it with _--help_ switch to see the accepted commands.

repository: enkomio/Misc

gha_language: F#

repo_name: enkomio/Misc


text:
---
layout: post
title: "How and why I replaced my MacBook Pro by an iPad Pro over the years? 🤓"
date: 2020-07-03
author: gdubeaux
tags:
  - TechFriday
  - iPadLaptop
category: blog
blog: true
---

Big news, I am an iPad fan. But replacing your Mac laptop with an iPad might seem like a crazy idea. In my opinion, it is not: please give me five minutes of your precious time and explain why…

I am not [Federico Viticci][1], as I am not saying that my iPad will be my only computer. I might be tempted in the future, but as a research associate, a lot of software that I use daily are Windows or Mac only (not even Linux…). In the meantime, I proudly own an iMac 5K, which is by far my favorite computer (the screen is terrific). The iPad Pro is here for its mobility aspect: that is where an iPad excel compared to a Mac laptop.

I see this post as the first in a long series that will be categorized under [^iPadLaptop]({{site.baseurl}}/tag/iPadLaptop). In this first article, I will explain the main reasons that pushed me toward adopting the iPad as a daily portable computer.

### The battery life is so much better than an MBP 🤩

Yes, this is big, but let me tell you one thing: whenever you charge your iPad to 100%, you won’t have to do it throughout the day. At least, that is definitely true most of the time, but if you are a hardcore FaceBook user, it might be a different story…

Whenever I travel (which is not the case these days 🦠), I love having my iPad around because I won’t have to find a plug. From door to door, my iPad Pro as enough battery in most cases.

Even if the battery is a genuinely *professional* factor, the next one is even bigger.

### Cellular: internet connection wherever and, whenever you want 🌐

If you own a MacBook (Air, Pro…), you know that you will have to rely on Wi-Fi at one point. You might be able to create a hotspot from your phone but, let’s be honest, that doesn’t sound professional…

With my iPad Pro, I am connected all the time (if AT&T does its job as intended). That is a big thing! Whenever I travel somewhere, I can only bring my iPad if I want to, and I don’t have to overthink about Wi-Fi.

### Most of the apps I use are *really* professional ⌨

That is one of the biggest complaints that I hear about the iPad as a daily computer. But man, you guys are wrong. Of course, you won’t necessarily find the same apps that you have on your computer. Still, I assure you: you can discover great yet professional apps on the App Store.

The only one that is truly missing is Xcode…

Most of the series will focus on my workflows, so I won’t expand on this today.

### The iPad is so much fun 😎

Did you see that coming? The iPad is so much more fun than a boring laptop. And I tend to be more productive on my iPad too.

If you want me to expand on that point, I will do it in the future, but I am sure that most of you agree on that point.

What I will just say is the following: the iPad is more than just a laptop. It is the greatest tablet of all time. I can read scientific articles on portrait mode and jump back at my desk and use an external keyboard and trackpad to do some writing in less than a minute. Do you often read on your laptop? Because I don’t. And if I was to do so, it is so much better on an iPad.

 If you have $1,000, you will get a great machine and a Smart Keyboard folio. You could add a Magic Trackpad if you really want to go all in…

To get a decent Mac laptop, don’t spend less than $2,000 if you want to keep it for 4-5 years. I have my iPad Pro for 5 years now (I bought the first iPad Pro generation) and spent $1,000 in total. And it is still truly a great daily laptop.

### What’s next? 👀

Okay, now that I said that my iPad is five years old, I have to tell you that I am tempted to replace it with a new generation iPad with a Magic Keyboard. See for yourself:

But boy, that thing is expensive. And iPadOS really works well on my iPad Pro right now. I will just wait for WWDC this year and see what they will present for iPadOS 14 🤩

I hope that I convinced you that an iPad is not just about consumption anymore. Of course, watching Netflix is terrific on an iPad. But you can also get so creative with such a powerful tool. I will explain how in my next articles. Stay tuned!

[1]:	https://twitter.com/viticci

extension: markdown


text:
#Achievement Storing API

##POST /save_achievement

Save achievement as a key/value for a particular user and application.

###Request

        params
        description

        access_token
        The secret access token for that specific user and application

        key
        The Key to identify the achievement

        value
        The achievement value to be stored, can be any data type

##GET /get_achievement

Request the value for a previously saved achievement for a player for this application.

###Request

        params
        description

        access_token
        The secret access token for the specific user and application

        key
        The Key to identify the achievement

###Response
Will return the Json object with the value for the given achievement key

##GET /get_achievements

Request all of the achievements for a player for this application.

###Request

        params
        description

        access_token
        The secret access token for the specific user and application

###Response
Will return the Json object with all of the achievements key/values


text:
![img](docs/images/ITRIX-Edge-logo-small2.jpg)
ITRIX-Edge: Software Define Edge
================================

**[中文簡介](README_TW.md)**

ITRIX-Edge leverages containers and kubernetes to edge software can easily connect to major cloud providers.
The main focus of this project is to make deployment and maintanence easily.
With the build in connection to cloud provider, users can easily connnect the edge to cloud.

# Overview

Currently, this project covered two parts, one for physical hardware and other one for software stack. The hardware part includes compute node power control, hardware reset and hardware status report. The software stack is based on container technique, and use kubernetes as container orchestration backend. System services and user applications will run on top of kubernetes, provide appliance management tasks and cloud integration works.

For more information, please check our [overview document](docs/overview.md).

# Contributing

Please see [CONTRIBUTING.md](CONTRIBUTING.md) to know how to contributing.

If you are associated hardware vendor, please consider help us to check our project compatibility. Once the software compatibility is verified, we'll put your hardware into our compatibility list.
Provide reference hardware to us for testing purpose, are always welcome.

# Community

We are open to our project meetings to the public, everyone that interesting in this project can join us via Zoom.

## Scheduled Regular Meeting
- Every other Wednesday, 2:00 PM GMT+8

## Regular Meeting note
- [Google doc](https://docs.google.com/document/d/1wQb8q7dXOevTFSIFiWSf9xacT_8qqiqOgxSLDL-Gn3E)

repository: itrix-edge/ITRIX-Edge

repo_name: itrix-edge/ITRIX-Edge


text:
# 2 Kings 01 General Notes
## Structure and formatting

2 Kings is a continuation of 1 Kings.

The story of Elijah continues in this chapter.

## Special concepts in this chapter

### God’s sovereignty
God is in control of the future. King Ahaziah sent messengers to ask the Philistine god if he would recover from his fall, but this god does not know the future. Because he asked another god instead of Yahweh, Elijah sent the messengers to tell Ahaziah that he would not recover.

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# CDC SDP JS

## Overview of JS related tools

### Babel
[Babel](https://babeljs.io/) is the transpiler we use that translates JavaScript from ES2015/ES6 syntax to the older ES5 syntax used by most browsers. It let's us use newer language features now instead of waiting for browsers to support them.

### Webpack
[Webpack](https://webpack.github.io/) is a module bundler that plays a similar role to what we'd used the Rails asset pipeline for in the past. It watches files and applies certain tools to them when they change. This is the tool that calls Babel to translate our JavaScript files. It is also responsible for transpiling our SCSS into CSS. Finally, it bundles files together to build the JS files we load on the client browser.

## Where to put new JS

All JS code needs to be inside the `webpack` folder or Webpack won't see it. For [React](https://facebook.github.io/react/) components you can put it in the `webpack/components` directory.

When creating a new page you will need to create at least two JS files and one ERB file.

### app/views/[resource_name]/[action].html.erb
This is the erb template you will use for anything you want rendered on initial page load. A rough scaffold for it is as follows:

```
<div class='container' id='react-container'>
</div>
<%= javascript_include_tag *webpack_asset_paths([resource_name], extension: 'js') %>
```

This does two things, it loads the JS for the `resource_name` and provides a div for the JS to hook into. This is important since `ReactDOM.render` requires a DOM element to render into.

### webpack/[resource_name].js

This will be the main entry point for whatever javascript you need running on the page. For example, to load a React component and render it you could use:

```
import React from 'react';
import ReactDOM from 'react-dom';
import ResponseSetTable from './components/ResponseSetTable';

const responses = JSON.parse(document.getElementById('responses-json').innerHTML);
ReactDOM.render(<ResponseSetTable initialResponses={responses} />, document.getElementById('response-set-table'));
```
You'll notice the line that parses some DOM element and then passes it into the component. That is a simple method for preloading data on page load. To make it work you can add a simple DOM node in your ERB like:

```
<script type="application/json" id="responses-json">
  <%= raw response_set.responses.to_json %>
</script>
```
This will render JSON into the DOM. This works because the Rails controller loaded the ActiveRecord model and passed it to the ERB template in a variable called `response_set`.

### webpack/components/[ComponentName].js

This is where you would put whatever React component you are building. For example, a very simple component would look like

```
import React from 'react';

export default MyComponent = () => {
  return <span> Hello, World! </span>
}

```

In this project, we have configured Babel to support [JSX](https://facebook.github.io/react/docs/jsx-in-depth.html). You will notice that React components in this project contain HTML-like code. When implementing functionality with JavaScript, much of the HTML that you typically would have placed in an ERB template will now be placed in a React component using JSX.

### config/webpack.config.js
You will have to **EDIT** this file. Add another entry in the `entry` section for your resource. It will look like:

```
'resource_name': webpack/[resource_name].js
```

This is what makes the `webpack_asset_paths([resource_name], extension: 'js')` in your ERB template work, if the `resource_name` tags don't match it won't find your JS file.

## Testing JS Components

While you could rely on the Rails application's Cucumber suite to test the React code it is likely much simpler to test the components in the JS ecosystem. As such, components should be tested using Mocha

### Getting started writing a test

You should create a file in `/test/frontend/components/[component_name]_test.js` to start. You will need to include some test helpers as seen below.

```
import { renderComponent , expect } from '../test_helper';
import [ComponentName] from '[path_to_component]';
```

You will also need to import your component.

Please feel free to use the following as a scaffold:

```
describe('[componentName]', () => {
  let component;

  beforeEach(() => {
    component = renderComponent([ComponentName], [props]);
  });

  it('has the correct class', () => {
    expect(component).to.have.class('some-class');
  });
});
```

This test will get picked up by the mocha test runner.

### Internal State
In some cases you might need to access the internal state of the component. Unfortunately the renderComponent wrapper doesn't support this use case. There is a second helper called `renderComponentWithState` that will return an object that looks like `{component, componentInstance}` so you can call it like `{component, componentInstance} = renderComponentWithState([ComponentName], [props]);` then proceed as normal. Any time you need to access the state of the component you can do so off the `componentInstance.state` object.

### Simulating Interactions

If your test needs to simulate interactions you can import TestUtils with `import TestUtils from 'react-addons-test-utils';` This will give you access to the Simulate object documented at https://facebook.github.io/react/docs/test-utils.html#simulate There are a handful of examples on the documentation site.

### Running Tests

`npm test`

## Linting

You should run `npm run lint` before making a PR. If it shows a bunch of errors they are likely mostly minor, there's a task for automatically fixing many small errors automatically, `npm run lint-auto`. It'd be a good idea to make a commit before running this just in case. It shouldn't make many large changes but commits are cheap in git.


text:
# DotEnv

![license](https://img.shields.io/badge/license-MIT-brightGreen.svg)
[![build](https://github.com/originphp/dotenv/workflows/CI/badge.svg)](https://github.com/originphp/dotenv/actions)
[![coverage](https://coveralls.io/repos/github/originphp/dotenv/badge.svg?branch=master)](https://coveralls.io/github/originphp/dotenv?branch=master)

A dotenv parser.

## Installation

To install this package

```linux
$ composer require originphp/dotenv
```

Then in your application bootstrap

```php
use Origin\DotEnv\DotEnv;
(new DotEnv())->load(__DIR__);
```

Here is an example of a dotenv file.

```linux
<EMAIL_ADDRESS>GMAIL_PASSWORD=secret
```

You can also add `export` in front of each line so you can source the file with bash.

```linux
export<EMAIL_ADDRESS>export GMAIL_PASSWORD=secret
```

If you want to use a custom name

```php
use Origin\DotEnv\DotEnv;
(new DotEnv())->load(__DIR__,'.env-local');
```

repository: originphp/dotenv

repo_name: originphp/dotenv


text:
---
layout: "unit"
title: "Guide Entry 05.04.08"
path: "/curriculum/guides/2005/4/05.04.08.x.html"
unitTitle: "Solar Effects on Global Warming"
unitAuthor: "Carolyn N. Kinder"
keywords: ""
recommendedFor: "Recommended for Earth Science, grades 5-8."
---

Guide Entry to 05.04.08:

This unit will be used to introduce children to the Sun and its effects on global warming.  The intent of this unit is to ignite their interest so that they will study this subject further on their own.  The unit is designed for children in grades 5-8 and will be taught for approximately ten days.  Because students are limited in their knowledge about the Sun, greenhouse effect, climate and global warming, this topic can be explored only to a somewhat limited extent.  What I have tried to do is to incorporate four main ideas: 1) to study the Sun; 2) to examine the greenhouse effect to see if it is affecting Earth's climate; 3) to examine temperatures over time to see if global temperatures have any effects on weather patterns and 4) to examine whether a brighter Sun is also responsible for rising temperatures.

Several strategies are used in this unit. Learning packages are used with specific goals and objectives with guided instructions from the teacher. Whole group and small group discussions and individual activities are used with each lesson.  Each lesson has a specific stated goal and is guided by one of the main ideas of this unit.   The lessons have been constructed to have students 1) Discuss prior knowledge; 2) Explore by doing an activity; 3) Reflect by looking back at activity, analyze and discuss and 4) to come to some conclusions, communicate to others, identify next steps that lead to the next topic.

The design of this unit has been guided by New Haven Public School Curriculum Science Standards grades 5-8.  Specifically, Content Standard 4.0 Earth Science will be addressed.  This standard states that students will develop an understanding of the structures, properties and dynamic processes of the earth, the solar system, the universe and the galaxy; they will be familiar with the origins, evolution, movements and interactions of these systems.

(Recommended for Earth Science, grades 5-8.)

gha_language: HTML


text:
---
author: dealingwith
date: '2007-12-21 12:19:00'
layout: post
slug: hates-intenets-explorer
status: publish
title: Hates Intenets (Explorer)
wordpress_id: '2415'
categories:
 - design
 - minutia
 - web
---

[danielsjourney][1]'s margins just got fixed in IE7. No idea what it looks
like in IE6. But really, anyone who uses IE probably doesn't care about what
web sites look like. ([This is what it's supposed to look like][2].) (Your OS-
specific font/text treatments may vary.) Still can't figure out what's wrong
with its list item bullets being not at all centered on the first line of list
text, or why the list bullets don't show up at all in the menu. But there is
basically no styling other than the bullet graphic change out going on there,
and I don't even know if you can move around a bullet to get it to line up any
better than the browser does by default.

Now on to [johnnycitizen.com][3]. That one has more issues, where I get
_really_ annoyed that IE doesn't support fixed elements very well. I'm
basically going to just start over there.

   [1]: http://danielsjourney.com/

   [2]: http://danielsjourney.com/blog/files/2007/12/djdc%20dec%2007.png

   [3]: http://johnnycitizen.com

repository: dealingwith/poole

gha_language: CSS

repo_name: dealingwith/poole


text:
# Certificate Based Authentication

This project demonstrates the basics of certificate-based authentication. The server (NGINX) validates the certificate presented by the client and rejects the request if there is no certificate or if the certificate is not valid. If the certificate is valid, NGINX proxies the request to an internal HTTP server (written in Go), and adds a header containing the `Subject DN` of the certificate sent by a client. This header can then be accessed by the internal server.

[![Docker Pulls](https://img.shields.io/docker/pulls/andreburgaud/nginx-cert-auth.svg)](https://hub.docker.com/r/andreburgaud/nginx-cert-auth/)
[![Docker Automated Build](https://img.shields.io/docker/automated/andreburgaud/nginx-cert-auth.svg)](https://hub.docker.com/r/andreburgaud/nginx-cert-auth/)
[![Docker Build Status](https://img.shields.io/docker/build/andreburgaud/nginx-cert-auth.svg)](https://hub.docker.com/r/andreburgaud/nginx-cert-auth/)

It relies on the following technologies:

* **Docker**: Containerization platform (https://www.docker.com/)
* **s6**: Process supervision programs (https://skarnet.org/software/s6/)
* **NGINX**: Web server (https://www.nginx.com/)
* **Go**: Programming language from Google (https://golang.org/)
* **Curl**: Command line tool to interact with web server (https://curl.haxx.se/)
* **OpenSSL**: TLS and SSL implementation (https://www.openssl.org/)

If you don't rebuild the Docker image and simply pull the public image from Docker Hub, you will need only:

* **Docker** to start and stop the container
* **OpenSSl** to generate keys and certificates
* **Curl** to test the communication with the server

# Simplified Architecture

TBD

# Getting Started

## Pull the docker image from Docker Hub:

```
$ docker pull andreburgaud/nginx-cert-auth
```

To build the image locally, refer to section **Development** towards the end of this document.

## Create the keys and certificates:

You can create the keys and certificates either manually, or via a `Makefile` (recommended). In both cases, export an environment variable `PASSPHRASE` to the value of the passphrase used by the **OpenSSL** commands.

After generating the keys and certificates you will have a directory named `certs` containing keys and certificates needed to run the container and communicate securely with the server.

### Manually

Follow the instructions in the section **Keys and Certs** below in this document.

### Makefile

Copy the `Makefile` from the GitHub repo: https://github.com/andreburgaud/docker-cert-auth/blob/master/Makefile, and execute:

```
$ make certs
```

## Start the Container

To start the container with a volume pointing to the local `certs` directory:

```
$ docker run --rm -p 8443:443 -v`pwd`/certs/:/etc/nginx/certs/ andreburgaud/nginx-cert-auth
```

The server can also be started as a `daemon` with option `-d`, but for the purpose of testing this development environment, it is more convenient to check the output of the server in the terminal.

## Tests using Curl

From a different terminal, you can use **curl** to perform some manual tests:

With `-k` **curl** proceeds even if the server connection is considered insecure (i.e. server certificate validation fails)

```
$ curl -v -s -k --key certs/client.key --cert certs/client.crt https://localhost:8443
```

To test the server certificate validation by the client, replace `-k` with `--cacert certs/ca.crt`. The server certificate was signed with `ca.crt` and this will allow the client to perform a successful validation. This requires that the `hostname` matches the name of the host in the certificate (`example.com`). Adding the host name to the `/etc/hosts` file of your system allows to successfully test this scenario on a development system.

```
$ curl -v -s --cacert certs/ca.crt --key certs/client.key --cert certs/client.crt https://example.com:8443
```

In both of those tests, you should get a response `Hello from Go`. In the terminal where the server was started, you can also observe the logs from both NGINX and the internal server. In particular, you should see the Subject DN of the certificate that was passed on by NGINX to the internal web server (Go web server) upon validation of the client certificate.

## Requirements

The following software need to be installed on the system to build and test the project:

* Docker
* OpenSSL
* curl
* make

# Keys and Certs

The OpenSSL commands are described in the following section. To simplify testing this container, there is a target in the Makefile that will issue all the necessary OpenSSL commands. Prior to execute `make certs`, ensure that you have exported the environment variable you want to use for the passphrase:

```
$ export PASSPHRASE=<some_passphrase>
$ make certs
```

## Create CA Key and Certificate for signing Client Certs

**CA**: Certificate Authority

```
$ openssl genrsa -aes256 -out ca.key 4096                   # CA key
$ openssl req -new -x509 -days 365 -key ca.key -out ca.crt  # CA Certificate
```

## Create the Server Key and CSR

**CSR** : Certificate Signing Request

```
$ openssl genrsa -aes256 -out server.key 2048       # Server key
$ openssl req -new -key server.key -out server.csr  # Server CSR
```

## Create and Sign Server Certificate

* Use a real CA certificate for production
* If you want to test the validation of the server certificate by the server, in the CN of the certificate subject, enter the hostname you want to use for the test (check the Makefile for reference; in the Makefile and in this document the host is `example.com`).

```
$ openssl x509 -req -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt
```

## Create Client Key and CSR

```
$ openssl genrsa -aes256 -out client.key 2048       # Client key
$ openssl req -new -key client.key -out client.csr  # Client CSR
```

## Create and Sign Client Certificate

* Using the same CA cert as for the server, in the context of this setup. In a production environment, the client certificate could be self-signed, but the server certificate would be signed by a trusted CA (e.g. Digicert, GoDaddy, Network Solutions, Let's Encrypt...).

```
$ openssl x509 -req -days 365 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out client.crt
```

## Remove passphrases

This is needed so that passphrases are not requested during the start or restart of a service.

```
$ openssl rsa -in server.key -out server.key
$ openssl rsa -in client.key -out client.key
```

# Useful Docker Commands

See Docker commands in the Makefile.

```
$ docker build -t nginx-auth .                                              # Build image
$ docker run --rm -p 8443:443 -v`pwd`/certs/:/etc/nginx/certs/ nginx-auth   # Start container with certs in a volume
$ docker run --rm -p 8443:443 nginx-auth                                    # Start container with certs in the container
$ docker ps                                                                 # List running active container
$ docker ps -a                                                              # List all active container
$ docker rm $(docker ps -a -f status=exited -f status=created -q)           # Delete all containers
```

To stop the container, you can either press `[CTRL+C]` in the terminal where the container was started (assuming the container was not started with the *daemon* option `-d`), or execute `docker stop <container_name>` after finding the container name via `docker ps`.

# Multiple Processes in the Container

Container best practices encourage to manage a single process per container. Although it is a goal, it comes with the necessity to orchestrate multiple containers via other services like **Kubernetes**, **Docker Swarm** or others. There are situations where running more than one process removes unnecessary complexity - like this particular project for example - and still allow to prepare the ground for a more elaborated stage that includes orchestration for containers.

# Development

To build the image locally:

```
$ git clone https://github.com/andreburgaud/docker-cert-auth
$ cd docker-cert-auth
$ make all
```

By default, the generated Docker image is `docker-cert-auth`. It can be changed in the `Makefile` by changing the variable name `IMAGE`.

# License

MIT (See the license file).


text:
# Attachment actions

Displays an attachment with actions

This component embeds the `govuk_publishing_components` attachment component with reduced data. Links to open the file use `target="\_blank"` to open in a new tab.

[Preview the component](https://govuk-content-publisher-prototype.herokuapp.com/components/attachment-actions/)

## Example usage

```
{% call appAttachmentActions({

}) %}

  {{ appAttachment({

  }) }}

{% endcall %}
```

## Accessibility acceptance criteria
Links in the component must:

- accept focus
- be focusable with a keyboard
- be usable with a keyboard
- indicate when they have focus
- change in appearance when touched (in the touch-down state)
- change in appearance when hovered
- be usable with touch
- be usable with [voice commands](https://www.w3.org/WAI/perspectives/voice.html)
- have visible text

## Arguments

This component accepts the following arguments.

|Name|Type|Required|Description|
|---|---|---|---|

*Warning: If you’re using Nunjucks macros in production be aware that using HTML arguments, or ones ending with `.html` can be at risk from [cross-site scripting](https://en.wikipedia.org/wiki/Cross-site_scripting) attacks. More information about security vulnerabilities can be found in the [Nunjucks documentation](https://mozilla.github.io/nunjucks/api.html#user-defined-templates-warning).*


text:
# BMO

BMO helps you to serve static files. It's intended to help you with your local development of static websites. Just do `npm install -g bmo` and then run `bmo` in the folder you want to serve. Run `bmo -h` for more information.

![BMO](img/bmo.gif)

## License (MIT)

Copyright (c) 2014 Finn Pauls, except BMO image which is (c) 2014 Cartoon Network.

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

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

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

repository: finnp/bmo

repo_name: finnp/bmo


text:
# AlexaHome
Personal Python app for Alexa, currently only LEAF related

# Usage
You need to create a folder called "private" within the container folder that contains a certificate.pem and private-key.pem to use a self-signed SSL certificate. That info also needs to be set within the custom Alexa application on Amazon's servers.

Additionally, a config.ini must be made in the private folder containing the login info for the LEAF website/app, structured like this:

```
[get-leaf-info]
username = your-email
password = your-password

```


text:
# Installing TensorFlow Natively on OS X

We will present the tutorial in [Jupyter](http://jupyter.org) notebooks.  To
run them on your machine, you will need a working TensorFlow
installation (v0.11+).

Follow these instructions, which assume you have OS X (probably 10.11
"El Capitan"), and will use Python 2.7.

## Open a terminal.

Open `Terminal`. This tutorial assumes you are using `bash`, which you
probably are.

## Clone this repository

Using git, clone this tutorial and enter that directory.

```
git clone https://github.com/random-forests/tensorflow-workshop.git
cd tensorflow-workshop
```

## Install Pip and Virtualenv

Pip is a package management system used to install and manage software
packages written in Python.  Virtualenv allows you to manage multiple
package installations.

At your Terminal window, run the following command.
```
# Mac OS X
sudo easy_install --upgrade pip
```

Once you've installed pip, you'll need to add a few more packages.

```
sudo easy_install --upgrade six
sudo pip install --upgrade virtualenv
```

These should some dependencies and Virtualenv.

Now, create a virtual environment.

```
virtualenv --system-site-packages ~/tensorflow
```

> Note: If you have already installed anaconda, some versions of
> anaconda and virtualenv are not compatible.  If you have trouble,
> such as seeing errors about "sys.prefix", you may want to try to
> use the [TensorFlow anaconda installation instructions](https://www.tensorflow.org/versions/r0.12/get_started/os_setup.html#anaconda-installation).
> You'll also need to install matplotlib and Pillow as well to get the full experience.

You will need to Activate the environment, which is to say switch your
Python enviroment to a fresh one with clean dependencies.

```
source ~/tensorflow/bin/activate
```

You are now running in a special Python enviroment with safe
dependencies. Your prompt should start with `(tensorflow) $`.

Select a binary and install protobufs, TensorFlow and Jupyter. For
this lab, we will use CPU-only Mac.

```
# Within the (tensorflow) virtualenv
pip install --upgrade protobuf
pip install --upgrade tensorflow
pip install --upgrade jupyter
pip install --upgrade Pillow
```

## Running Jupyter

From your "tensorflow" virtualenv prompt, run the following command:

```
(tensorflow) $ jupyter notebook
```

Click on `0_test_install.ipynb` to test that jupyter is running
correctly.

You should be able to run the code in notebook.

Note: If you can't find `0_test_install.ipynb` to run, you may need to
exit jupyter, `cd ~/tensorflow-workshop` (or where ever you cloned
this repository), and try again.

<hr>

## Installation notes

Virtualenv is a tidy way of managing your dependencies.  Any time
you want to run TensorFlow, you can activate by `source
~/tensorflow/bin/activate`.  To exit the virtual environment, simply
type `deactivate`.

Without using Virtualenv, at this time you may run into issues with
upgrading some pre-installed Python dependencies (especially `numpy`
on MacOS El Capitan 10.11). You can also try Anaconda, see
[TensorFlow anaconda installation instructions](https://www.tensorflow.org/versions/r0.12/get_started/os_setup.html#anaconda-installation) for details.

repository: ml-lab/tensorflow-workshop

repo_name: ml-lab/tensorflow-workshop


text:
# Quick Start - No DI

If you do not wish to use StoneFruit with a DI container, you can build the `Engine` directly and use it:

```csharp
var engineBuilder = new EngineBuilder();
    // Setup the builder here
    // ...
var engine = engineBuilder.Build();
```

Without a DI container, you will need to manually configure the handlers you wish to use, and you will be limited in what dependencies those handlers can require.

repository: Whiteknight/StoneFruit

repo_name: Whiteknight/StoneFruit


text:
# Virtual Device for Android host-side utilities

This repository holds supporting tools that prepare a host to boot
[Cuttlefish](https://source.android.com/setup/create/cuttlefish), a configurable
Android Virtual Device (AVD) that targets both locally hosted Linux x86/arm64
and remotely hosted Google Compute Engine (GCE) instances rather than physical
hardware.

## Debian packages

The following debian packages are provided:

* `cuttlefish-base` - Creates static resources needed by the Cuttlefish devices
* `cuttlefish-user` - Provides a local web server that enables interactions with
the devices through the browser
* `cuttlefish-integration` - Installs additional utilities to run Cuttlefish in
Google Compute Engine
* `cuttlefish-orchestration` - Replaces `cuttlefish-user` in the
[Orchestration project](https://github.com/google/cloud-android-orchestration)
* `cuttlefish-common` - [DEPRECATED] Provided for compatibility only, it's a
metapackage that depends on `cuttlefish-base` and `cuttlefish-user`

The packages can be built with the following command:

```bash
for dir in base frontend; do
    pushd $dir
    dpkg-buildpackage -uc -us
    popd
done
```

Cuttlefish requires only `cuttlefish-base` to be installed, but `cuttlefish-user`
is recommended to enjoy a better user experience. These can be installed after
building with the following command:

```bash
sudo apt install ./cuttlefish-base_*.deb ./cuttlefish-user_*.deb
```

## Google Compute Engine

The following script can be used to build a host image for Google Compute Engine:

    device/google/cuttlefish/tools/create_base_image.go

[Check out the AOSP tree](https://source.android.com/setup/build/downloading)
to obtain the script.

## Docker

The Debian packages can also be built in a the docker container. Dockerfile and
build scripts are included in this repository, just run:

```
    docker/build.sh --build_debs_only --rebuild_debs_verbose
```

The command will build the container, if needed, that builds the Debian packages,
and builds the Debian packages within the container. The resultant packages will
be located under the ```docker/out``` directory.

This repository also contains a Dockerfile that can be used to construct an
image for a privileged Docker container, which in turn can boot the cuttlefish
device.  Such an image allows one to develop for Cuttlefish without having to
install a number of packages directly on the host machine. For more details,
read the [docker instructions](docker/README.md).

repository: google/android-cuttlefish

gha_language: Go

repo_name: google/android-cuttlefish


text:
# VirtualPTZ

This is a DAL-Plugin that turns a 360° webcam into a virtual PTZ (Pitch/Tilt/Zoom) camera by choosing a variable segment of the original camera view and transforming it into a virtual camera output.
Based on [seanchas116/SimpleDALPlugin](https://github.com/seanchas116/SimpleDALPlugin)
which is based on [johnboiles/coremediaio-dal-minimal-example](https://github.com/johnboiles/coremediaio-dal-minimal-example)
who himself used [Apple's CoreMediaIO example](https://developer.apple.com/library/archive/samplecode/CoreMediaIO/Introduction/Intro.html)!)

## How to run

* Build VirtualPTZ in Xcode
* Copy VirtualPTZ.plugin into `/Library/CoreMediaIO/Plug-Ins/DAL`
* Connect your 360° cam and start it
* Attach gamecontroller and connect
* Open Webcam-using app and choose VirtualPTZ as camera input
* Control the camera view with left thumbstick, control zoom and roll with right thumbstick of gamecontroller

There are some (severe) limitations and drawbacks right now:
* As I could only test it with my own 360° cam, selection of the source camera is currently hardcoded to Ricoh Theta cameras (specifically the THETA V, though others should work). I would be open to test this with other cameras if someone provided (*cough RICOH*) me with examples.
* I couldn't be bothered to implement keyboard controls, so a gamecontroller is required right now
* Resolution is pretty bad, which (depending on you use case) may make this project useless.
* Debugging or profiling plugins is a nightmare, so this may contain crashing bugs and memory leaks galore.

repository: avsbot/VirtualPTZ

repo_name: avsbot/VirtualPTZ


text:
# feel-the-web

[![HitCount](http://hits.dwyl.io/myisaak/feel-the-web.svg)](http://hits.dwyl.io/myisaak/feel-the-web)
[![Join the chat at https://gitter.im/feel-the-web/Lobby](https://badges.gitter.im/feel-the-web/Lobby.svg)](https://gitter.im/feel-the-web/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

### Introduction

Feel-the-web is a free cross-platform browser extension allows marketers and students to view, or 'feel', sentiments from websites. It highlights all positive in green, neutral in yellow and negative in red, directly on the webpage itself.

### Setup

- Required dependencies: `Node` and `NPM`
- Optional dependency: `crxmake`

#### 1. You need to clone this GitHub repo *with submodules* so run the following:

`git clone --recurse-submodules -j8 <repo link>` where `<repo link>` is replaced with any of the two links below:
 - `https://github.com/MyIsaak/feel-the-web.git`
 - `git@github.com:MyIsaak/feel-the-web.git`

#### 2. Run the install.sh from base directory
> Note: For Windows users I recommend copying the `browser-polyfill.js` file located in `webextension-polyfill/dist/` to `feel-the-web/src/`, assuming you're locating from base repo directory.

Perhaps you don't have permission to execute `install.sh`, in this case try running `chmod +x install.sh`

`crxmake` is an optional dependency if you wish to pack the plugin

#### 3. Then load the feel-the-web folder onto your web browser
> Note: Don't mistake `feel-the-web/` (incorrect) with `feel-the-web/feel-the-web/` (correct) when loading the plugin onto the browser. Any plugin must have a `manifest.json` in it's base directory.

- For Chrome, you can go to "chrome://extensions" and enable "Developer Mode" then select "Load Unpacked"
- For Firefox, you can enter "about:debugging" in the URL bar and click "Load Temporary Add-on"

### Development

A hot reload script is added for facilitating the developent cycle, since some browsers don't update and require you reload or refresh the plugin manually (especially when packed). It serves as a watchdog for file changes and immediately refreshes the browser. Will be removed on published builds.

### What is sentiment analysis?

The process of computationally identifying and categorizing opinions expressed in a piece of text, especially in order to determine whether the writer's attitude towards a particular topic, product, etc. is positive, negative, or neutral.

A picture is worth a thousand words:

![alt text](https://www.kdnuggets.com/images/sentiment-fig-1-689.jpg "Sentiment analysis diagram")

### How feel-the-web works?

Using [Google's Natural Language REST API](https://cloud.google.com/natural-language/) feel-the-web sends the webpage to their trained neural-network based model which performs sentiment analysis for the extension to receive. This external machine is hosted on their cloud, payed by my own pockets so don't go wild... unless you make a donation :)

Using [Mozilla's WebExtensions Framework](https://developer.mozilla.org/en-US/Add-ons/WebExtensions) feel-the-web can be supported by Chrome, Firefox and Opera as well as the [W3C Community Group](https://browserext.github.io/browserext/)

### Contributors

- Isaak Eriksson
- (perhaps you?)

### Contributions are welcome

If you have any suggestions, issues or new ideas please [leave a chat on gitter](https://gitter.im/feel-the-web/Lobby) or [submit an issue](https://github.com/MyIsaak/feel-the-web/issues)

If you wan't to modify code please [fork this repo](https://github.com/MyIsaak/feel-the-web/edit/master/README.md#fork-destination-box)

### License

Feel the Web is under MIT licensing

repository: MyIsaak/analyze-site

repo_name: MyIsaak/analyze-site


text:
# Exercise-3

As described in [chapter-5](https://info201-s17.github.io/book/introduction-to-git-and-github.html), you should begin by forking this repository, then cloning it to your local machine (if you haven't already).

In the space below, you'll provide some information about a terminal command you've learned thus far in the class. In particular, you should include the following:

A `heading` with the name of the command
An example of how it can be used (with appropriate code highlighting)
A _nested list_ of information about the command (i.e., things that it does, or how it can be used)

See `complete` branch for answers.

# pwd

```
Use `pwd` to print the working direcotry
```

Here's some more information about the `pwd` command:

It can let you know where you working at

Easy to copy the directory for other uses


text:
# git-semver: A cli tool for versioning your git repository

## Why

There is no standardized way to version a git repository. Node applications store their version in a package.json, other appications store it in a Makefile or somewhere else.

What i want is small cli tool that handles the version of my repository, no matter what technology is under the hood.

## Installation

**brew**

```bash
brew tap meinto/git-semver https://github.com/meinto/git-semver
brew install meinto/git-semver/git-semver
```

**manually**

Download the corresponding [latest binary](https://github.com/meinto/git-semver/releases) and run the `install` command. Right now the `install` command is only valid for mac and linux.

```bash
<name-of-binary> install
```

You can use `semver` as a gitplugin by using the following syntax:

```bash
git semver version ...
```

## Usage

By default this cli tool uses a `VERSION` file in the root folder of a git repository to store the version. The versioning is built up on [semantic versioning](https://semver.org/).

```bash
semver version [major|minor|patch] \
  [--dryrun] \                        # default: false -- only show how version would change
  [-p <path-to-repo>] \               # default: .
  [-f <version-file-name>] \          # default: VERSION -- define alternative version file
  [-t <version-file-type>] \          # default: raw -- you can set the values "json" or "raw"
  [--tag] \                           # default: false -- tag the commit with the new version
  [--push] \                          # default: false -- push all changes made by semver
```

You can create an individual `semver.config.json` file in the root of your project to override the default values of the flags. Simply run the `semver init` command and follow the instructions.

### Custom version file

By default `semver` lookup the `VERSION` file in the current directory. If you want to store your version in a custom file use the flag `-f`.

If you prefer a `json` file which contains the version number in a `version` property you can do this by using the flags `-f` in combination with `-t`:

> Auto file type detection will be implemented in the next release.
> If you can't wait, please send a pull request :)

```bash
semver version minor -f package.json -t json
```

If your defined version file is of type `json`, the cli tool only overrides the property `version` and leaves other properties untouched.

### Create git tag

With the flag `--tag` or short `-T`, `semver` will create a git tag of the new version e.g.: `v1.0.0`.

### Push version changes

`semver` writes the new version back into the version file. As described, you can also tag the commit using the flag `-T`. To automatically push these changes made by `semver`, use the flag `--push` or short `-P`.

## Get Version(s)

With the `get` command you can get the current or next possible versions.

```bash
semver get         # will print the current version
semver get major   # will print the next major version
semver get minor   # will print the next minor version
semver get patch   # will print the next patch version
```

With the `--raw` or short `-r` flag you will get the plain number without description. For example:

```bash
semver get minor --raw
```

## Contribute

Create a fork, make your changes, and send a pull request. :sunglasses:

repository: alexkamil/git-semver

repo_name: alexkamil/git-semver


text:
### Cleaner
The cleaner library provides helpers to perform a cleanup during uninstallation.
* **BGI::cleaner::cleanPath _"$currentdir"_**: removes empty directories from deeper to higher
```bash
# Example
# Given the following directory tree:
# /my/targetdir:
#   + subdir1:
#       + file1
#       + subdir2:
#           + subdir3:
BGI::cleaner::cleanPath "/my/targetdir/subdir1/subdir2/subdir3"
# this will result in the new directory tree:
# /my/targetdir:
#   + subdir1:
#       + file1
```

repository: eviweb/bash-generic-installer

repo_name: eviweb/bash-generic-installer


text:
Trello EPD
---

Trello List Display built for the Waveshare 7.5inch Model B e-Paper connected to a Raspberry Pi 3B.

Note: This will also work for the Waveshare 7.5inch Model C
_(and technically A with a few changes to the code)_

Read more technical things [here](./MORE.md)

# Installation

**Pre-requisites**
Pillow 3.0.0 requires `libjpeg`, so install it with `sudo apt install libjpeg-dev`

**Python packages**
`pip3 install -r requirements.txt`

## Setup

Copy `.env.sample` to `.env` and modify the settings.
To get the Trello API key and token, visit https://trello.com/app-key.

> If you are using a Raspberry Pi, enable SPI.

### Webhook Relay

[webhookrelay.com](https://webhookrelay.com/) has been implemented, to allow for push events - rather than polled updates.

* Create an account on [webhookrelay.com](https://webhookrelay.com/)
* Create a bucket called `trelloepd` in the control panel
* Set the `WEBHOOK_KEY` and `WEBHOOK_SECRET` values in `.env`
* [Create a webhook on Trello](https://developer.atlassian.com/cloud/trello/guides/rest-api/webhooks/#creating-a-webhook)
  * Link this to the List ID (You can modify the `trelloConnector.py` to print out the id)

# Running

* Poll Mode - every 5 minutes - `python3 run.py`
* Push Mode - Webhook - `python3 runWebhook.py`

Run it in a `screen` / `tmux` session I guess...

# License

`waveshare_epd` library from [Waveshare](https://github.com/Waveshare/e-Paper)

MIT License

Copyright 2019-2021 Andrew Wong.

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

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

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

repository: featherbear/trello-epd

repo_name: featherbear/trello-epd


text:
---
title: Dolby Evolution
sub: Broadcast Transcoder for ATSC A/85 Compliance (CALM Act)
image:
  alt: Dolby Axon Transcoder
  src<EMAIL_ADDRESS>  zoom: evolution.png
  width: 867px
---
A realtime system for facilitating trusted CALM act compliance in broadcast networks. It consisted of a realtime E-AC-3 transcoder capable of updating a stream’s ‘dialnorm’ in response to ITU-R.BS.1770 or EBU R 128 compliant levelling, and a signing mechanism implemented in metadata extensions to indicate a stream’s compliance to downstream transcoders.

This implementation was a technology preview shown at NAB Show® 2012, mainly for technology partners and technical operations executives from major broadcasters (CBS, ESPN, Comcast, etc.).

:fa-link: [Dolby Broadcast Loudness Solutions][dls]

**Languages:** C, C++
**Technologies:** [Qt][qt], [DD+ (E-AC-3)][a52], [DPLM][dpls]

[dls]:http://www.dolby.com/us/en/professional/broadcast/industry.html

[qt]:https://www.qt.io/developers/
[a52]:http://atsc.org/standard/a522012-digital-audio-compression-ac-3-e-ac-3-standard-12172012/
[dpls]:http://www.dolby.com/us/en/technologies/dolby-professional-loudness-solutions.pdf


text:
# Change Log - @yume-chan/scrcpy

This log was last generated on Fri, 25 Aug 2023 14:05:18 GMT and should not be manually modified.

## 0.0.21
Fri, 25 Aug 2023 14:05:18 GMT

### Updates

- Add support for Scrcpy server version 2.1 and 2.1.1
- Move the fetching server binary script to `@yume-chan/scrcpy-fetch-server` package

## 0.0.20
Mon, 05 Jun 2023 02:51:41 GMT

### Updates

- Add support for Scrcpy 2.0. New features including audio forwarding (supports PCM, AAC and OPUS encoding) and other video codecs (supports H.264 and H.265, AV1 not supported). Read the PR for new options and breaking changes. ([#495](https://github.com/yume-chan/ya-webadb/pull/495))
- Move ADB related code to `@yume-chan/adb-scrcpy` package. This package now only implements the Scrcpy protocol.

## 0.0.19
Sun, 09 Apr 2023 05:55:33 GMT

### Updates

- Change `AdbScrcpyClient#pushServer` to take a `ReadableStream<Uint8Array>` instead of returning a `WritableStream<Uint8Array>`
- Add `AdbReverseNotSupportedError` handling and automatically switch to forward tunnel in `AdbScrcpyClient`.
- Update `AndroidKeyCode` enum to align with Web `KeyboardEvent.code`

## 0.0.18
Wed, 25 Jan 2023 21:33:49 GMT

### Updates

- Move `@yume-chan/adb` to `peerDependencies`
- Add support for Scrcpy server version 1.25
- Add support for `SetClipboard` control message and `AckClipboard` device message

## 0.0.17
Tue, 18 Oct 2022 09:32:30 GMT

### Updates

- Add standalone types for serializing/deserializing Scrcpy packets
- Separate decoders to own packages so they don't need optional peer dependencies.

## 0.0.16
Sat, 28 May 2022 03:56:37 GMT

### Updates

- Upgrade TypeScript to 4.7.2 to enable Node.js ESM
- Add support for more `CodecOptions` keys
- Add support for `CodecOptions` value types other than `int`

## 0.0.15
Mon, 02 May 2022 04:18:01 GMT

### Updates

- Add support for `rotateDevice` control message
- Add method to get screen list

## 0.0.14
Sat, 30 Apr 2022 14:05:48 GMT

### Updates

- Add support for Scrcpy server version 1.24

## 0.0.13
Thu, 28 Apr 2022 01:23:53 GMT

### Updates

- Add support for Scrcpy server version 1.23

## 0.0.12
Sun, 03 Apr 2022 11:18:47 GMT

_Version update only_

## 0.0.11
Sun, 03 Apr 2022 10:54:15 GMT

### Updates

- Add support for Scrcpy server version 1.22
- Update to use Web Streams API
- Improve compatibility with Node.js 12 ESM format
- Workaround a issue with server crash on Samsung ROM (https://github.com/Genymobile/scrcpy/issues/2841)
- Remove output parsing. It's output is for debugging only, not machine readable.
- Update license year

## 0.0.10
Sun, 09 Jan 2022 15:52:20 GMT

_Initial release_

repository: yume-chan/ya-webadb

gha_language: TypeScript

repo_name: yume-chan/ya-webadb


text:
Event Horizon Rider
===================

Multiplatform (mobile first) game inspired by [Super Hexagon](http://www.superhexagon.com) using MonoGame.

[![Event Horizon Rider](https://cloud.githubusercontent.com/assets/1789883/26028224/03049e54-37d1-11e7-8d54-569d0d378b68.gif)](http://www.eventhorizonrider.com)

http://www.eventhorizonrider.com

Build Requirements
------------------
 * Visual Studio 2019 with Xamarin iOS/Android and Windows Universal 10 components installed
 * [MonoGame Content Processors version 3.7.1](http://teamcity.monogame.net/repository/download/MonoGame_PackagingWindows/latest.lastSuccessful/MonoGameSetup.exe?guest=1) located at $(MSBuildExtensionsPath)/MonoGame/v3.0/

Build Instructions
------------------
Open the EventHorizonRider solution, select desired platform project to *Set as StartUp Project*, select appropriate
build configuration and platform, then hit F5.

Development Notes
-----------------
The following software was used to help develop the content:

 * [Audacity](http://audacity.sourceforge.net/)
 * [Paint.NET](http://www.getpaint.net/)
 * [Gimp](http://www.gimp.org/)

The following sites were used to obtain royalty free content:

 * http://www.soundjay.com/
 * http://teknoaxe.com/
 * https://www.freesound.org

Video captures were made using the following:

 * [WM Capture 7](http://wmrecorder.com/products/wm-capture/)

repository: scottlerch/EventHorizonRider

gha_language: C#

repo_name: scottlerch/EventHorizonRider


text:
# LogDemo

logDemo shows up various wireless device data can be visualized to see key events.

## Installation

Use Node NVM to install

```bash
npm install
```

## Usage

```javascript
node server.js
```

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)

repository: byronrau/logDemo

repo_name: byronrau/logDemo


text:
# Docker Engine on Fly.io

This is a Docker Engine that runs on Fly.io.
It is **only** used for [thechangelog/changelog.com](https://github.com/thechangelog/changelog.com) builds.
It provides built-in caching & better performance than the free GitHub Actions Runners (4 CPUs vs 2 CPUs).

## Deploy

1. Create a new app: `fly apps create docker-2022-06-13`
1. Create a volume in a region of your choice: `fly volumes create data --size 50 --region iad`
1. Deploy app: `fly deploy`

## Test

1. Create a WireGuard peer: `fly wireguard create changelog iad github-actions-2022-06-13`
1. [Setup WireGuard with generated config](https://fly.io/docs/reference/private-networking/#importing-your-tunnel)
1. Get the Docker Engine private IP: `fly ips private` → `fdaa:0:4556:a7b:21e0:1:1f9d:2`
1. Set the `DOCKER_HOST` env variable:
    ```sh
    export DOCKER_HOST=tcp://[fdaa:0:4556:a7b:21e0:1:1f9d:2]:2375
    ```
1. Ensure that you can connect to this Docker Engine:
    ```sh
    docker info

    Client:
     ...

    Server:
     ...
     Server Version: 20.10.17
     Kernel Version: 5.12.2
     Operating System: Alpine Linux v3.16
     Architecture: x86_64
     CPUs: 1
     Total Memory: 221.2MiB
     Docker Root Dir: /data/docker

    WARNING: API is accessible on http://[::]:2375 without encryption.
             Access to the remote API is equivalent to root access on the host. Refer
             to the 'Docker daemon attack surface' section in the documentation for
             more information: https://docs.docker.com/go/attack-surface/
    ```

## Scale

We want to scale this remote Docker Engine to a size which is more appropriate for compiling Erlang code: `fly scale vm dedicated-cpu-4x`

The above VM size takes `5m 25s` to complete a build with no cache. The default VM size takes ~3x as long.

Other VM sizes available: https://fly.io/docs/about/pricing/

## Use

This new Docker Engine is configured & used in `.github/workflows/prod_image.yml`

## Troubleshooting

### What should I do if the Wireguard tunnel stops working in GitHub Actions?

1. Create a new WireGuard peer:
    ```sh
    pwd
    $HOME/github.com/thechangelog/changelog.com/2022.fly/docker

    fly wireguard create changelog iad github-actions-2022-08-30

    !!!! WARNING: Output includes private key. Private keys cannot be recovered !!!!
    !!!! after creating the peer; if you lose the key, you'll need to remove    !!!!
    !!!! and re-add the peering connection.                                     !!!!
    ? Filename to store WireGuard configuration in, or 'stdout':  stdout

    [Interface]
    # ... omitting for security reasons
    PersistentKeepalive = 15
    ```
1. Update the [`FLY_WIREGUARD` value in GitHub Actions secrets](https://github.com/thechangelog/changelog.com/settings/secrets/actions) with the stdout output, starting with the `[Interface]` line
1. Re-run the failed job, e.g. https://github.com/thechangelog/changelog.com/actions/runs/2951152698


text:
### DESCRIPTION

The _libvirtd_ component manages the configuration of the
the libvirtd daemon.

### CONFIGURATION PARAMETERS

The base path for all of the configuration parameters is
    `/software/components/libvirtd.`  The following sections describe the
    elements that are permitted directly below this base path.  With
    further parameters described in each section.  All parameters are
    optional.  Except the configuration file location.

#### libvirtd\_config (R '/etc/libvirt/libvirtd.conf')

This string defines the location of the libvirtd configuration file.

#### network

This sections contains the networking parameters.

- listen\_tls: 0 or 1, enabled by default
- listen\_tcp: 0 or 1, disabled by default
- tls\_port: port number (16514) or service name
- tcp\_port: port number (16509) or service name
- listen\_addr (type\_hostname): IPv4/v6 address or hostname
- mdns\_adv: 0 or 1, enabled by default
- mdns\_name: default string is "Virtualization Host HOSTNAME"

#### socket

This section contains the configuration for unix sockets.

- unix\_sock\_group: restricted to root by default
- unix\_sock\_ro\_perms: octal string, default allows any user
- unix\_sock\_rw\_perms: octal string
- unix\_sock\_dir: directory of created sockets

#### authn

This section contains the authentication parameters.

- auth\_unix\_ro: `'none|sasl|polkit'`, default anyone
- auth\_unix\_rw: `'none|sasl|polkit'`, default polkit
- auth\_tcp' ? `'none|sasl'`, should be 'sasl' for production
- auth\_tls' ? `'none|sasl'`

#### tls

This section contains the parameters for TLS.

- key\_file: full path to key file
- cert\_file: full path to certificate file
- ca\_file: full path to certificate authority certificate
- crl\_file: fall path to CRL

#### authz

This section contains the authorization parameters.

- tls\_no\_verify\_certificate: 0 or 1, defaults to verification
- tls\_allowed\_dn\_list: list of allowed DNs
- sasl\_allowed\_username\_list: list of allowed usernames

#### processing

This section contains the parameters used to control the processing.

- max\_clients: maximum number of clients
- min\_workers: minimum number of workers
- max\_workers: maximum number of workers
- max\_requests: maximum number of requests
- max\_client\_requests: maximum number of client requests

#### logging

This section contains the parameters used to control the logging.

- log\_level: 4=errors,3=warnings,2=info,1=debug,0=none
- log\_filters: list of filters, see man for format
- log\_outputs: list of outputs, see man for format

repository: wdpypere/documentation

repo_name: wdpypere/documentation


text:
---
layout: default
title: Chocolate Chunk Cookies
tags:
  - baking
  - dessert
---

# Chocolate Chunk Cookies

## Notes

- Use mass while measuring flour
- Chia can be ground or whole

### Serves: 24

## ⏰ Time

- 20 mins mixing
- 10 mins baking
- 1 hour cooling

## Ingredients

- 1 cup vegan butter or margarine
- 1 cup sugar
- 1 cup packed brown sugar
- 2 Tbsp chia seeds + 6 Tbsp water
- 2 tsp vanilla extract
- 1 tsp baking soda
- 2 tsp hot water
- 1/2 tsp salt
- 3 cups (450g) flour
- 2 cups semisweet chocolate chunks
- 1 cup walnuts

## Directions

1. Preheat oven to 350 degrees F.
1. Add 2 Tbsp chia with 6 Tbsp water and let sit in a small bowl.
1. In a new bowl, cream together the butter, white sugar, and brown sugar until smooth. Beat in the chia, then stir in the vanilla.
1. In the old chia bowl, mix baking soda and hot water. Stir, then add to the rest of the mixture along with salt.
1. Stir in flour by folding the mixture, part way through add in chocolate chunks and walnuts.
1. Use a spoon to drop as lumps onto an ungreased pan. Bake for 10 minutes, or until edges are brown.

repository: kirinrastogi/recipes

repo_name: kirinrastogi/recipes


text:
# pmu-research
Utilities to learn and explore CPU PMUs, and different libraries to interact with the PMUs.

## Installation

Pre-requisites:
* CMake 3.13+
* Recent GCC or Clang compiler with C11 and C++17 support

This project uses git submodules, make sure to pull submodules before running `cmake`.

```bash
git clone --recursive  https://github.com/meteorfox/pmu-research.git
cd pmu-research/
mkdir build && cd build/
cmake ..
```

## Usage

To use the tests that make use of libpfc library, load the 'pfc.ko' kernel module built under `build/third_party/libpfc/kmod`.

See [libpfc's documentation](https://github.com/obilaniu/libpfc#loading-the-kernel-module-pfcko
) for more information on how to load the kernel module.

### Simple test
```bash
$ ./hellopfc
Instructions Issued                  :<PHONE_NUMBER>
Unhalted core cycles                 :<PHONE_NUMBER>
Unhalted reference cycles            :<PHONE_NUMBER>
uops_issued.any                      :<PHONE_NUMBER>
uops_issued.any<1                    :<PHONE_NUMBER>
uops_issued.any>=1                   :<PHONE_NUMBER>
uops_issued.any>=2                   :<PHONE_NUMBER>
...
```

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: meteorfox/pmu-research

repo_name: meteorfox/pmu-research