text:
---
title: Head First Java, 2nd Edition
chapter: 2
sort_key: "02"
textbook: HFJ
desc: "A Trip to Objectville"
---

The big picture
---------------

As page 27 explains, this chapter helps us get out of main and really embrace the whole Object Oriented stuff that Java is supposed to be about. If your previous exposure to Java was all about writing programs where there was only one class, most of your code was in the main, and if you did make other methods, they were all `static`, then this Chapter is the antidote.

Chapter 2, page-by-page
-----------------------

### page 27

Page 27 is about "the big picture" of this chapter--see comments above.

### page 28

Page 28 starts a little story about Larry and Brad, and an Aeron
chair. In case you don't know, Aeron chairs are supposed to be really
comfortable, but they are also really expensive.

(Back in the days of Silicon Valley excess (dot-com bubble days), they
were all the rage at companies with too much money and not enough
sense--see <http://en.wikipedia.org/wiki/Aeron_chair>)

This is sort of the hallmark of the Head First books—telling a story
to try to pull you in, and teaching something about Java on the
way. The code they are writing is sort of silly, but the concepts are
important, so suspend your disbelief and go with it.

### page 29

"The spec always changes". This is a big part of what good software
design is about—making sure you design things in a way that you are
prepared for change. Its one of the reasons I want you to write lots
of code (for the choice points exercises) that become the basis for
building something bigger later—so that you can see how, as you build
on previous code, that code something has to change to accommodate new
needs.

As you can see, the point here is that some designs accomodate change
more easily than others.

### page 30-32

On pages to 32, the discussion continues and we start to get into inheritance.

### pages 33-34

Pages 33 and 34 invite you to really think about Object Oriented
design--the choices that you make when you choose the methods and
attributes of a class. We'll be doing a lot of that in this course, so
I want to really invite you to spend some time on these two pages
thinking about the content.

Having said that, I think the Television exercise on p. 34 is sort of
dumb. I'd rather ask you to create an object for a CalendarEvent, or a
UCSBCourse, or a UCSBStudent, and think about what the methods and
attributes would be--something you might actually use in a Java
program.

gha_language: Ruby


text:
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

# Overview

RRT-X Dynamic obstacle avoidance algorithm (developed by Michael Otte, MIT 2014)

For more details kindly refer to the paper
"RRT-X: Real-Time Motion Planning/Replanning for Environments
with Unpredictable Obstacles,"
WAFR 2014,
Michael Otte and Emilio Frazzoli

- The code was initially written in the Julia language (http://julialang.org/) by Professor Michael Otte.
- Sharan Nayak worked on making it compatible to newer Julia versions (https://gitlab.com/Otte-Lab)

This repository contains the C++ version of the code developed by me. Following is the instruction to compile. You will have to uncomment the main of the particular file you want to run and then execute the suitable compilation code for it.
```
g++ -std=c++11  -I../include list.cpp -o lit
g++ -std=c++11  -I../include heap.cpp -o heap
g++ -std=c++11  -I../include kdtree_general.cpp -o kdtree
g++ -std=c++11  -I../include DRRT_simpleEdge_functions.cpp DRRT_distance_functions.cpp -o simplef
g++ -std=c++11  -I../include DRRT_* list.cpp heap.cpp kdTree_general.cpp experimentsForPaper.cpp -o rrtx
```

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: MATLAB

gha_license_id: MIT

license_type: permissive


text:
# Installation of the module into Lizmap

Here instructions to install the module into [Lizmap Web Client](https://www.lizmap.com/).

Lizmap should be installed and should work, before installing the module.

This documentation is for Lizmap 3.4 or higher.

It is recommended to install the module with [Composer](https://getcomposer.org),
the package manager for PHP. But you can also install manually the sources.

## Automatic installation with Composer  Into Lizmap 3.6 or higher

* into `lizmap/my-packages`, create the file `composer.json` (if it doesn't exist)
  by copying the file `composer.json.dist`, and install the modules with Composer:

```bash
cp -n lizmap/my-packages/composer.json.dist lizmap/my-packages/composer.json
composer require --working-dir=lizmap/my-packages "jelix/multiauth-module"
```

* Then go into `lizmap/install/` and execute Lizmap install scripts :

```bash
php configurator.php multiauth
php installer.php
./clean_vartmp.sh
./set_rights.sh
```

## Manual installation without Composer Into Lizmap 3.6 or higher

* Get the last ZIP archive in the [release page](https://github.com/jelix/multiauth-module/releases) of
  the GitHub repository.
* Extract the archive and copy the `multiauth` directory in the Lizmap Web Client folder `lizmap/lizmap-modules/`
* enable the module with:

```bash
php lizmap/install/configurator.php multiauth
```

* Then execute Lizmap install scripts into `lizmap/install/` :

```bash
php lizmap/install/installer.php
./lizmap/install/clean_vartmp.sh
./lizmap/install/set_rights.sh
```

### Automatic installation with Composer into Lizmap 3.4 and 3.5

* into `lizmap/my-packages`, create the file `composer.json` (if it doesn't exist)
  by copying the file `composer.json.dist`, and install the modules with Composer:

```bash
cp -n lizmap/my-packages/composer.json.dist lizmap/my-packages/composer.json
composer require --working-dir=lizmap/my-packages "jelix/multiauth-module"
```

* Edit the config file `lizmap/var/config/localconfig.ini.php` and add or modify these values into
  the section `[modules]`:

```ini
ldapdao.access=0
multiauth.access=2
jauth.access=2
```

* Then go into `lizmap/install/` and execute Lizmap install scripts :

```bash
php installer.php
./clean_vartmp.sh
./set_rights.sh
```

You can configure the module. See the "Configuration" section of the README.md file.

### Manual installation without Composer Into Lizmap 3.4 or 3.5

* Get the last ZIP archive in the [release page](https://github.com/jelix/multiauth-module/releases) of
  the GitHub repository.
* Extract the archive and copy the `multiauth` directory in the Lizmap Web Client folder `lizmap/lizmap-modules/`
* Edit the config file `lizmap/var/config/localconfig.ini.php` and add or modify these values into
  the section `[modules]`:

```ini
ldapdao.access=0
multiauth.access=2
jauth.access=2
```

* Then execute Lizmap install scripts into `lizmap/install/` :

```bash
php lizmap/install/installer.php
./lizmap/install/clean_vartmp.sh
./lizmap/install/set_rights.sh
```

repository: jelix/multiauth-module

gha_language: PHP

repo_name: jelix/multiauth-module


text:
# Mango Syntax theme

Inspired by the Monokai theme.

The font used in the screenshot is called [Raleway](http://www.google.com/fonts#UsePlace:use/Collection:Raleway)

### Preview:
![Mango-Syntax.png](https://raw.githubusercontent.com/Dubstepper/mango-syntax/master/Mango-Syntax.png)

repository: itsjw/atom

repo_name: itsjw/atom


text:
# concatAll

#### signature: `concatAll(): Observable`

## Collect observables and subscribe to next when previous completes.

---

⚠ Be wary of
[backpressure](https://github.com/Reactive-Extensions/RxJS/blob/master/doc/gettingstarted/backpressure.md)
when the source emits at a faster pace than inner observables complete!

💡 In many cases you can use [concatMap](../transformation/concatmap.md) as a
single operator instead!

---

### Why use `concatAll`?
This operator is best used when you have multiple observables that need to be processed sequentially, ensuring that each observable completes before moving on to the next. Real-world examples of this can be seen in scenarios such as uploading multiple files to a server one-by-one, or displaying a sequence of animations in order.

Bear in mind that `concatAll` will only start processing the next observable when the current one completes. This is an important consideration if you have observables that emit values indefinitely or take a long time to complete, as it may cause a delay in processing subsequent observables.

Additionally, if you're working with observables that can emit values concurrently and don't need to wait for one to complete before processing another, [mergeAll](mergeall.md) might be a more suitable choice. Similarly, if you only need to combine the values of multiple observables at the point when they all complete, [forkJoin](forkjoin.md) could be a better option.

[![Ultimate RxJS](https://drive.google.com/uc?export=view&id=1qq2-q-eVe-F_-d0eSvTyqaGRjpfLDdJz 'Ultimate RxJS')](https://ultimatecourses.com/courses/rxjs?ref=4)

### Examples

(
[example tests](https://github.com/btroncone/learn-rxjs/blob/master/operators/specs/combination/concatall-spec.ts)
)

##### Example 1: concatAll with observable

(
[StackBlitz](https://stackblitz.com/edit/typescript-zwtpc7?file=index.ts&devtoolsheight=100)
| [jsBin](http://jsbin.com/nakinenuva/1/edit?js,console) |
[jsFiddle](https://jsfiddle.net/btroncone/8dfuf2y6/) )

```js
// RxJS v6+
import { map, concatAll } from 'rxjs/operators';
import { of, interval } from 'rxjs';

//emit a value every 2 seconds
const source = interval(2000);
const example = source.pipe(
  //for demonstration, add 10 to and return as observable
  map(val => of(val + 10)),
  //merge values from inner observable
  concatAll()
);
//output: 'Example with Basic Observable 10', 'Example with Basic Observable 11'...
const subscribe = example.subscribe(val =>
  console.log('Example with Basic Observable:', val)
);
```

##### Example 2: concatAll with promise

(
[StackBlitz](https://stackblitz.com/edit/typescript-3w4px3?file=index.ts&devtoolsheight=100)
| [jsBin](http://jsbin.com/bekegeyopu/1/edit?js,console) |
[jsFiddle](https://jsfiddle.net/btroncone/w7kp7qLs/) )

```js
// RxJS v6+
import { map, concatAll } from 'rxjs/operators';
import { interval } from 'rxjs';

//create and resolve basic promise
const samplePromise = val => new Promise(resolve => resolve(val));
//emit a value every 2 seconds
const source = interval(2000);

const example = source.pipe(
  map(val => samplePromise(val)),
  //merge values from resolved promise
  concatAll()
);
//output: 'Example with Promise 0', 'Example with Promise 1'...
const subscribe = example.subscribe(val =>
  console.log('Example with Promise:', val)
);
```

##### Example 3: Delay while inner observables complete

(
[StackBlitz](https://stackblitz.com/edit/typescript-ft3rbf?file=index.ts&devtoolsheight=100)
| [jsBin](http://jsbin.com/pojolatile/1/edit?js,console) |
[jsFiddle](https://jsfiddle.net/btroncone/8230ucbg/) )

```js
// RxJS v6+
import { take, concatAll } from 'rxjs/operators';
import { interval, of } from 'rxjs';

const obs1 = interval(1000).pipe(take(5));
const obs2 = interval(500).pipe(take(2));
const obs3 = interval(2000).pipe(take(1));
//emit three observables
const source = of(obs1, obs2, obs3);
//subscribe to each inner observable in order when previous completes
const example = source.pipe(concatAll());
/*
  output: 0,1,2,3,4,0,1,0
  How it works...
  Subscribes to each inner observable and emit values, when complete subscribe to next
  obs1: 0,1,2,3,4 (complete)
  obs2: 0,1 (complete)
  obs3: 0 (complete)
*/

const subscribe = example.subscribe(val => console.log(val));
```

### Related Recipes

- [Progress Bar](../../recipes/progressbar.md)

### Additional Resources

- [concatAll](https://rxjs.dev/api/operators/concatAll) 📰 - Official docs
- [concatAll](https://indepth.dev/reference/rxjs/operators/concat-all) - In Depth Dev Reference
- [Flatten a higher order observable with concatAll in RxJS](https://egghead.io/lessons/rxjs-flatten-a-higher-order-observable-with-concatall-in-rxjs?course=use-higher-order-observables-in-rxjs-effectively)
  🎥 💵 - André Staltz

---

> 📁 Source Code:
> [https://github.com/ReactiveX/rxjs/blob/master/src/internal/operators/concatAll.ts](https://github.com/ReactiveX/rxjs/blob/master/src/internal/operators/concatAll.ts)

repository: btroncone/learn-rxjs

gha_language: TypeScript

repo_name: btroncone/learn-rxjs


text:
### Service account credential

Provide here a default service account when using the docker-compose command. In order to use a default google
service account, you need to specify the environment variable. See
[Authenticating as a service account](https://cloud.google.com/docs/authentication/production) for additional
information on how to create a service account key and use it locally.

Name the credentials file `gsa-key.json` and store it under this subdirectory.

repository: JohnAdamsy/penelope

branch_name: refs/heads/main

repo_name: JohnAdamsy/penelope


text:
# aspixml [![Build Status](https://travis-ci.org/larixsource/aspixml.svg?branch=master)](https://travis-ci.org/larixsource/aspixml)
ASPI-XML/3.2 types

This package provides types to marshal/unmarshal messages of the Honeywell ASPI-XML/3.2 protocol.

Not all messages are supported yet, check the table below:

Msg | Kind | Supported
--- | --- | ---
SubmitMessage | Request | No
StatusReport | Response | No
RequestStatus | Request | No
CancelMessage | Request | No
RequestDelivery | Request | Yes
MessageDelivery | Response | Yes
GetMessageCopy | Request | No
MessageCopy | Response | No
GetLastIdentifier | Request | No
LastIdentifier | Response | No
Fault | Response | Yes

This package is still unstable.

repository: larixsource/aspixml

repo_name: larixsource/aspixml


text:
Project Status: Completed | Actively maintaining
# golang-glide
A Docker image that builds and runs Go projects that use [Glide](https://glide.sh) for vendoring.

# Versioning
Most of the updates to this image will most likely be bumps to the Go base image version.
As such the following versioning schemes will be used:

```
<Image Semver>-<Golang ver>
<Golang ver>
```

The `<Image Semver>` will be changed when specific changes are made to the Dockerfile.
The `<Golang ver>` will be changed to match the latest Go version.

# Release checklist
1. Tag `latest`
2. Tag specific version
3. Push

# Changelog
- `1.0.0-1.6` - Initial release

repository: Noah-Huppert/golang-glide

repo_name: Noah-Huppert/golang-glide


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# hierBipartite

[![CRAN](https://www.r-pkg.org/badges/version/hierBipartite)](https://www.r-pkg.org/pkg/hierBipartite)
[![CRAN
downloads](https://cranlogs.r-pkg.org/badges/hierBipartite)](https://CRAN.R-project.org/package=hierBipartite)
[![Project Status: Active – The project has reached a stable, usable
state and is being actively
developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
[![MIT
license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT)

> Bipartite Graph-based Hierarchical Clustering

**Author:** [Calvin Chi](https://calvintchi.github.io/)

-----

## About

Bipartite graph-based hierarchical clustering performs hierarchical
clustering of groups of samples based on association patterns between
two sets of variables. It is developed for pharmacogenomic datasets and
datasets sharing the same data structure. In the context of
pharmacogenomic datasets, the samples are cell lines, and the two sets
of variables are typically expression levels and drug sensitivity
values. For this method, sparse canonical correlation analysis from Lee,
W., Lee, D., Lee, Y. and Pawitan, Y. (2011) <doi:10.2202/1544-6115.1638>
is first applied to extract association patterns for each group of
samples. Then, a nuclear norm-based dissimilarity measure is used to
construct a dissimilarity matrix between groups based on the extracted
associations. Finally, hierarchical clustering is applied.

-----

## Installation

For standard use, we recommend installing the package from
[CRAN](https://CRAN.R-project.org/package=hierBipartite) via

``` r
install.packages("hierBipartite")
```

-----

## Example

Minimially sufficient example of using `hierBipartite`. Please refer to
the
[vignette](https://cran.r-project.org/web/packages/hierBipartite/vignettes/hierBipartite.html)
for detailed usage.

``` r
library(hierBipartite)
data(ctrp2)

groups = ctrp2$groups
X = ctrp2$X
Y = ctrp2$Y

result = hierBipartite(X, Y, groups)
```

repository: CalvinTChi/hierBipartite

repo_name: CalvinTChi/hierBipartite


text:
# coreldraw_cdr.ksy

CDR (CorelDRAW drawing) format specification for Kaitai Struct

## What it is

Formal specifications for the CorelDRAW `.cdr` format in [Kaitai Struct](https://kaitai.io/) YAML (`.ksy`), a declarative language for describing binary formats.

If you are interested in...

* what graphic objects (paths, polygons, rectangles, ellipses, embedded images) the CDR document contains,
* how do they look like (i.e. the geometry data associated with them: path points, rectangle side lengths and so on),
* what fill and outline styles the objects use (solid colors, gradients),
* what transformation matrix is applied on each object,

... and more, [Kaitai Struct](https://kaitai.io/) can make all this data accessible to you given the `.ksy` specifications from this repository.

## How to use

**Use the [`bin/cdr-unpk`](bin/cdr-unpk) Bash script** to preprocess the `.cdr` file so that you can read all CDR versions (especially the new ones) without having to worry about what version of the CDR format the `.cdr` file in front of you is using. The usage is the following:

```
bin/cdr-unpk example.cdr
```

It creates example.cdr.unpk in the same directory where `example.cdr` is. The `example.cdr.unpk` file needs to be interpreted by [`cdr_unpk.ksy`](cdr_unpk.ksy) (which imports [`coreldraw_cdr.ksy`](coreldraw_cdr.ksy) and [`file_streams.ksy`](file_streams.ksy) under the hood).

---

To understand why applying the `coreldraw_cdr.ksy` Kaitai Struct specification to real-world `.cdr` files is complicated, you need to have a basic overview of CDR format versions:

* X3 (13.0) and older: directly the RIFF-based chunk structure that `coreldraw_cdr.ksy` understands;
* X4 (14.0) and X5 (15.0): a ZIP archive, the `coreldraw_cdr.ksy` spec can only recognize the `content/riffData.cdr` file inside it;
* X6 (16.0) or later: also a ZIP archive, but the entrypoint is `content/root.dat` which needs to read external chunk payloads from `content/data/*.dat` files.

The need for accessing external streams in CDR X6+ files was a problem, because to be able to use visualizers available for [Kaitai Struct](https://kaitai.io/) (e.g. [ksv](https://github.com/kaitai-io/kaitai_struct_visualizer), [Web IDE](https://ide.kaitai.io/)), the entire parsed byte stream needs to be contained in a single file and the top-level type in the main `.ksy` spec must not have any parameters. That's why the [`bin/cdr-unpk`](bin/cdr-unpk) script was created - it extracts the necessary streams from the given `.cdr` file and dumps them into a `.unpk` file in a custom auxiliary format described in [`cdr_unpk.ksy`](cdr_unpk.ksy).

## Standalone use of `coreldraw_cdr.ksy` from your application

There is a branch [`unpack-zip-yourself`](https://github.com/kaitai-io/coreldraw_cdr.ksy/tree/unpack-zip-yourself) available when you want to use the Kaitai Struct parser generated from `coreldraw_cdr.ksy` in your application. It makes the integration easier, because it provides you a top-level parameter where you pass a list of `KaitaiStream` objects for each external data stream in X6+ files (in the order specified in `content/dataFileList.dat` file of X6+ `.cdr` ZIP archives):

```ksy
params:
  - id: streams
    type: io[]
```

For pre-X6 `.cdr` files, just pass an empty list.

You should be able to understand how to find the data streams in the ZIP archive by looking [into `bin/cdr-unpk`](https://github.com/kaitai-io/coreldraw_cdr.ksy/blob/2266d9908f058a27186a7008f263c0ab74e54beb/bin/cdr-unpk#L30), or you can look [into **libcdr**](https://github.com/LibreOffice/libcdr/blob/b14f6a1f17652aa842b23c66236610aea5233aa6/src/lib/CDRDocument.cpp#L154).

## Manual standalone use of `coreldraw_cdr.ksy` (no support for external streams)

By default, the `coreldraw_cdr.ksy` spec is expected to be imported from [`cdr_unpk.ksy`](cdr_unpk.ksy) and not used by itself. However, if you don't want to preprocess `.cdr` files by [`bin/cdr-unpk`](bin/cdr-unpk), you can manually edit `coreldraw_cdr.ksy` to disable support for external streams (comment out sections `/meta/imports`, `/params` and `/types/chunk_wrapper/instances/body_external`).

Such a `coreldraw_cdr.ksy` specification can be used directly on the `.cdr` file for pre-X4 files (will work great), or on `content/riffData.cdr` if it's inside the ZIP archive of CDR X4/X5 files. For X6 and later it's technically possible to use it on `content/root.dat` itself too, but you won't get too deep into the file because it uses external streams for most chunks (so it probably won't be very useful).

gha_language: Kaitai Struct


text:
# Python MBills

Python implementation of the Hal MBills APIs.

Detailed API documentation: http://docs.mbills.apiary.io
For dev access you should contact Hal MBills sales team.

**NOTE:** This library only partially implements the APIs. If you'd like to see full support, you are free to contribute.
Current support only provides what's absolutely necessary to process online payments.

## Installation

    $ pip install python-mbills

## Usage

### API Initialization

```python

public_key = "...public RSA key string..."

api = MBillsAPI(api_key='my_api_key',
                shared_secret='my_secret_key',
                mbills_rsa_pub_key=public_key)
```

### Test API Parameters

You can test your **api_key**, **shared_secret** and **mbills_rsa_pub_key** by calling
*test_api_parameters_and_signature_verification* function.

If you want to skip the RSA signature verification, initialize the MBillsAPI with **mbills_rsa_pub_key** set to None.
Even though it is not recommended to skip the signature verification, it might come in handy during development.

```python
try:
    success = api.test_api_parameters_and_signature_verification()
    print("Success: %s" % success)
except SignatureValidationException:
    print("Failed to verify signature")
```

### Test Webhook

To trigger webhook call, you can issue a *test_webhook* call. The API will also
verify the RSA keys and your access credentials.

```python
try:
    success = api.test_webhook()
    print("Success: %s" % success)
except SignatureValidationException:
    print("Failed to verify signature")
```

### Create new Sale

You can create a new sale request by simply calling *create_new_sale* with appropriate parameters.

Response:
 - Transaction ID
 - Payment Token Number
 - Status of the payment (please refer to the official documentation)

```python
try:
    tx_id, payment_token_number, status = api.create_new_sale(amount=Decimal('10.00'),
                                                              purpose='Purpose of the payment',
                                                              payment_reference=None,
                                                              order_id=None,
                                                              channel_id=None,
                                                              capture=True)
    print("Payment token number: %s" % payment_token_number)
except SignatureValidationException:
    print("Failed to verify signature")
```

### Fetch Transaction Status

You can issue a call to check the transaction status.

```python
try:
    response_dict = api.create_new_sale(transaction_id=tx_id)
except SignatureValidationException:
    print("Failed to verify signature")
```

### Capture preauthroization

Capture preauthorization. You can use this API only if you have set capture to False when creating the sale.

```python
try:
    response_dict = api.capture_sale(transaction_id=tx_id,
                                     capture_amount=Decimal('10.00'),
                                     message="Your message to the customer")
except SignatureValidationException:
    print("Failed to verify signature")
```

### Void preauthroization

To void a reserved funds, if for instance you can not deliver the goods, you can void the sale.
```python
try:
    response_dict = api.void_preauthorization(transaction_id=tx_id,
                                              message="Your message to the customer")
except SignatureValidationException:
    print("Failed to verify signature")
```

## Not yet supported APIs

List of currently not supported APIs:
 - Attach Document - ZOI
 - Last 24
 - Get Your Wallet Balance
 - FURS Bill Status

## Contact

**Boris Savic**

 * Twitter: [@zitko](https://twitter.com/zitko)
 * Email<EMAIL_ADDRESS>

repository: boris-savic/python-mbills

repo_name: boris-savic/python-mbills


text:
---
title: Build Server Protocol
---

# 1. Build Server Protocol

This document is a thought experiment for how a potential Build Server Protocol (BSP) would look like.
The document is written by Ólafur Páll Geirsson, Jorge Vicente Cantero with feedback from Guillaume Martres and Eugene Burmako.

The Build Server Protocol is not an official Scala Center project nor is it an approved standard.
Everything in this document is subject to change and open for discussions.
Including core data structures.

## 1.1. Motivation

The problem this document aims to address is the multiplied effort required to integrate between available Scala language servers and build tools.
Currently, every language server must implement custom integrations for the most popular Scala Build tools in order to extract compilation information such as classpaths and source directories.
Likewise, new Scala build tools are expected to integrate with all available Scala IDEs.
This explosion of integrations is a growing problem due to the recent proliferation of both Scala language servers and build tools supporting Scala.

## 1.2. Background

The Build Server Protocol takes inspiration from the Language Server Protocol (LSP).
Unlike in the Language Server Protocol, the language server is referred to as the “client” and a build tool such as sbt/pants/gradle/bazel is referred to as the “server”.

The best way to read this document is by considering it as a wishlist from the perspective of an IDE developer.
Consider this document as our personal vision for how a bi-directional communication protocol between a build tool and language server could look like.

The code listings in this document are written using Scala syntax.
Every data strucuture in this document has a direct translation to JSON and Protobuf.
See [Appendix](#15-appendix) for schema definitions that can be used to automatically generate
bindings for different target languages.

<!-- TOC -->

- [1. Build Server Protocol](#1-build-server-protocol)
    - [1.1. Motivation](#11-motivation)
    - [1.2. Background](#12-background)
    - [1.3. Status](#13-status)
    - [1.4. Base protocol](#14-base-protocol)
    - [1.5. Basic Json Structures](#15-basic-json-structures)
        - [1.5.1. Build Target](#151-build-target)
        - [1.5.2. Build Target Identifier](#152-build-target-identifier)
    - [1.6. Actual Protocol](#16-actual-protocol)
        - [1.6.1. Server Lifetime](#161-server-lifetime)
            - [<IP_ADDRESS>. Initialize Build Request](#1611-initialize-build-request)
            - [<IP_ADDRESS>. Initialized Build Notification](#1612-initialized-build-notification)
            - [<IP_ADDRESS>. Shutdown Build Request](#1613-shutdown-build-request)
            - [<IP_ADDRESS>. Exit Build Notification](#1614-exit-build-notification)
        - [1.6.2. Workspace Build Targets Request](#162-workspace-build-targets-request)
        - [1.6.3. Build Target Changed Notification](#163-build-target-changed-notification)
        - [1.6.4. Build Target Text Documents Request](#164-build-target-text-documents-request)
        - [1.6.5. Text Document Build Targets Request](#165-text-document-build-targets-request)
        - [1.6.6. Dependency Sources Request](#166-dependency-sources-request)
        - [1.6.7. Compile Request](#167-compile-request)
        - [1.6.8. Test Request](#168-test-request)
    - [1.7. Extensions](#17-extensions)
        - [1.7.1. Scala](#171-scala)
            - [<IP_ADDRESS>. Scala Build Target](#1711-scala-build-target)
            - [<IP_ADDRESS>. Scalac Options Request](#1712-scalac-options-request)
            - [<IP_ADDRESS>. Scala Test Classes Request](#1713-scala-test-classes-request)
    - [1.8. Appendix](#18-appendix)
        - [1.8.1. Protobuf schema definitions](#181-protobuf-schema-definitions)
        - [1.8.2. Scala Bindings](#182-scala-bindings)

<!-- /TOC -->

## 1.3. Status

A protocol is only worth as much as the quality of the available clients and servers that implement the protocol.
A proof-of-concept integration between [scalameta/metals](https://github.com/scalameta/metals) and [scalacenter/bloop](https://github.com/scalacenter/bloop) using the Build Server Protocol is in the works.
See [sbt/sbt#3890](https://github.com/sbt/sbt/issues/3890) for a discussion on the next steps for adding BSP support in sbt.

The best way to share your thoughts on the Build Server Protocol is to open an issue or pull request to this repository.

## 1.4. Base protocol

The base protocol is identical to the language server base protocol. See
<https://microsoft.github.io/language-server-protocol/specification> for
more details.

Like the language server protocol, the build server protocol defines a
set of JSON-RPC request, response and notification messages which are
exchanged using the base protocol.

## 1.5. Basic Json Structures

In addition to basic data structures in the language server protocol,
the build server protocol defines the following additional data
structures.

### 1.5.1. Build Target

Build target contains metadata about an artifact (for example library, test, or binary artifact).
Using vocabulary of other build tools:

* sbt: a build target is a combined project + config. Example:
  * a regular JVM project with main and test configurations will have
    2 build targets, one for main and one for test.
  * a single configuration in a single project that contains both Java and Scala sources maps to one BuildTarget.
  * a project with crossScalaVersions 2.11 and 2.12 containing main and test configuration in each will have 4 build targets.
  * a Scala 2.11 and 2.12 cross-built project for Scala.js and the JVM with main and test configurations will have 8 build targets.
* pants: a pants target corresponds one-to-one with a BuildTarget
* bazel: a bazel target corresponds one-to-one with a BuildTarget

The general idea is that the BuildTarget data structure should contain only information that is is fast or cheap to compute.

```scala
trait BuildTarget {

  /** The target’s unique identifier */
  def id: BuildTargetIdentifier

  /** A human readable name for this target.
    * May be presented in the user interface.
    * Should be unique if possible.
    * The id.uri is used if None. */
  def displayName: Option[String]

  /** The category of this build target. */
  def kind: List[BuildTargetKind]

  /** The set of languages that this target contains.
    * The ID string for each language is defined in the LSP. */
  def languageIds: List[String]

  /** Language-specific metadata about this target.
    * See ScalaBuildTarget as an example. */
  def data: Option[Json] // Note, matches `any` in the LSP.
}

object BuildTargetKind {
  val Library = 1
  /** This target can be compiled and tested via
    * method buildTarget/test */
  val Test = 2
  /** This target can be tested via method
    * buildTarget/test and may run slower compared to a Test. */
  val IntegrationTest = 3
  /** This target can be run via method buildTarget/run */
  val Main = 4
}
```

### 1.5.2. Build Target Identifier

A unique identifier for a target.

```scala
trait BuildTargetIdentifer {
  /** The target’s URI */
  def uri: URI
}
```

## 1.6. Actual Protocol

Unlike the language server protocol, the build server protocol does not
support dynamic registration of capabilities.
The motivation for this change is simplicity.
If a motivating example for dynamic registration comes up this decision can be reconsidered.
The server and client capabilities must be communicated through the initialize request.

### 1.6.1. Server Lifetime

Like the language server protocol, the current protocol specification
defines that the lifetime of a build server is managed by the client
(e.g. a language server like Dotty IDE). It is up to the client to
decide when to start (process-wise) and when to shutdown a server.

#### <IP_ADDRESS>. Initialize Build Request

Like the language server protocol, the initialize request is sent as the
first request from the client to the server. If the server receives a
request or notification before the initialize request it should act as
follows:

* For a request the response should be an error with code: -32002.
  The message can be picked by the server.

* Notifications should be dropped, except for the exit notification.
  This will allow the exit of a server without an initialize
  request.

Until the server has responded to the initialize request with an
InitializeBuildResult, the client must not send any additional requests
or notifications to the server.

Request:

* method: ‘build/initialize’

* params: InitializeBuildParams defined as follows

```scala
trait InitializeBuildParams {

  /** The rootUri of the workspace */
  def rootUri: DocumentUri

  /** The capabilities of the client */
  def capabilities: BuildClientCapabilities

}

trait BuildClientCapabilities {
    /** The languages that this client supports.
      * The ID strings for each language is defined in the LSP.
      * The server must never respond with build targets for other
      * languages than those that appear in this list. */
    def languageIds: List[String]
}
```

Response:

* result: InitializeBuildResult defined as follows

```scala
trait InitializeBuildResult {
  /** The capabilities of the build server */
  capabilities: BuildServerCapabilities
}

trait BuildServerCapabilities {
  /** The server can compile targets via method buildTarget/compile */
  compileProvider: Boolean
  /** The server can test targets via method buildTarget/test */
  testProvider: Boolean
  /** The server can provide a list of targets that contain a
    * single text document via the method textDocument/buildTargets */
  textDocumentBuildTargetsProvider: Boolean
  /** The server provides sources for library dependencies
    * via method buildTarget/dependencySources */
  dependencySourcesProvider: Boolean
  /** The server sends notifications to the client on build
    * target change events via buildTarget/didChange */
  buildTargetChangedProvider: Boolean
}
```

#### <IP_ADDRESS>. Initialized Build Notification

Like the language server protocol, the initialized notification is sent
from the client to the server after the client received the result of
the initialize request but before the client is sending any other
request or notification to the server. The server can use the
initialized notification for example to initialize intensive computation
such as dependency resolution or compilation. The initialized
notification may only be sent once.

Notification:

* method: ‘build/initialized’
* params: InitializedBuildParams defined as follows

```scala
trait InitializedBuildParams {

}
```

#### <IP_ADDRESS>. Shutdown Build Request

Like the language server protocol, the shutdown build request is sent
from the client to the server. It asks the server to shut down, but to
not exit (otherwise the response might not be delivered correctly to the
client). There is a separate exit notification that asks the server to
exit.

Request:

* method: ‘shutdown’
* params: `null`

Response:

* result: `null`
* error: code and message set in case an exception happens during
  shutdown request.

#### <IP_ADDRESS>. Exit Build Notification

Like the language server protocol, a notification to ask the server to
exit its process. The server should exit with success code 0 if the
shutdown request has been received before; otherwise with error code 1.

Notification:

* method: ‘exit’
* params: `null`

### 1.6.2. Workspace Build Targets Request

The workspace build targets request is sent from the client to the server to ask for the list of all available build targets in the workspace.

Request:

* method: 'workspace/buildTargets'
* params: `WorkspaceBuildTargetsParams`, defined as follows

```scala
trait WorkspaceBuildTargetsParams {
}
```

Response:

* result: `WorkspaceBuildTargetsResult`, defined as follows

```scala
trait WorkspaceBuildTargetsResult {
  /** The build targets in this workspace that
    * contain sources with the given language ids. */
  def targets: List[BuildTarget]
}
```

### 1.6.3. Build Target Changed Notification

The build target changed notification is sent from the server to the client to signal a change in a build target.
The server communicates during the initialize handshake whether this method is supported or not.

Notification:

* method: 'buildTarget/didChange'
* params: `DidChangeBuildTarget` defined as follows:

```scala
trait DidChangeBuildTarget {
  def changes: List[BuildTargetEvent]
}
trait BuildTargetEvent {
  /** The identifier for the changed build target */
  def uri: URI
  /** The kind of change for this build target */
  def kind: Option[BuildTargetEventKind]

  /** Any additional metadata about what information changed. */
  def data: Option[Json]
}
object BuildTargetEventKind {
  val Created = 1
  val Changed = 2
  val Deleted = 3
}
```

### 1.6.4. Build Target Text Documents Request

The build target text documents request is sent from the client to the server to query for the list of source files that are part of a given list of build targets.

* method: `buildTarget/textDocuments`
* params: `BuildTargetTextDocumentsParams`

```scala
trait BuildTargetTextDocumentsParams {
  def targets: List[BuildTargetIdentifier]
}
```

Response:

* result: `BuildTargetTextDocumentsResponse`, defined as follows

```scala
trait BuildTargetTextDocumentsResponse {
  /** The source files used by this target */
  def textDocuments: List[TextDocumentIdentifier]
}
```

### 1.6.5. Text Document Build Targets Request

The text document build targets request is sent from the client to the server to query for the list of targets containing the given text document.
The server communicates during the initialize handshake whether this method is supported or not.

This request may be considered as the inverse of `buildTarget/textDocuments`.
This method can be used by a language server on `textDocument/didOpen` to lookup which compiler instance to use to compile that given text document.
In the case there are multiple targets (for example different platforms: JVM/JS, or x86/ARM) containing the same source file, the language server may present in the editor multiple options via `textDocument/codeLens` to configure how to dis-ambiguate.

* method: `textDocument/buildTargets`
* params: `TextDocumentBuildTargetsParams`, defined as follows

```scala
trait TextDocumentBuildTargetsParams {
  def textDocument: TextDocumentIdentifier
}
```

Response:

* result: `TextDocumentBuildTargetsResult`, defined as follows

```scala
trait TextDocumentBuildTargetsResult {
  def targets: List[BuildTargetIdentifier]
}
```

### 1.6.6. Dependency Sources Request

The build target dependency sources request is sent from the client to the server to query for the list of sources for the dependency classpath of a given list of build targets.
The server communicates during the initialize handshake whether this method is supported or not.
This method can be used by a language server on `textDocument/definition` to "Go to definition" from project sources to dependency sources.

* method: `buildTarget/dependencySources`
* params: `DependencySourcesParams`

```scala
trait DependencySourcesParams {
  def targets: List[BuildTargetIdentifier]
}
```

Response:

* result: `DependencySourcesResult`, defined as follows

```scala
trait DependencySourcesResult {
  def items: List[DependencySourcesItem]
}
trait DependencySourcesItem {
  def target: BuildTargetIdentifier
  /** List of resources containing source files of the
    * target's dependencies.
    * Can be jar files, zip files, or directories. */
  def sources: List[URI]
}
```

### 1.6.7. Compile Request

The compile build target request is sent from the client to the server to compile the given list of build targets.
The server communicates during the initialize handshake whether this method is supported or not.
This method can for example be used by a language server before `textDocument/rename` to ensure that all workspace sources typecheck correctly and are up-to-date.

* method: `buildTarget/compile`
* params: `CompileParams`

```scala
trait CompileParams {
  def targets: List[BuildTargetIdentifier]

  /** Optional arguments to the compilation process. */
  def arguments: List[Json]
}
```

Response:

* result: `CompileReport`, defined as follows

```scala
trait CompileReport {
  def items: List[CompileReportItem]
}
trait CompileReportItem {

  /** The total number of reported errors compiling this target. */
  def errors: Long

  /** The total number of reported warnings compiling the target. */
  def warnings: Long

  /** The total number of milliseconds it took to compile the target. */
  def time: Option[Long]

  /** The total number of lines of code in the given target. */
  def linesOfCode: Option[Long]

}
```

The server is free to send any number of `textDocument/publishDiagnostics` and `window/logMessage` notifications during compilation before completing the response.
The client is free to forward these messages to the LSP editor client.

### 1.6.8. Test Request

The test build target request is sent from the client to the server to test the given list of build targets.
The server communicates during the initialize handshake whether this method is supported or not.

* method: `buildTarget/Test`
* params: `TestParams`

```scala
trait TestParams {
  def targets: List[BuildTargetIdentifier]
  /** Optional arguments to the test execution. */
  def arguments: List[Json]
}
```

Response:

* result: `TestReport`, defined as follows

```scala
trait TestReport {
  def items: List[TestReportItem]
}
trait TestReportItem {

  /** The compile times before executing tests if the target.
    * An empty field means the target may have already
    * been compiled beforehand. */
  def compileReport: Option[CompileReportItem]

  /** The total number of successful tests. */
  def passed: Long

  /** The total number of failed tests. */
  def failed: Long

  /** The total number of milliseconds it took to run the tests.
    * Should not include compile times. */
  def time: Option[Long]
}
```

The server is free to send any number of `textDocument/publishDiagnostics` and `window/logMessage` notifications during compilation before completing the response.
The client is free to forward these messages to the LSP editor client.

## 1.7. Extensions

The build server protocol is designed to be extended with language specific data structures and methods.

### 1.7.1. Scala

The following section contains Scala-specific extensions to the build server protocol.

#### <IP_ADDRESS>. Scala Build Target

`ScalaBuildTarget` is a basic data structure that contains scala-specific metadata for compiling a target containing Scala sources.
This metadata is embedded in the `data: Option[Json]` field of the `BuildTarget` definition.

```scala
trait ScalaBuildTarget {

  /** The Scala organization that is used for a target. */
  def scalaOrganization: String

  /** The scala version to compile this target */
  def scalaVersion: String

  /** The binary version of scalaVersion.
    * For example, 2.12 if scalaVersion is 2.12.4. */
  def scalaBinaryVersion: String

  /** The target platform for this target */
  def platform: ScalaPlatform

}

object ScalaPlatform {
  val JVM = 1
  val JS = 2
  val Native = 3
}
```

#### <IP_ADDRESS>. Scalac Options Request

The build target scalac options request is sent from the client to the server to query for the list of compiler options necessary to compile in a given list of targets.

* method: `buildTarget/scalacOptions`
* params: `ScalacOptionsParams`

```scala
trait ScalacOptionsParams {
  def targets: List[BuildTargetIdentifier]
}
```

Response:

* result: `ScalacOptionsResult`, defined as follows

```scala
trait ScalacOptionsResult {
  def items: List[ScalcOptionItem]
}
trait ScalacOptionsItem {
    def target: BuildTargetIdentifier
    /** Additional arguments to the compiler.
      * For example, -deprecation. */
    def options: List[String]
    /** The dependency classpath for this target, must be
      * identical to what is passed as arguments to
      * the -classpath flag in the command line interface
      * of scalac. */
    def classpath: List[String]
    /** The output directory for classfiles produced by this target */
    def classDirectory: String
}
```

#### <IP_ADDRESS>. Scala Test Classes Request

The build target scalac options request is sent from the client to the server to query for the list of fully qualified names of test clases in a given list of targets.
This method can for example be used by a language server by using `textDocument/codeLens` to attach a "Run test suite" button above the definition of a test suite.
By clicking on the button, the language server can pass the fully qualified name of the test class as an argument to the `buildTarget/test` request.

* method: `buildTarget/scalaTestClasses`
* params: `ScalaTestClassesParams`

```scala
trait ScalaTestClassesParams {
  def targets: List[BuildTargetIdentifier]
}
```

Response:

* result: `ScalaTestClassesResult`, defined as follows

```scala
trait ScalaTestClassesResult {
  def items: List[ScalaTestClassesItem]
}
trait ScalaTestClassesItem {
    def target: BuildTargetIdentifier
    /** The fully qualified names of the test classes in this target */
    def classes: List[String]
}
```

## 1.8. Appendix

### 1.8.1. Protobuf schema definitions

The data structures presented in this document are accompanied by protobuf schema definitions.
See [bsp.proto](src/main/protobuf/bsp.proto).

### 1.8.2. Scala Bindings

A Scala library implementation of this communication protocol is available in this repository.
The public API of this library currently has three direct Scala dependencies:

* ScalaPB - for generation of Scala sources from protobuf schema
* Monix - for asynchronous programming primitives
* Circe - for JSON serialization and parsing of protocol data structures

If there is demand, it should be possible to refactor out all three dependencies to provide a zero dependency core module.

repository: jvican/bsp

repo_name: jvican/bsp


text:
# RepoDestQML

Application written in C++/QT to communicate with many Siemens PLC devices by ethernet and collect data into SQLite or Access database.
This example of application is on production use in Valeo factory in Skawina(Poland). It is in use to collect all errors on machines and times of occurence.
Collected data are used to create raports.
Snap7 library is used to communicate with PLC devices.
Under this link You can find executable version of this application: https://github.com/azieh/RepoDestQML/tree/master/RepoDest5.6

![alt text](http://i.stack.imgur.com/h8vy7.jpg)

### Prerequisites
Application can be started on any windows operation system.

## License

This project is licensed under the MIT License


text:
jekyll-website
==============

Personal Website of Animesh Garg.

Based on [Al-folio](https://github.com/alshedivat/al-folio) template.

How to run:
1. Open shell and cd to the github repo clone.
2. (for the first time) chmod a+x local_test deploy
3. ./local_test #for testing locally
4. ./deploy #for deployment on github make sure to edit the deploy file.

(optiona) bundle exec jekyll clearn && bundle exec jekyll serve --watch --incremental
This will fire up a local server and you may check if your website works.
--watch allows you to change files without recompiling

---
Reference Docs:

Comprehensive guide to Jekyll: http://jekyllrb.com/docs/home/
Liquid Tags Cheatsheet: http://cheat.markdunkley.com/
Kramdown - http://kramdown.gettalong.org/syntax.html (Preferred)
Markdown Syntax: http://daringfireball.net/projects/markdown/syntax
Textile Documentation: http://txstyle.org/
Fonts: https://edgewebfonts.adobe.com/index
Check Fonts on a webpage - http://fount.artequalswork.com/
jekyll scholar and github actions: https://martinopilia.com/posts/2020/02/22/migration.html

gha_language: HTML


text:
#[TCPCopy](https://github.com/session-replay-tools/tcpcopy) - A TCP Stream Replay Tool

TCPCopy is a TCP stream replay tool to support real testing of Internet server applications.

##Description
Although the real live flow is important for the test of Internet server applications, it is hard to simulate it as online environments are too complex. To support more realistic testing of Internet server applications, we develop a live flow reproduction tool – TCPCopy, which could generate the test workload that is similar to the production workload. Currently, TCPCopy has been widely used by companies in China.

TCPCopy has little influence on the production system except occupying additional CPU, memory and bandwidth. Moreover, the reproduced workload is similar to the production workload in request diversity, network latency and resource occupation.

##Scenarios
* Distributed stress testing
  - Use tcpcopy to copy real-world data to stress test your server software. Bugs that only can be produced in high-stress situations can be found
* Live testing
  - Prove the new system is stable and find bugs that only occur in the real world
* Regression testing
* Performance comparison

##Architecture

![tcpcopy](https://raw.github.com/wangbin579/auxiliary/master/images/tcpcopy.GIF)

As shown in Figure 1, TCPCopy consists of two parts:  *tcpcopy* and *intercept*. While *tcpcopy* runs on the online server and captures the online requests, *intercept* runs on the assistant server and does some assistant work, such as passing response info to *tcpcopy*. It should be noted that the test application runs on the target server.

*tcpcopy* utilizes raw socket input technique by default to capture the online packets at the network layer and does the necessary processing (including TCP interaction simulation, network latency control, and common upper-layer interaction simulation), and uses raw socket output technique by default to send packets to the target server (shown by pink arrows in the figure).

The only operation needed on the target server for TCPCopy is setting appropriate route commands to route response packets (shown by green arrows in the figure) to the assistant server.

*intercept* is responsible for passing the response header(by default) to *tcpcopy*. By capturing the reponse packets, *intercept* will extract response header information and send the response header to *tcpcopy* using a special channel(shown by purple arrows in the figure). When *tcpcopy* receives the response header, it utilizes the header information to modify the attributes of online packets and continues to send another packet. It should be noticed that the responses from the target server are routed to the assistant server which should act as a black hole.

##Quick start

Two quick start options are available for *intercept*:

* [Download the latest intercept release](https://github.com/session-replay-tools/intercept/releases).
* Clone the repo: `git clone git://github.com/session-replay-tools/intercept.git`.

Two quick start options are available for *tcpcopy*:

* [Download the latest tcpcopy release](https://github.com/session-replay-tools/tcpcopy/releases).
* Clone the repo: `git clone git://github.com/session-replay-tools/tcpcopy.git`.

##Getting intercept installed on the assistant server
1. cd intercept
2. ./configure
  - choose appropriate configure options if needed
3. make
4. make install

###Configure Options for intercept
    --single            run intercept at non-distributed mode
    --with-pfring=PATH  set path to PF_RING library sources
    --with-debug        compile intercept with debug support (saved in a log file)

##Getting tcpcopy installed on the online server
1. cd tcpcopy
2. ./configure
  - choose appropriate configure options if needed
3. make
4. make install

###Configure Options for tcpcopy
    --offline                   replay TCP streams from the pcap file
    --pcap-capture              capture packets at the data link
    --pcap-send                 send packets at the data link layer instead of the IP layer
    --with-pfring=PATH          set path to PF_RING library sources
    --set-protocol-module=PATH  set tcpcopy to work for an external protocol module
    --single                    if intercept and tcpcopy are both configured with "--single" option,
                                only one tcpcopy works together with intercept,
                                and better performance is achieved.
    --with-debug                compile tcpcopy with debug support (saved in a log file)

##Running TCPCopy
Assume *tcpcopy* and *intercept* are both configured with "./configure".

###1) On the target server which runs server applications:
      Set route commands appropriately to route response packets to the assistant server

      For example:

         Assume <IP_ADDRESS> is the IP address of the assistant server. We set the
         following route command to route all responses to the 62.135.200.x's clients
         to the assistant server.

           route add -net <IP_ADDRESS> netmask <IP_ADDRESS> gw <IP_ADDRESS>

###2) On the assistant server which runs intercept(root privilege is required):

       ./intercept -F <filter> -i <device,>

       Note that the filter format is the same as the pcap filter.
       For example:

          ./intercept -i eth0 -F 'tcp and src port 8080' -d

          intercept will capture response packets of the TCP based application which listens
          on port 8080 from device eth0

###3) On the online source server (root privilege is required):

      ./tcpcopy -x localServerPort-targetServerIP:targetServerPort -s <intercept server,>
      [-c <ip range,>]

      For example(assume <IP_ADDRESS> is the IP address of the target server):

        ./tcpcopy -x 80-<IP_ADDRESS>:8080 -s <IP_ADDRESS> -c 62.135.200.x

        tcpcopy would capture port '80' packets on current server, change client IP address
        to one of 62.135.200.x series, send these packets to the target port '8080' of the
        target server '<IP_ADDRESS>', and connect <IP_ADDRESS> for asking intercept to
        pass response packets to it.

        Although "-c" parameter is optional, it is set here in order to simplify route
        commands.

##Note
1. It is tested on Linux only (kernal 2.6 or above)
2. TCPCopy may lose packets hence lose requests
3. Root privilege is required
4. TCPCopy only supports client-initiated connections now
5. TCPCopy does not support replay for server applications which use SSL/TLS
6. ip_forward should not be set on the assistant server
7. Please execute "./tcpcopy -h" or "./intercept -h" for more details.

##Influential Factors
There are several factors that could influence TCPCopy, which will be introduced in detail in the following sections.

###1. Capture Interface
*tcpcopy* utilizes raw socket input interface by default to capture packets at the network layer on the online server. The system kernel may lose some packets when the system is busy.

If you configure *tcpcopy* with "--pcap-capture", then *tcpcopy* could capture packets at the data link layer and could also filter packets in the kernel. With PF_RING, *tcpcopy* would lose less packets when using pcap capturing.

Maybe the best way to capture requests is to mirror ingress packets by switch and then divide the huge traffic to several machines by load balancer.

###2. Sending Interface
*tcpcopy* utilizes raw socket output interface by default to send packets at the network layer to a target server.
If you want to avoid ip_conntrack problems or get better performance, configure *tcpcopy* with "--pcap-send", then with appropriate parameters *tcpcopy* could send packets at the data link layer to a target server.

###3.On the Way to the Target Server
When a packet is sent by *tcpcopy*, it may encounter many challenges before reaching the target server. As the source IP address in the packet is still the end-user’s IP address(by default) other than the online server’s, some security devices may take it for an invalid or forged packet and drop it. In this case, when you use tcpdump to capture packets on the target server, no packets from the expected end-users will be captured. To know whether you are under such circumstances, you can choose a target server in the same network segment to do a test. If packets could be sent to the target server successfully in the same network segment but unsuccessfully across network segments, your packets may be dropped halfway.

To solve this problem, we suggest deploying *tcpcopy*, *target applications* and *intercept* on servers in the same network segment. There’s also another solution with the help of a proxy in the same network segment. *tcpcopy* could send packets to the proxy and then the proxy would send the corresponding requests to the target server in another network segment.

Note that deploying the target server's application on one virtual machine in the same segment may face the above problems.

####4. OS of the Target Server
The target server may set rpfilter, which would check whether the source IP address in the packet is forged. If yes, the packet will be dropped at the network layer.

If the target server could not receive any requests although packets can be captured by tcpdump on the target server, you should check if you have any corresponding rpfilter settings. If set, you have to remove the related settings to let the packets pass through the network layer.

There are also other reasons that cause *tcpcopy* not working, such as iptables setting problems.

###5. Applications on the Target Server
It is likely that the application on the target server could not process all the requests in time. On the one hand, bugs in the application may make the request not be responded for a long time. On the other hand, some protocols above TCP layer may only process the first request in the socket buffer and leave the remaining requests in the socket buffer unprocessed.

###6. OS of the assistant Server
You should not set ip_forward true or the assistant server can't act as a black hole.

##Release History
+ 2014.09  v1.0    TCPCopy released

##Bugs and feature requests
Have a bug or a feature request? [Please open a new issue](https://github.com/session-replay-tools/tcpcopy/issues). Before opening any issue, please search for existing issues.

## Copyright and license

Copyright 2014 under [the BSD license](LICENSE).

repository: dycforever/sourceReading

repo_name: dycforever/sourceReading


text:
# Catalog of Services Available
[🏠](Home.html)

## Dream Job
This is what I really want to do.

## Rates

### Periodic Rates [https://www1.salary.com/](https://www1.salary.com/)

| Service | On-Site | On-Line | Non-Profit |
| :---    | ---:    | ---:    | ---:       |
| Hourly | $22.00 | $20.00 | $10.00 |
| Daily | $200.00 | $180.00 | $90.00 |
| Weekly | $1,000.00 | $900.00 | $450.00 |
| Annual | $50,000.00 | $45,000.00 | $40,000.00 |

### Lump Some Rates

| Service | Fee |
| :--- | ---: |
| Trademark Logo | $100.00 |
| Single Page Website | $200.00 |
| Small Static Website | $1,000.00 |

### Contract Rates
* Retainer Agreements
  * may purchase one week of time in advance
  * must use the time within one year
  * no refunds
* Lower of Actual Cost or Lump Sum
  * about 10% of contract required for defining contract
  * partial payments scheduled upon completion of benchmark events
  * complete payment due upon completion of project
  * total cost of contract never exceeds the lump sum limit
  * additional charge for change orders at contract rate

* * *
[🏠](Home.html) Copyright © 2018 Clarke Jeniffer


text:
## Crontab

When running online, the project could often to be timed to execute a function. By this time, you need to use crontab to handle. ThinkJS supports command line calls, combined with the system crontab function it can well support crontab.

### Command Line Execution

Besides supporting URL access, ThinkJS also supports command line. The usage is as follows.

```sh
node www/production.js home/index/index
```

The above command means to execute indexAction of `index` Controller in `home` module.

##### With Params

If you need to add some params, just put the corresponceing params in the end. like the following.

```sh
node www/production.js home/index/index?name=thinkjs
```

In Action, you can use method `this.get` to get param `name`.

##### Modify Request Method

In command line executation, the default request type is GET. If you wand to modify it to other type, you can use the following way.

```sh
node www/production.js url=home/index/index&method=post
```

Thus, the request type is changed to post. But in this way, the value of params in url can not include & char (can use / to specify params, as above).

Besides modifying request type, you can also modify the following params.

* `host` modify the request host, default value is <IP_ADDRESS>
* `ip` modify request ip, default value is <IP_ADDRESS>

##### Modify Header

Sometimes, if you want to modify more headers, you can pass a complete json. eg.

```sh
node www/production.js {"url":"/index/index","ip":"<IP_ADDRESS>","method":"POST","headers":{"xxx":"yyyy"}}
```

##### Forbid URL Access

By default, you can access Action that is executed in command line by URL. If forbid URL to access to the Action, you can use `think.cli` to judge. eg.

```js
export default class extends think.controller.base {
  indexAction(){
    // forbid URL access to the Action
    if(!think.cli){
      this.fail('only invoked in cli mode');
    }
    ...
  }
}
```

### Executable Script

You can create a simple executable script to call command line to execute. eg.

```sh
cd project_path;
node www/prodution.js home/index/index;
```

Create the directory `crontab` in the project, and put the above executable script as a file in this directory.

### Timed Execution

Using system crontab can do timed executaion. Use command `crontab -e` to edit crontab. eg.

```sh
0 */1 * * * /bin/sh project_path/crontab/a.sh # execute once per 1 hour
```

### Use node-crontab Module to Execute Crontab

Besides combining crontab with command line, you can also use `node-crontab` module to execute crontab. eg.

```js
import crontab from 'node-crontab';
// execute once per 1 hour
let jobId = crontab.scheduleJob('0 */1 * * *', () => {

});
```

Put the above code file in direcotry `src/common/bootstrap`, thus it can be executed automatically when server startup.


text:
# henk52-kvm-host
Install a KVM host.
kvm-host

This is the kvm-host module.

License
-------

Contact
-------

Support
-------

Please log tickets and issues at our [Projects site](http://projects.example.com)

sudo puppet apply tests/init.pp

virsh pool-list
setlocale: No such file or directory
Name                 State      Autostart
-----------------------------------------
default              active     yes
vg_images            active     yes


text:
### [CVE-2019-15954](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-15954)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

An issue was discovered in Total.js CMS 12.0.0. An authenticated user with the widgets privilege can gain achieve Remote Command Execution (RCE) on the remote server by creating a malicious widget with a special tag containing JavaScript code that will be evaluated server side. In the process of evaluating the tag by the back-end, it is possible to escape the sandbox object by using the following payload: <script total>global.process.mainModule.require(child_process).exec(RCE);</script>

### POC

#### Reference
- http://packetstormsecurity.com/files/154924/Total.js-CMS-12-Widget-JavaScript-Code-Injection.html

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
# Building These Examples

I use `parcel-bundler` for build these projects, so make sure you have that installed.
I like to install it globally:

```npm i -g parcel-bundler```

Change into this directory and just run:

```parcel simple/index.html``` or ```parcel advanced/index.html```

Then go to [`localhost:1234`](localhost:1234) and check it out!

repository: munozu/elm-web-audio

repo_name: munozu/elm-web-audio


text:
# How

## Bugs

If you find a bug that risks destabilizing a project, please:

- File an issue immediately
- Provide a sample repo URL (where possible)
- Provide the state of the working tree (`git status > status.log`) and relevant diffs (`git diff > diff.log`) and attach them inline (within code-block backticks) in the ticket.

## Feature Requests

File an issue with something specific. If it's short enough to fit into an alias, please end the filename with `.alias.txt`.

## Pull Requests

Would you like to improve or add a new script, or convert an existing script in one supported langauge to another?

Pull requests are more than welcome! Thanks in advance :smile:

repository: michaelsanford/git-handy

repo_name: michaelsanford/git-handy


text:
#This is my personal website.

##The goals of this website are as follows:

1) Catalogue and display my past experiences and projects

2) Serve as a platform to get to know me

3) Allow for more open networking with others

4)Be a fun way to experiment with webdev

##Features:

- [x] Experiences Section

- [x] Interests Sections

- [x] Links ot email, github, and linkedin

- [x] Project discriptions and links

- [x] Make multiple pages

- [ ] Make further cusomizations

- [ ] Improve design and make my own assets

- [ ] Add more interactive features to make it a fun browsing experience

- [ ] Highlight projects more


text:
---
# i2ctpl0401evm

---

## Example Summary

Sample application to communicate with the I2C peripherals on a TPL0401EVM
Booster Pack.

## Peripherals Exercised

* `Board_GPIO_LED0` - Indicator LED
* `Board_GPIO_LED1` - Indicator LED
* `Board_I2C_TPL0401` - I2C used to communicate with I2C peripherals on
TPL0401EVM.

## Resources & Jumper Settings

> If you're using an IDE (such as CCS or IAR), please refer to Board.html in
your project directory for resources used and board-specific jumper settings.
Otherwise, you can find Board.html in the directory
<SDK_INSTALL_DIR>/source/ti/boards/<BOARD>.

This example was designed to use the TPL0401 Booster Pack (TPL0401EVM). The
booster pack is required to successfully complete this example.

The I2C GPIO driver on the TPL0401 requires external current sourcing to power
the RGB LEDs.

## Example Usage

* Connect the TPL0401EVM Booster Pack before powering the hardware. You
__must__ connect the 5V pin of your LaunchPad to the 5V header pin on the top
left corner of the TPL0401EVM Booaster Pack.

* Run the example. `Board_GPIO_LED0` turns ON to indicate driver
initialization is complete.

* The TLC59108 will read the color patterns in the rgbcmd variable and toggle
the RGB LEDs ON/OFF. `Board_GPIO_LED1` will turn ON if there has been a problem
with I2C communication.

## Application Design Details

This application uses one thread:

`mainThread` performs the following actions:

1. Opens and initializes an I2C driver object.

2. Uses the I2C driver to initialize the PWM oscillator on the TLC59108 and
set the LED outputs to PWM mode.

3. A RGBCMD structure (contains LED address and individual color values for
Red, Green and Blue) is read from the rgbcmd array and sent via I2C
driver to the TLC59108.

> If the end of the array is reached, the index is reset to 0 and the thread
sleeps for 100 milliseconds before starting the next iteration.

TI-RTOS:

* When building in Code Composer Studio, the kernel configuration project will
be imported along with the example. The kernel configuration project is
referenced by the example, so it will be built first. The "release" kernel
configuration is the default project used. It has many debug features disabled.
These feature include assert checking, logging and runtime stack checks. For a
detailed difference between the "release" and "debug" kernel configurations and
how to switch between them, please refer to the SimpleLink MCU SDK User's
Guide. The "release" and "debug" kernel configuration projects can be found
under <SDK_INSTALL_DIR>/kernel/tirtos/builds/<BOARD>/(release|debug)/(ccs|gcc).

FreeRTOS:

* Please view the `FreeRTOSConfig.h` header file for example configuration
information.


text:
A toy Node.js+browser app I made for a homework assignment at coding boot camp, [Prime Digital Academy](https://primeacademy.io/) in Minneapolis Minnesota.

[![build status badge](https://github.com/carnesen/reveal-me/workflows/test/badge.svg)](https://github.com/carnesen/reveal-me/actions?query=workflow%3Atest+branch%3Amaster)

Deployed on the web at [https://reveal-me.carnesen.com/](https://reveal-me.carnesen.com/).

## Developer setup

To run this project on your development host:
- Install [Node.js](https://nodejs.org/) if you haven't already
- `git clone` this repository
- `cd` into the repository and run `npm install` and `npm start`
- - Visit [http://localhost:3000](http://localhost:3000) in a browser

## [Releases](https://github.com/carnesen/reveal-me/releases)

This project uses [calendar versioning](https://en.wikipedia.org/wiki/Software_versioning#Date_of_release) with format YYYY.M.#.

## Related

- [@carnesen/carnesen-dot-com](https://github.com/carnesen/carnesen-dot-com): Automates deployment of carnesen.com sites like [https://mathjs.carnesen.com/](https://mathjs.carnesen.com/) using Google Cloud Platform

## License

MIT © [Chris Arnesen](https://www.carnesen.com)

repository: carnesen/reveal-me

gha_language: JavaScript

repo_name: carnesen/reveal-me


text:
    Adskip Extension - click simulators to skip ads on sites that restrict use of script-level video blockers

## Installation
1. Clone the repository `git clone https://github.com/magicgrl111/adskip-extension.git`
2. Run `npm install`
3. Run `npm run build`

##### Load the extension in Chrome & Opera
1. Open Chrome/Opera browser and navigate to chrome://extensions
2. Select "Developer Mode" and then click "Load unpacked extension..."
3. From the file browser, choose to `adskip-extension/build/chrome` or (`adskip-extension/build/opera`)

##### Load the extension in Firefox
1. Open Firefox browser and navigate to about:debugging
2. Click "Load Temporary Add-on" and from the file browser, choose `adskip-extension/build/firefox`

## Developing
The following tasks can be used when you want to start developing the extension and want to enable live reload -

- `npm run chrome-watch`
- `npm run opera-watch`
- `npm run firefox-watch`

## Packaging
Run `npm run dist` to create a zipped, production-ready extension for each browser.

-----------
This project is licensed under the MIT license.

repository: runthee/adskip-extension

repo_name: runthee/adskip-extension


text:
# Data

Details are included here of how the data that powers the products site is stored and updated.

## Overview

The main data used by the products site relates predominantly to 3 types of document:

- Summaries of Product Characteristics (SPC)
- Patient Information Leaflet (PIL)
- Public Assessment Report (PAR)

Documents, their metadata and their contents are searchable and can be accessed and opened through the site.

Consider checking out the [architecture of the site](../architecture#progress) and the [configuration files](../../../infrastructure/) to create these resources for each environment.

## Storage

### Products

All SPC, PIL and PAR files are stored as blobs in an Azure blob container along with associated metadata fields, including:

- Substance name - e.g. "CLOPIDOGREL BESILATE"
- Doc type - e.g. “SPC”
- Facets - key words, e.g. “CLOPIDOGREL BESILATE”
- Product name - e.g. “CADIX 75MG FILM-COATED TABLETS”
- File name - original name of the file, e.g. “CON1552021698726”
- PL number - e.g. "PL403780095"
- Title - title of the document, e.g. “spc-doc_PL 40378-0095”
- Date created - upload date of document, e.g. “2019-03-08T05:08:00+00:00”
- Release state - whether the document is released, e.g. “Y”
- Revision label - version number of the file, e.g. “2”
  This index is defined in [code](https://github.com/MHRA/products/blob/master/medicines/search/src/index.rs).

Each file is stored as a blob with a name that is a hash of the file contents, e.g. `000f6ec9a52b3230d5f880e55fb33a405a1c83d3` and has a unique URI through which it can be accessed.

### BMGF

All BMGF files are also stored as blobs in an Azure blob container, both in PDF format (to which the following metadata is attached) and HTML format (for the creation of accessible web content):

- report_name - the name of the report, e.g. "Study on the effects of Ibuprofen"
- file_name - the name of both the PDF and HTML files, e.g. "Ibuprofen report"
- summary - a short summary of the report that will be shown on the website, e.g. "A study into the effects of..."
- active_substances - any active substances associated with the report, stored as an array, e.g. ["IBUPROFEN", "PARACETAMOL"]
- products - any products associated with the report, stored as an array, e.g. ["IBUPROFEN TABLETS", "IBUPROFEN GEL"]
- pl_numbers - any product licence numbers associated with the report, stored as an array, e.g. ["PL123451234", "PL234562345"]
- pbpk_models - any PBPK models associated with the report, stored as an array
- pregnancy_trimesters - any specific pregnancy trimesters associated with the report, stored as an array, e.g. ["first", "second"]
- matrices - any matrices associated with the report, stored as an array
- facets - calculated from the active substances, used to drive hierarchical navigation on the products site, e.g. ["I", "I, IBUPROFEN", "P", "P, PARACETAMOL"]

## Updates

SPC and PIL files are updated on a weekly basis, as the result of the batch process run on the Sentinel server. Currently, all resultant files and their metadata are manually copied and uploaded to a new container after each batch update, but this is moving towards an automatic and incremental update.

PAR files are updated on a weekly basis, as the result of a manual upload process to Sharepoint. New PAR files are uploaded and a spreadsheet is updated with a new line, containing the associated metadata.

The importer within this repository processes these files and metadata, matching the file name with the “file name” field in the metadata row and then attaching the metadata to each file, before uploading it to Azure blob storage.

## Search

Each file is discoverable through the search functionality of the products site. In order to achieve this, the Azure search service is used. There are three main parts to this service:

- Index - like a table, this has defined fields and stores a big list of entries for everything that is searchable through the service. Search results are returned from here
- Indexer - this runs periodically and fills the index with searchable entries
- Data source - this is used by the indexer to define a searchable source of data. In the case of the products site, this is the Azure blob container that holds all of the files.

Every time the contents of the blob container are updated, the indexer must run over the container again in order for these changes to be reflected in the search index.

The search mode used currently is of the "any" type, in which multiple search terms and used in an "or" fashion - a search for "ibuprofen gel" will return results for both "ibuprofen" and "gel", with matches that contain both terms appearing higher.

## Retention

Files will be retained and stored in the blob container indefinitely.

Files that should no longer be indexed and displayed on the site will be soft deleted - tagged with an "is_deleted" flag, which causes the indexer to remove them from the index.

## Security

Read-only access to the individual blob files is available to anyone who has the file’s URI, which is surfaced through the search service.

The ability to update files is restricted, only open to those with privileged access to the Azure account. Similarly, any updates to the index can only be carried out by authorised users.

## Data sensitivity

No restricted or customer-sensitive data is used on the site.

## Availability

Azure blob containers used in this project are configured to be of type RAGRS (Read-access Geo-redundant Storage), with a level of availability over a given year of 99.99999999999999% (16 9's), [as documented](https://docs.microsoft.com/en-us/azure/storage/common/storage-redundancy-grs#read-access-geo-redundant-storage).

## Redundancy and recovery

The contents of [RAGRS Azure blob containers](https://docs.microsoft.com/en-us/azure/storage/common/storage-redundancy-grs#read-access-geo-redundant-storage) are automatically replicated to a second region, so that in the case of failure or lack of availability of the primary, data can be copied over or directly read from the secondary.

## Analytics

Google Analytics is used on the site in order to track site usage and inform future improvements. Analytics are only collected for users who opt in to the cookie policy that is displayed on the site.

repository: MHRA/products

gha_language: Rust

repo_name: MHRA/products


text:
# Golang HTTP Echo Server

The dumbest HTTP server you can find. Send a request and have it echoed back to you.

## Usage

```go
go run echoserver.go
```

Then point your browser to [http://localhost:8080](http://localhost:8080).

The port will be set to `8080` by default. If you want to run the server on another port, pass it using the `PORT` environment variable or as a parameter:

```go
go run echoserver.go 8090
```

## Docker

Follow the instructions below to _dockerize_ the server.

### Build image

```bash
docker build -t go-http-echo-server .
```

If you don't want to use the default port (`8080`), make sure you change that in the Dockerfile before building the image.

### Run container

```bash
docker run -d -p 8080:8080 go-http-echo-server
```

## Kubernetes

Run the bash script to push the image into a registry (`localhost:32000` by default) and deploy it to Kubernetes.

```bash
./deploy.sh
```

Or use the existing Docker image:

```bash
IMAGE=docker.pkg.github.com/gysel/go-http-echo-server/http-echo-server
kubectl create deployment echo-server --image=$IMAGE
kubectl expose deployment echo-server --port=80 --target-port=8080
```

Please note that GitHub requires you to log in even when the image is public.
(See https://github.community/t5/GitHub-Actions/docker-pull-from-public-GitHub-Package-Registry-fail-with-quot/td-p/32782)

repository: gysel/go-http-echo-server

repo_name: gysel/go-http-echo-server


text:
# Example of pandoc's power

This folder contains a research paper that mixes markdown syntax and LaTex.
The main idea was to move everything from LaTex to markdown but, due to lack
of time, I have fixed the parts that I considered more difficult and the others
can be worked out in the same way. For example, I have cross-referenced sections.
You can cross-reference figures and tables in the same way, although I have
not done those two.

# Structure

The `Makefile` compiles the markdown `main.md` file into `main.pdf`.

To separate concerns, we use the `meta.yaml` and the `main.md`.
`meta.yaml` contains meta-information such as, authors, format of the paper, etc.
`main.md` contains the information written in the paper.

With this simple separation, one creates a separation of concerns and can focus
on one thing at a time. If you would like to create an ePub version, you would
simply have to create a new `epub.yaml` file, add the required fields and
update the `Makefile` to create an ePub, instead of a PDF.


text:
# Aggregations

Aggregations allow you to describe your result set by generating counts and sets

Check out [buckets](https://github.com/fergiemcdowall/search-index/blob/0.9.0/doc/API.md#buckets)
and [categorize](https://github.com/fergiemcdowall/search-index/blob/0.9.0/doc/API.md#categorize) in the API


text:
# Installation
> `npm install --save @types/less-middleware`

# Summary
This package contains type definitions for less-middleware (https://github.com/emberfeather/less.js-middleware).

# Details
Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/less-middleware

Additional Details
 * Last updated: Wed, 25 Oct 2017 18:38:02 GMT
 * Dependencies: express
 * Global values: none

# Credits
These definitions were written by Federico Bond <https://github.com/federicobond>.

repository: C-Alexander/spaceServerNode

repo_name: C-Alexander/spaceServerNode


text:
Welcome to FastGram 👋

A website for people that belive that looking at Instagram is slow

## How to use?

### Head over to https://y3ll0wlife.github.io/FastGram/

### Press the hamburger icon to bring up the settings![img](https://i.gyazo.com/3327577a6d95a849718937fe23b27024.png)

### The first tab is were you add the people you want to find (NOTE: the account cannot be private for this to work) so just write the username and then press "Add user"![img](https://i.gyazo.com/7e1e0dc68fffa7d35a39b386b4514c3f.png)

### The next part is were you remove all the list of people you are getting imges from (will update in the future so you can select individual people) ![img](https://i.gyazo.com/c4dc0c6a9a6feb2b5b6ee2d70bbef517.png)

### These are the people you are currently watching (in this case "instagram" and "nike") ![img](https://i.gyazo.com/30b8f9b8b1466af159ed06fa1bb3fa1d.png)

### You can use this slider to select of many images that the website should show (max 10) ![img](https://i.gyazo.com/2826de70ae953196036a211c948e7c79.png)

### Lastly we have the "Get images" button press it! ![img](https://i.gyazo.com/b0eefa675a2fd138ab55819726f0947d.png)

![img](https://i.gyazo.com/fe4ad1cdb87d8173ad08122a24e68c63.jpg)

## Author

👤 **y3ll0w**

- Twitter: [@y3ll0wLife](https://twitter.com/y3ll0wLife)
- Github: [y3ll0wlife](https://github.com/y3ll0wlife)

## Show your support

Give a ⭐ if this project helped you!

## 📝 License

Copyright © 2020 y3ll0wlife
This project is [MIT](https://github.com/y3ll0wlife/FastGram/blob/master/LICENSE) licensed.


text:
# SimpleRichText

## Desc
SimpleRichText is a simple rich text plugin for Unity3D, based on UGUI or NGUI (you can implement custom rich text mode).
Both UGUI and NGUI support basic rich text formats, but they are limited, this plugin is aim to enhance their rich
text ability (still you can get rid of UGUI or NGUI by implementing your own custom rich text mode)

## Usage
Usage is simple :

- first you need to init rich text : RichTextManager.Init(RichTextManager.Mode.UGUI);

- then you could add rich elements to rich text by RichText.AddRichElement method,
   and then call RichText.Format

- for simple useage, we could create a rich text syntax string to build rich text by
   using RichTextManager.ParseRichSyntax method

**Please check example scenes under [ProjectRoot]/Scenes : test_rich_text_ugui and test_rich_text_ngui**

## Notice
We do not support **NGUI** mode by default, you can enable it by adding **RICH_TEXT_ENABLE_NGUI** macro symbol.

## Screenshot

![screenshot from test_rich_text_ugui](https://github.com/tkokof/SimpleRichText/blob/master/Info.png)

repository: kerwinzxc/SimpleRichText

repo_name: kerwinzxc/SimpleRichText


text:
### [CVE-2018-19445](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-19445)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

A command injection can occur for specially crafted PDF files in Foxit Reader SDK (ActiveX) Professional <IP_ADDRESS>1 when the JavaScript API app.launchURL is used. An attacker can leverage this to gain remote code execution.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/0xCyberY/CVE-T4PDF
- https://github.com/ARPSyndicate/cvemon


text:
# Manorrock Oyena

Manorrock Oyena delivers you with several add-on modules that you can use with
Eclipse Mojarra.

See the list below for the add-on modules that are available.

1. [Action framework add-on](action/README.md)
2. [CDI add-on](cdi/README.md)
2. [REST add-on](rest/README.md)

Note the documentation for the master branch might show features that are NOT
yet available as it is under active development. Please see the documentation
for the release you are using in the links below.

## Documentation for older releases

1. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
2. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
3. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
4. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
5. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
6. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
7. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>), adds REST add-on
8. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>), adds CDI add-on
9. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
10. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>), first release on Maven central
11. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>)
12. [Version <IP_ADDRESS>](https://github.com/manorrock/oyena/tree/v<IP_ADDRESS>), first release

## How do I contribute?

See [Contributing](CONTRIBUTING.md)

## Our code of Conduct

See [Code of Conduct](CODE_OF_CONDUCT.md)

repository: smhjamalii/oyena

repo_name: smhjamalii/oyena


text:
# Dice-Game

This is a Dice game where the goal is to be first to reach score in input filed or to reach 100.

Its build with pure JS ES6 and compiled with Webpack

You can play it here:

https://sekenikola.com/dicegame/

[![Website shields.io](https://img.shields.io/website-up-down-green-red/http/shields.io.svg)](http://shields.io/)
[![made-with-VSCode](https://img.shields.io/badge/Made%20with-VSCode-1f425f.svg)](https://code.visualstudio.com/)
[![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)
[![Open Source Love svg1](https://badges.frapsoft.com/os/v1/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badges/)
[![Javascript](https://badges.frapsoft.com/javascript/code/javascript.svg?v=101)](https://github.com/ellerbrock/javascript-badges/)

repository: SekeNikola/Dice-Game

repo_name: SekeNikola/Dice-Game


text:
# A Summoner's Tale

## Brief Description

'A Summoner's Tale' is a game based on Pokemon. Players take control of a 'Summoner', a magic wielder that can bend the will of elementals to that of their own, and wage war against other summoners.

## In Depth Description

A Summoner's Tale takes place on a fictional planet named **Gaia**. Gaia is mainly inhabited by humans, although they share the planet with a plethora of magical creatures. Many thousands of years ago, the first summoner was born. His true identity is lost to the ages, the summoners of today simply refer to him as **The Originator**. The Originator founded the **Order of Summoners**, a group dedicated to the protection of Gaia's denizens.

A Summoner is a human that was born with the innate ability to sense and control the six elements: **Light**, **Dark**, **Fire**, **Water**, **Earth** and **Air**. Each element has its own characteristics, strengths and weaknesses. A summoner usually has their own preference, having an affinity with one of the elements. It is not known how the summoner gains an affinity for one of the elements, however several popular theories attest that it is based on the Summoner's subconscious being. That is, who the Summoner really is within.

## Elements

### Light
#### Strengths
Strong against dark elementals

repository: Blindside-Games/ASummonersTale

path: /Documents/Design Document.md

filename: Design Document.md

repo_name: Blindside-Games/ASummonersTale


text:
# Voxuoso
A laryngitis mobile detection app, which will use LSTM-RNN and Acoustic Voice Quality Index (AVQI).

## About
This is a ReactNative mobile application served over Flask microframework.

## Requirements
**Backend requirements**
* Python: 2.7
* See [virtual_requirements.txt](https://github.com/entt/Voxuoso/blob/master/backend/virtual_requirements.txt)

**Frontend**
* NodeJS: 6.11.4
* NPM: 3.10.10
* Exp: 46.0.3
* Expo SDK: 24.00
* React: 16.1.1
* ReactNative: 0.50.3

## Build Guide
```
# For frontend
cd frontend
npm install

# For backend
cd ../backend
virtualenv -p python venv
source venv/bin/activate
pip install -r requirements
```

## Running the App
```
# For frontend
cd frontend

# Hot reload, use Expo client to scan QR code
exp start

# If you have a connected Android device use,
# Note: Hot-reload
exp android

# For backend
cd ../backend
export FLASK_APP=app.py
flask app

# Alternatively,
python app.py
```

repository: entt/Voxuoso

repo_name: entt/Voxuoso