text:
# Nginx Ingress Controller

This is a simple nginx Ingress controller. Expect it to grow up. See [Ingress controller documentation](../README.md) for details on how it works.

This version includes SSL support, integrated with HashiCorp Vault and access and error logs, which go to the container stdout/stderr by default.

## Installation

```
go build controller.go && docker rmi devlm/nginx-ingress:latest; docker build -t devlm/nginx-ingress:latest . && docker push devlm/nginx-ingress:latest
```

replacing devlm/nginx-ingress with a repo of your choice. There is a pre-built container at devlm/nginx-ingress on docker hub if required.

Access to Vault is predicated on the following:

Vault is running in the local environment.

A valid access token is available at the following location:

/etc/vault-token/ingress-read-only

An example for creating this as a kubernetes secret is shown below.

```yaml
apiVersion: v1
kind: Secret
metadata:
  namespace: kube-system
  name: ingress-read-only
data:
  ingress-read-only: %%TOKEN%%
```

where %%TOKEN%% is an access token for a policy with read access to secret/ssl in Vault:

```yaml
# For Ingress controller- ssl key access
path "sys/*" {
  policy = "deny"
}

path "secret/ssl/*" {
  policy = "read"
}
```
You may also pass in an alternative file as an env var $VAULT_TOKEN_FILE, or pass in the TOKEN directly as $VAULT_TOKEN. The controller self-renews this token every 10 minutes.

The key contents themselves should already have been written to Vault as follows:

Key: secrets/ssl/<hostname> crt and key

where "crt" contains the x509 public certificate and key contains the x509 private key.

```
vault write www.example.com key="-----BEGIN PRIVATE KEY-----..." crt="-----BEGIN CERTIFICATE-----..."
```

## Deploying the controller

Deploying the controller is as easy as creating the RC in this directory. Having done so you can test it with the following echoheaders application:

```yaml
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  namespace: kube-system
  name: nginx-ingress
spec:
 template:
    metadata:
      labels:
        name: nginx-ingress
    spec:
      hostNetwork: true
      nodeSelector:
        role: loadbalancer
      containers:
      - image: devlm/nginx-ingress:1.7.0
        resources:
            limits:
              cpu: "${INGRESS_CPU}"
              memory: ${INGRESS_RAM}
        imagePullPolicy: Always
        name: nginx-ingress
        env:
          - name: "VAULT_ADDR"
            value: "https://vault.kube-system.svc.cluster.local:8243"
          - name: "VAULT_TOKEN_FILE"
            value: "/etc/vault-token/ingress-read-only"
          - name: "VAULT_SSL_SIGNER"
            value: >
                   "-----BEGIN CERTIFICATE-----
                    ....
                    -----END CERTIFICATE-----"
        ports:
        - containerPort: 80
          hostPort: 80
        - containerPort: 443
          hostPort: 443
        volumeMounts:
          - name: vault-volume
            mountPath: /etc/vault-token
      volumes:
        - name: vault-volume
          secret:
              secretName: ingress-read-only

```

Note the secret volume setup and `VAULT_` environment variables.

## Deploying an ingress:

```yaml
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: example
  namespace: some-namespace
  labels:
    ssl: true
    httpsOnly: false
    httpsBackend: true
spec:
  rules:
  - host: www.example.com
    http:
      paths:
      - backend:
          serviceName: example
          servicePort: 8043
        path: /
```
You should be able to access the Services on the public IP of the node the nginx pod lands on.

Note the `ssl: true` label.

The other (optional) labels available are:

`httpsOnly` Do not create a http listener
`httpsBackend` Use https for the proxy connection to the backend
`timeout` A configurable override of the backend timeout (default 60s)

The ingress controller will detect that this has been created and react as follows:

```
Found secret for www.example.com
Found key for www.example.com
Found crt for www.example.com
Keypair correct for www.example.com
Service address responding for www.example.com
Starting nginx [-c /etc/nginx/nginx.conf]
nginx config updated.
```
You should now be able to point www.example.com at the Ingress nodes and reach www.example.com over http:// and https://.

Validation:

The ingress will NOT be created if:
The keypair created by the key and crt values is not valid.
The backend service does not respond at https://example.some-namespace.svc.cluster.local:8043 with a 200.

However it will keep trying.

If either VAULT_ADDR or VAULT_TOKEN are not set then vault support is disabled and the controller should act like nginx-alpha, with the addition of access and err logging from the nginx instance to stdout/err on the container.

repository: oyvindio/contrib

repo_name: oyvindio/contrib


text:
---
title: "Testing Hybrid Mobile Apps using Live Sync"
id: "testing-hybrid-mobile-apps-using-live-sync"
sidebar_label: "Test via Live Sync"
---
---

Live Sync is a feature that brings App UI changes in Studio to the mobile app without needing a new build. This reduces the number of mobile builds required, tremendously saving developers time.

## Configuring Live Sync

1. Open the **Export as Cordova zip** dialog.
2. Select server path as **dev** and profile as **development**.

![](/learn/assets/live-sync/cordova-export.png)

3. Click the **Build** button.
4. Download the Cordova zip and run a mobile build using **wm-cordova-cli** or **AppChef**.
5. Download and install the app on mobile and open the app.

The following popup displays. This popup displays after every app restart.

![](/learn/assets/live-sync/live-sync-screen-confirmation.png)

### Enabling Live Sync

You can see the **Live Sync** button at the bottom right corner. To switch on Live Sync, press the **Yes** button.

![](/learn/assets/live-sync/live-sync-screen-refresh.png)

### Disabling Live Sync

If you do not need the Live Sync option, simply press **No**.

:::note
If you wish to enable Live Sync later, you can either restart the app or press and hold anywhere for 5 seconds, and the screen should show the Live Sync Popup again.
:::

![](/learn/assets/live-sync/live-sync-screen-info.png)

## Understanding Live Sync

- Whenever a UI change is made in Studio, press the Live Sync button to refresh the app with the latest changes.

![](/learn/assets/live-sync/live-sync-screen-refresh.png)

- Except for offline functionality, the rest of the functionalities should work as they do.
- Whenever plugins are added in WaveMaker Studio, a new build is required to add the plugin into the app to function. When Live Sync observes plugin addition, you will notice the following warnings, and it is recommended to have a new build when such warning is shown.

:::note
When a device variable or widget is added, plugins required for that variable or widget are added automatically.
:::

- Third-party plugins are supported.
- You can debug the app as usual.

## Limitations

- Offline functionality is not supported.

repository: wavemaker/docs

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

license_type: permissive

repo_name: wavemaker/docs


text:
# BamStats05

Coverage statistics for a BED file, group by gene

## Usage

```
Usage: bamstats05 [options] Files
  Options:
  * -B, --bed
      bed file (columns: chrom start end GENE)
    -f, --filter
      A filter expression. Reads matching the expression will be filtered-out.
      Empty String means 'filter out nothing/Accept all'. See https://github.com/lindenb/jvarkit/blob/master/src/main/resources/javacc/com/github/lindenb/jvarkit/util/bio/samfilter/SamFilterParser.jj
      for a complete syntax.
      Default: mapqlt(1) || MapQUnavailable() || Duplicate() || FailsVendorQuality() || NotPrimaryAlignment() || SupplementaryAlignment()
    --groupby
      Group Reads by
      Default: sample
      Possible Values: [readgroup, sample, library, platform, center, sample_by_platform, sample_by_center, sample_by_platform_by_center, any]
    -h, --help
      print help and exit
    --helpFormat
      What kind of help
      Possible Values: [usage, markdown, xml]
    -m, --mincoverage
      min coverage to say the position is not covered
      Default: 0
    -o, --output
      Output file. Optional . Default: stdout
    --version
      print version and exit

```

## Keywords

 * bam
 * coverage
 * statistics
 * bed

## Compilation

### Requirements / Dependencies

* java [compiler SDK 1.8](http://www.oracle.com/technetwork/java/index.html) (**NOT the old java 1.7 or 1.6**) and avoid OpenJdk, use the java from Oracle. Please check that this java is in the `${PATH}`. Setting JAVA_HOME is not enough : (e.g: https://github.com/lindenb/jvarkit/issues/23 )
* GNU Make >= 3.81
* curl/wget
* git
* xsltproc http://xmlsoft.org/XSLT/xsltproc2.html (tested with "libxml 20706, libxslt 10126 and libexslt 815")

### Download and Compile

```bash
$ git clone "https://github.com/lindenb/jvarkit.git"
$ cd jvarkit
$ make bamstats05
```

The *.jar libraries are not included in the main jar file, [so you shouldn't move them](https://github.com/lindenb/jvarkit/issues/15#issuecomment-140099011 ).
The required libraries will be downloaded and installed in the `dist` directory.

Experimental: you can also create a [fat jar](https://stackoverflow.com/questions/19150811/) which contains classes from all the libraries, on which your project depends (it's bigger). Those fat-jar are generated by adding `standalone=yes` to the gnu make command, for example ` make bamstats05 standalone=yes`.

### edit 'local.mk' (optional)

The a file **local.mk** can be created edited to override/add some definitions.

For example it can be used to set the HTTP proxy:

```
http.proxy.host=your.host.com
http.proxy.port=124567
```
## Source code

[https://github.com/lindenb/jvarkit/tree/master/src/main/java/com/github/lindenb/jvarkit/tools/bamstats04/BamStats05.java](https://github.com/lindenb/jvarkit/tree/master/src/main/java/com/github/lindenb/jvarkit/tools/bamstats04/BamStats05.java)

<details>
<summary>Git History</summary>

```
Tue Jun 20 15:07:17 2017 +0200 ; cont ; https://github.com/lindenb/jvarkit/commit/8e712ff2b8d4b73d71cd2035cfac57381d3e9d4b
Wed May 24 17:27:28 2017 +0200 ; lowres bam2raster & fix doc ; https://github.com/lindenb/jvarkit/commit/6edcfd661827927b541e7267195c762e916482a0
Sat Apr 29 18:45:47 2017 +0200 ; partition ; https://github.com/lindenb/jvarkit/commit/7d72633d50ee333fcad0eca8aaa8eec1a475cc4d
Fri Apr 7 16:35:31 2017 +0200 ; cont ; https://github.com/lindenb/jvarkit/commit/54c5a476e62e021ad18e7fd0d84bf9e5396c8c96
Wed Oct 5 21:00:52 2016 +0200 ; fix https://github.com/lindenb/jvarkit/issues/66 ; https://github.com/lindenb/jvarkit/commit/abee996272e161088c4fd81d4c4d36ad8c5e9f5d
Mon May 30 09:56:31 2016 +0200 ; cont ; https://github.com/lindenb/jvarkit/commit/e7b2fe070bf124c8b71611d621a2efb4d0fab90a
Thu Nov 26 17:41:15 2015 +0100 ; cont ; https://github.com/lindenb/jvarkit/commit/899c60335614350d463be66ec21e994b34dc55be
Mon Nov 16 12:21:53 2015 +0100 ; blastfilterjs ; https://github.com/lindenb/jvarkit/commit/6b885d465b47f339d323f909c2ae7a88641f08a4
Tue Oct 13 15:46:31 2015 +0200 ; bamstats05 ; https://github.com/lindenb/jvarkit/commit/e6b4b771f21e6973664c336243c814b2342a9cc4
Mon Oct 12 17:40:15 2015 +0200 ; bamstats05 ; https://github.com/lindenb/jvarkit/commit/a68434654d5917076bee6d76c38c4c4555ce4f0f
```

</details>

## Contribute

- Issue Tracker: [http://github.com/lindenb/jvarkit/issues](http://github.com/lindenb/jvarkit/issues)
- Source Code: [http://github.com/lindenb/jvarkit](http://github.com/lindenb/jvarkit)

## License

The project is licensed under the MIT license.

## Citing

Should you cite **bamstats05** ? [https://github.com/mr-c/shouldacite/blob/master/should-I-cite-this-software.md](https://github.com/mr-c/shouldacite/blob/master/should-I-cite-this-software.md)

The current reference is:

[http://dx.doi.org/10.6084/m9.figshare.1425030](http://dx.doi.org/10.6084/m9.figshare.1425030)

> Lindenbaum, Pierre (2015): JVarkit: java-based utilities for Bioinformatics. figshare.
> [http://dx.doi.org/10.6084/m9.figshare.1425030](http://dx.doi.org/10.6084/m9.figshare.1425030)

## Example

```

$ head genes.bed
1	179655424	179655582	ZORG
1	179656788	179656934	ZORG

$ java -jar  dist/bamstats05.jar -B genes.bed --mincoverage 10  > out.txt

$ head out.txt
#chrom	start	end	gene	sample	length	mincov	maxcov	avg	nocoverage.bp	percentcovered
1	179655424	179656934	ZORG	SAMPLE1	304	27	405<PHONE_NUMBER>2631578	0	100

```

license: MIT

repository: jiaolongsun/jvarkit

repo_name: jiaolongsun/jvarkit


text:
# Cats Who Code

Instragram like feed but of cats or kittens who either are coding, or think they're coding. Used for learning Docker and AWS.

## System Requirements

- Docker for Mac/Widows (if you're on Linux, you'll know what to do).
- Make.

## To get the app running in a development environment

**1.** Go into the `app` directory and rename `app.env.dev-example` to `app.env`.

**NOTE**: If you are running this on a Virtual Machine and not locally using Docker for Desktop, you will need to uncomment the `AWS_S3_CUSTOM_DOMAIN` line, entering the host name of your VM.

**2.** Then build the containers and run the application in development (files mounted in the container) mode.

    make app-dev-start

**3.** Then once the containers are running, go to the docs site at http://localhost:3000/run-app-locally/ to learn how to complete the application setup process.

## To get the app running in a production environment

There are a lot of ways to run this in production, but for a simple case, where you want to build and run the containers using Docker Compose.

**1.** Go into the `app` directory and rename `app.env.production-example` to `app.env`. Then tweak the variables based on your RDS, ElastiCache and S3 bucket settings.

**2.** In the project root, build the front-end and API containers locally by running:

    make build

IDeally, these would be pulled from a remote Docker Registry.

**3.** Bring up the front-end and API containers by running:

    make app-start

repository: ryan-blunden/cats-who-code

gha_language: Python

repo_name: ryan-blunden/cats-who-code


text:
The client package provides commands for network access

## Installation
See the Installation in [need-some-init.bash](https://github.com/need-some/need-some-init.bash "need-some-init.bash")

## Syntax

### wcat
get resource from the internet, and print to stdout

	wcat [--no-check-certificate] [--useragent string] url


text:
# EduAnsa

EduAnsa is a static website developed as a go-to resource for students.

Even though EduAnsa is a static website, it is build with reusable HTML components (partial HTML files) to avoid HTML duplications. These partial HTML files are combined together using the `Apache server INCLUDE` statement written in the `.htaccess` file.

```html
<body>
  <div id="container">
    <!--#include virtual="include/header.html" -->
    <main>
      <article>
        <!--#include virtual="include/author-bio.html" -->
        <!--#include virtual="include/right-sidebar.html" -->
      </article>
    </main>
    <!--#include virtual="include/footer.html" -->
  </div>
  <script src="js/main.js"></script>
</body>
```

## Tech Stack

- [x] HTML
- [x] CSS (SCSS)
- [x] Vanilla JavaScript

## Sample Pages

![include](client/assets/docs/home-page.PNG)

_Sample Home Page_

![include](client/assets/docs/blog-list.PNG)

_Blog Page_

repository: bloggrammer/Edu-Ansa

branch_name: refs/heads/main

repo_name: bloggrammer/Edu-Ansa


text:
# Deploying Heracles

> Feel free to just read this site, but if you want to deploy, the best thing its to [fork this repo](https://docs.github.com/en/free-pro-team@latest/github/getting-started-with-github/fork-a-repo). Once forked, go to your copy.  Click on actions.  If you are asked click on “I Understand my workflows, go ahead and enable them”. You may need to correct a few things (such as the workflow status badges in the main readme.md).

Deploying Heracles is easy.  Follow these simple steps:

## Create a Service Principal for GitHub Actions
The actions in this repo create all the resources necessary to run the TimeHelper application in a new resource group in one of your subscription.  In order to do that we need Azure credentials with contributor rights to the subscription where you will host. Run the following command in Azure CLI and copy the resultant json output to your clipboard

`az ad sp create-for-rbac --name "myApp" --role contributor --scopes /subscriptions/{subscription-id} --sdk-auth`

Then create GitHub secret called AZURE_CREDENTIALS and paste the json content generated above into the value field for the secret. [see here for more details](https://github.com/Azure/login#configure-deployment-credentials)

## Create Other GitHub Secrets

There are a couple of other secrets you need to define in GitHub:

### Database Admin Password

DB_ADMIN_PASSWORD=***************
This is simply the password that will be used to administer the Azure SQL Database that gets created.  Its highly unlikely you'll need to use it, but make a note of the value you choose.  It should really be 12 characters alphameric or longer.

### GitHub Personal Access Token
HERACLES_PAT=********************************
This is a Personal Access Token to allow the GitHub actions to access your repo.  This is needed to enable the main infrastructure deployment workflow to kick off deployments of the applications once it has completed normally.  Follow the instructions for [creating a GitHub PAT](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token#:~:text=Creating%20a%20token.%201%20Verify%20your%20email%20address%2C,able%20to%20see%20the%20token%20again.%20More%20items), ensure you grant the public_repo scope and then store the value of the generated PAT as a secret.

> I dont think you actually need this.  I think instead you can directly reference ${{ secrets.GITHUB_TOKEN }} but I didn't have time to test it yet.

## Initiate Deployment

To initiate the deployment, choose the *Actions* tab at the top of the repo screen.  In the list of workflows, choose *Deploy Heracles* and on the right choose *Run Workflow*.  An invite screen will appear to capture parameters for this deployment:

Fill out the the parameters as follows:

### Application alias
The application alias is important. IT is used as a stem when naming the Azure resources that will be created. Choose something unique, it should be about 6 characters in length, and lower case alphameric.  For the demo instance I chose 'herc'.
> This will be used as part of the storage account names - which have very rigorous constraints - hence the need for lower case.

### Location
The Azure location where the resources will be deployed.  uksouth, ukwest, northeurope or any other valid Azure data centre.

### Instance Name
The instance name is stored as a tag against all resource groups.  It's important for me where I have multiple instances of the application deployed, and it let's me work with groups of resources together.  If you only plan on deploying once, leaving the Instance Name as Lucky_Jim would be fine.

### debug output?
Leave set to False.

### pending delete?
Set to False.

# Watch the Deployment Video

There is a short (6 minute) video that shows the deployment in action:

[![link to deployment video](../images/xdeployment-video-screenshot.jpg)](https://hercheracles29790.blob.core.windows.net/media/heracles-ai-deploy.mp4)

repository: nikkh/heracles-ai

gha_language: C#

gha_license_id: MIT

repo_name: nikkh/heracles-ai


text:
# ProxyCrawl

Dependency free gem for scraping and crawling websites using the ProxyCrawl API.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'proxycrawl'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install proxycrawl

## Usage

Require the gem in your project

```ruby
require 'proxycrawl'
```

Initialize the API with one of your account tokens, either normal or javascript token. Then make get or post requests accordingly.

You can get a token for free by [creating a ProxyCrawl account](https://proxycrawl.com/signup) and 1000 free testing requests. You can use them for tcp calls or javascript calls or both.

```ruby
api = ProxyCrawl::API.new(token: 'YOUR_TOKEN')
```

### GET requests

Pass the url that you want to scrape plus any options from the ones available in the [API documentation](https://proxycrawl.com/dashboard/docs).

```ruby
api.get(url, options)
```

Example:

```ruby

begin
  response = api.get('https://www.facebook.com/britneyspears')
  puts response.status_code
  puts response.original_status
  puts response.pc_status
  puts response.body
rescue => exception
  puts exception.backtrace
end

```

You can pass any options of what the ProxyCrawl API supports in exact param format.

Example:

```ruby
options = {
  user_agent: 'Mozilla/5.0 (Windows NT 6.2; rv:20.0) Gecko/20121202 Firefox/30.0',
  format: 'json'
}

response = api.get('https://www.reddit.com/r/pics/comments/5bx4bx/thanks_obama/', options)

puts response.status_code
puts response.body # read the API json response
```

### POST requests

Pass the url that you want to scrape, the data that you want to send which can be either a json or a string, plus any options from the ones available in the [API documentation](https://proxycrawl.com/dashboard/docs).

```ruby
api.post(url, data, options);
```

Example:

```ruby
api.post('https://producthunt.com/search', { text: 'example search' })
```

You can send the data as application/json instead of x-www-form-urlencoded by setting options `post_content_type` as json.

```ruby
response = api.post('https://httpbin.org/post', { some_json: 'with some value' }, { post_content_type: 'json' })

puts response.status_code
puts response.body

```

### Javascript requests

If you need to scrape any website built with Javascript like React, Angular, Vue, etc. You just need to pass your javascript token and use the same calls. Note that only `.get` is available for javascript and not `.post`.

```ruby
api = ProxyCrawl::API.new(token: 'YOUR_JAVASCRIPT_TOKEN' })
```

```ruby
response = api.get('https://www.nfl.com')
puts response.status_code
puts response.body
```

Same way you can pass javascript additional options.

```ruby
response = api.get('https://www.freelancer.com', options: { page_wait: 5000 })
puts response.status_code
```

## Original status

You can always get the original status and proxycrawl status from the response. Read the [ProxyCrawl documentation](https://proxycrawl.com/dashboard/docs) to learn more about those status.

```ruby
response = api.get('https://sfbay.craigslist.org/')

puts response.original_status
puts response.pc_status
```

If you have questions or need help using the library, please open an issue or [contact us](https://proxycrawl.com/contact).

## Development

After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/proxycrawl/proxycrawl-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

## Code of Conduct

Everyone interacting in the Proxycrawl project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/proxycrawl/proxycrawl-ruby/blob/master/CODE_OF_CONDUCT.md).

---

Copyright 2020 ProxyCrawl

repository: jamalawd/proxycrawl-ruby

repo_name: jamalawd/proxycrawl-ruby


text:
---
authors:
- chesnay: null
  name: Chesnay Schepler
date: "2021-12-16T00:00:00Z"
title: Apache Flink Log4j emergency releases
aliases:
- /news/2021/12/16/log4j-patch-releases.html
---

The Apache Flink community has released emergency bugfix versions of Apache Flink for the 1.11, 1.12, 1.13 and 1.14 series.

These releases only include a version upgrade for Log4j to address [CVE-2021-44228](https://nvd.nist.gov/vuln/detail/CVE-2021-44228) and [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046).

We highly recommend all users to upgrade to the respective patch release.

You can find the source and binaries on the updated [Downloads page](/downloads.html), and Docker images in the [apache/flink](https://hub.docker.com/r/apache/flink) dockerhub repository.

We are publishing this announcement earlier than usual to give users access to the updated source/binary releases as soon as possible.

As a result of that certain artifacts are not yet available:

* Maven artifacts are currently being synced to Maven central and will become available over the next 24 hours.
* The 1.11.6/1.12.7 Python binaries will be published at a later date.

This post will be continously updated to reflect the latest state.

The newly released versions are:

* 1.14.2
* 1.13.5
* 1.12.7
* 1.11.6

To clarify and avoid confusion: The 1.14.1 / 1.13.4 / 1.12.6 / 1.11.5 releases, which were supposed to only contain a Log4j upgrade to 2.15.0, were _skipped_ because [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) was discovered during the release publication. Some artifacts were published to Maven Central, but no source/binary releases nor Docker images are available for those versions.

repository: apache/flink-web

branch_name: refs/heads/asf-site

gha_language: HTML

repo_name: apache/flink-web


text:
NextGenMap/0.5.5
================

<http://cibiv.github.io/NextGenMap/>

Used under license:
MIT
<https://github.com/Cibiv/NextGenMap/blob/master/LICENSE>

Structure creating script (makeroom_NextGenMap_0.5.5.sh) moved to /sw/bioinfo/NextGenMap/makeroom_0.5.5.sh

Built with EasyBuild toolchains, then later RPATH info updated in executables.

LOG
---

    makeroom.sh -f -t NextGenMap -v 0.5.5 -w http://cibiv.github.io/NextGenMap/ -l "MIT" -L https://github.com/Cibiv/NextGenMap/blob/master/LICENSE -d "flexible highly sensitive short read mapping tool that handles much higher mismatch rates than comparable algorithms while still outperforming them in terms of runtime"
    ./makeroom_NextGenMap_0.5.5.sh
    source /sw/bioinfo/NextGenMap/SOURCEME_NextGenMap_0.5.5 && cd $SRCDIR
    wget https://github.com/Cibiv/NextGenMap/archive/refs/tags/v0.5.5.tar.gz

### snowy-gpu

Now build on a snowy gpu node first.

    cd $PREFIX
    rm -f snowy bianca
    mkdir snowy
    ln -s snowy bianca
    ssh s160
    cd /sw/EasyBuild/
    source source-me-for-EasyBuild-4.5.1-snowy-gpu
    cd $SRCDIR
    tar xf v0.5.5.tar.gz
    mv NextGenMap-0.5.5 NextGenMap-0.5.5_EB-snowy-gpu
    module load CMake/3.18.4-GCCcore-10.2.0
    module load fosscuda/2020b
    cd NextGenMap-0.5.5_EB-snowy-gpu
    mkdir build
    cd build
    cmake -DCMAKE_INSTALL_PREFIX:PATH=$PREFIX ..
    make
    make install

This doesn't ultimately install the tool.  We must handle that by hand.

    cd ../bin
    cp -av ngm-0.5.5 $PREFIX/bin

Check the path usage and use patchelf to fix it up.

    cd $PREFIX/bin
    ldd ngm-core
    ldd ngm-core-debug
    ldd ngm-utils
    ldd ngm-utils-debug
    module load patchelf/0.12-GCCcore-10.2.0
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/CUDAcore/11.1.1/lib:/sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-core
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/CUDAcore/11.1.1/lib:/sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-core-debug
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-utils
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-utils-debug

### rackham

Now build for rackham.

    source /sw/bioinfo/NextGenMap/SOURCEME_NextGenMap_0.5.5
    cd /sw/EasyBuild/
    source source-me-for-EasyBuild-4.5.1-rackham
    cd $SRCDIR
    tar xf v0.5.5.tar.gz
    mv NextGenMap-0.5.5 NextGenMap-0.5.5_EB-rackham
    module load CMake/3.18.4-GCCcore-10.2.0
    module load foss/2020b
    cd NextGenMap-0.5.5_EB-rackham
    mkdir build
    cd build
    cmake -DCMAKE_INSTALL_PREFIX:PATH=$PREFIX ..
    make
    make install
    cd ../bin
    cp -av ngm-0.5.5 $PREFIX/bin

Rackham does not have OpenCL active but does have system-installed OpenCL libraries, and these were linked into the executable.
Use patchelf to fix RPATH up.

    cd $PREFIX/bin
    module load patchelf/0.12-GCCcore-10.2.0
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/CUDAcore/11.1.1/lib:/sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-core
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/CUDAcore/11.1.1/lib:/sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-core-debug
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-utils
    patchelf --set-rpath /sw/EasyBuild/snowy-gpu/software/GCCcore/10.2.0/lib64 ngm-utils-debug

repository: UPPMAX/install-methods

repo_name: UPPMAX/install-methods


text:
# nfov [![Build Status](https://travis-ci.org/nrlquaker/nfov.svg?branch=master)](https://travis-ci.org/nrlquaker/nfov)

nfov is simple ASCII art viewer for macOS powered by [Electron](https://electron.atom.io)

## Features

- nfo, diz, asc, txt support
- ability to change font, font size, text and background color
- ability to change selection and link color
- clickable links
- ability to save rendered png

## Fonts

nfov is bundled with:

- a lot of fonts from [The Ultimate Oldschool PC Font Pack](http://int10h.org/oldschool-pc-fonts)
- [BlockZone](https://github.com/ansilove/BlockZone)
- [Profont for Windows tweaked](http://tobiasjung.name/profont)
- [PT Mono](https://fonts.google.com/specimen/PT+Mono)

## Installation

Can be easily installed with [Homebrew](http://brew.sh):

```sh
brew cask install nfov
```

Alternatively, binaries are available in the [GitHub Releases](https://github.com/nrlquaker/nfov/releases)

## Screenshots

![nfov screenshot](./screenshots/crude.nfo.png)
![nfov screenshot](./screenshots/flt-1000.nfo.png)

## Similar apps

- [Ascension](https://github.com/ansilove/Ascension)
- [PabloDraw](http://picoe.ca/products/pablodraw)
- [NFOViewer](http://blockart.sourceforge.net)
- [QLAnsilove](https://github.com/ansilove/QLAnsilove)
- [QuickNFO](https://github.com/planbnet/QuickNFO)
- [termNFO](https://github.com/phracker/termNFO)

## License

nfov is released under the [MIT License](https://github.com/nrlquaker/nfov/blob/master/LICENSE)

repository: Cloudxtreme/nfov

repo_name: Cloudxtreme/nfov


text:
# <IP_ADDRESS>. Identifying the current process

The close association between the  `thread_info` structure and the **Kernel Mode stack** just described
offers a key benefit in terms of efficiency: the **kernel** can easily obtain the address of the
`thread_info` structure of the process currently running on a CPU from the value of the  `esp` register.
In fact, if the  `thread_union` structure is 8 KB ($2^{13}$ bytes) long, the kernel masks out the 13 least
significant bits of  `esp` to obtain the base address of the  `thread_info` structure; on the other hand, if
the  `thread_union` structure is 4 KB long, the kernel masks out the 12 least significant bits of  `esp` .
This is done by the  `current_thread_info( )` function, which produces assembly language
instructions like the following:

```assembly
movl $0xffffe000,%ecx /* or 0xfffff000 for 4KB stacks */
andl %esp,%ecx
movl %ecx,p
```

After executing these three instructions,  p contains the  `thread_info` structure pointer of the process
running on the CPU that executes the instruction.

Most often the kernel needs the address of the **process descriptor** rather than the address of the
`thread_info` structure. To get the **process descriptor pointer** of the process currently running on a
CPU, the kernel makes use of the  `current` macro, which is essentially equivalent to
`current_thread_info( )->task` and produces assembly language instructions like the following:

```c
movl $0xffffe000,%ecx /* or 0xfffff000 for 4KB stacks */
andl %esp,%ecx
movl (%ecx),p
```

Because the  `task` field is at offset 0 in the  `thread_info` structure, after executing these three
instructions  `p` contains the **process descriptor pointer** of the process running on the CPU.

The  `current` macro often appears in kernel code as a prefix to fields of the **process descriptor**. For
example,  `current->pid` returns the **process ID** of the process currently running on the CPU.

Another advantage of storing the **process descriptor** with the **stack** emerges on multiprocessor
systems: the correct current process for each hardware processor can be derived just by checking
the stack, as shown previously. Earlier versions of Linux did not store the **kernel stack** and the
**process descriptor** together. Instead, they were forced to introduce a global static variable called
`current` to identify the **process descriptor** of the running process. On multiprocessor systems, it was
necessary to define  current as an array one element for each available CPU.

***SUMMARY*** : 所有的**process descriptor** 和 **kernel stack** 都是位于kernel中；由kernel来执行调度；当CPU需要执行某个**process descriptor**的时候，它需要读取这个**process descriptor**的一些数据，比如之前保存的register数据等以便resume；从上面的描述可以看出，CPU是根据`esp`的值来获得**process descriptor**的地址，并且，从前面的描述来看，每个`thread_union`都有一个自己的 **kernel stack** ，而从上面的描述来看，是根据`esp`的值来获得**process descriptor**的地址，所以CPU是在某个`thread_union的 **kernel stack**中执行，然后得到对应的**process descriptor**；

***SUMMARY*** : 因为scheduler在调度一个task开始运行之前会将这个task的所有的register都恢复到CPU中，所以必然会包含`esp`，所以它就可以根据`esp`快速地定位到process descriptor；

repository: dantefung/Linux-OS

repo_name: dantefung/Linux-OS


text:
# TwitterApiMean

MEAN web-application to interact with Twitter API

## Getting started

These instructions will get you a copy of the project up and running on your local machine for development purposes.

### Requirements

Node.js v10.15.3
npm 6.4.1

### Installation

Clone the repository

```
git clone https://github.com/orlyohreally/twitter-api-mean.git
```

Install the dependencies

```
npm install
```

Run mongodb (path may vary) on port 217017

```
cd C:\Program Files\MongoDB\Server\4.0\bin
mongod.exe
```

Run Node.js server

```
node server.js
```

Run Angular project

```
ng serve --proxy-config proxy.conf.json
```

The project will be available at http://localhost:4200. To get random phrases authentication is required

## Built with

- [MongoDB](https://www.mongodb.com) - document database with the scalability and flexibility
- [Express](https://expressjs.com/) - back-end web application framework running on top of Node.js
- [Angular 6](https://angular.io/) - front-end web app framework
- [NodeJS](https://nodejs.org/) - JavaScript runtime environment
- [Angular Material](https://material.angular.io) - Material Design components for Angular

## Authors

- **Orly Knop** - [orlyohreally](https://github.com/orlyohreally)

## License

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

repository: orlyohreally/twitter-api-mean

repo_name: orlyohreally/twitter-api-mean


text:
# nativescript-globalevents
A NativeScript plugin to deal with Global events

## License

This is released under the MIT License, meaning you are free to include this in any type of program -- However for entities that need a support contract, changes, enhancements and/or a commercial license please contact me (nathan@master-technology.com).

## Installation

tns plugin add nativescript-globalevents

## Usage

To use the module you just `require()` it:

```js
require( "nativescript-globalevents" );
```

Notice: You do NOT need to keep a reference to it; and you only need to load it once.

It will automatically attach its methods to all the proper classes in the NativeScript library making it act as if they are built in.

What this does is automatically add support to allow you to setup events on all the page events globally.  For example; if you need a pageLoaded event to occur on every page; you can use this library to get a global pageLoaded event.

Events currently on the **Page** globally that are supported are:
- Page.navigatingToEvent
- Page.navigatedToEvent
- Page.navigatingFromEvent
- Page.navigatedFromEvent
- Page.shownModallyEvent
- Page.showingModallyEvent
- View.loaded
- View.unloaded

If you have any other global events you would like supported please open an issue on the github issue tracker and I will investigate its relevance.

## You ask, how exactly does this help?
Well, my usage is I have several plugins that need to be notified when a new page is loaded/unloaded to allow custom handling to occur automatically.  It could be useful for your own app if you need to do something globally when every page is loaded or unloaded.

```js
require('nativescript-globalevents'); // need only once in the application total

var Page = require('ui/page').Page;
Page.on(Page.navigatingTo, function() { console.log("We have navigated to a new page!"); });
```

## Why use this?
If you need to track globally an event and you don't want to put a handler in each separate page.xml/page.js file.

### Commands and functions
Static Page class now has four new STATIC functions

##### Page.on / Page.addEventHandler (eventName, callback[, thisArg])
##### Page.off / Page.removeEventHandler (eventName[[, callback], thisArg])

### Notes:
If thisArg is null/undefined it will use the current page's "this".

If callback is null on the off/removePageHandler it will remove ALL handlers.

repository: aqibn/DeliveryApp

repo_name: aqibn/DeliveryApp


text:
# Building Modern Web Applications
### By Michael Smart
### Presented at InterSystems Global Summit 2017

__Description:__ An example of a RESTful web service as implemented in Caché, and a client application designed in Angular.js that connects to the service. The two components are meant to demonstrate the concepts of modern web application design and serve as a companion piece to the presentation found here: https://learning.intersystems.com/course/view.php?id=681

__Requirements:__ Caché or Ensemble 2016.2 or higher.

__Instructions:__

1. Create the CSP application `/gs` for the desired namespace.
2. Make sure that the __CSP Physical Files Path__ setting is defined for the `/gs` CSP application.
3. Create the CSP application `/gs/api` and point it to the the same namespace as `/gs`.
4. Set the __Dispatch Class__ option for `/gs/api` to `Todo.REST`.
5. Load the files in the __BuildingModernWebApps__ directory to a new project using Atelier.
6. Compile the new project in Atelier.
7. Connect via Terminal to your instance and run the command `do ##class(Todo.Task).reset()` in the application namespace. This will generate the example data as seen in the presentation.
8. Open your web browser to `http://<server>:<port>/gs/index.html`.

Enjoy!

_— MS_

repository: intersystems/building-modern-web-apps

repo_name: intersystems/building-modern-web-apps


text:
# angular-body-class [![Build Status](https://travis-ci.org/Knorcedger/angular-body-class.png?branch=master)](https://travis-ci.org/Knorcedger/angular-body-class)

An Angular directive that adds the current route controller name as a class to the element it is used
It is meant to be primarily used on the body element of the HTML
**BE CAREFUL**: It deletes any existing classes on that element

## Installation

Download node at [nodejs.org](http://nodejs.org) and install it, if you haven't already.

```sh
npm install angular-body-class --save
```

## Tests

```sh
npm install
npm test
```

## Dev Dependencies

- [eslint](https://github.com/eslint/eslint): An AST-based pattern checker for JavaScript.
- [eslint-config-google](https://github.com/google/eslint-config-google): ESLint shareable config for the Google style

## License

MIT

_Generated by [package-json-to-readme](https://github.com/zeke/package-json-to-readme)_

repository: Knorcedger/angular-body-class

repo_name: Knorcedger/angular-body-class


text:
# Cross account role setup
The cloudformation and scripts in this folder are designed to setup roles users can switch to in your account.  This approach leverages AWS's cross account role capabilities and AWS's STS service in order to assume these roles.  When a role is assumed in the command line, the user will be required to provide a MFA token in order to assume the role.  When the role is assumed, the user will be given temporary credentials which will be set in the terminal sessions' environment.  These credentials will be valid for 1 hour, then the script will need to be run again.

More around this approach can be read at: http://advosight.com/blog

# Technology used
This approach leverages AWS Cross Account Roles, STS and client side scripts in order to ensure MFA authentication for development tools such as AWS SAM, the Serverless Framework and the AWS CLI.

# The scripts

## Setup
For the type of script you want to use, open the script and replace the <REPLACE ME> with the information requested

## Running switchTo.sh
``` !bash
. ./switchTo.sh <MFA Token>
```

## Running switchTo.ps1
``` !ps1
switchTo.ps1
```
The script will prompt for an MFA Token

# Notes
This script can be modified to support multiple accounts, allowing secure and convenient command line access for developers and tools

# Disclaimer
The templates in this repository are an example and Advosight takes no responsibility for your use of them or any problems that come from using them.

repository: advosight/advosight-templates

repo_name: advosight/advosight-templates


text:
# Kubernetes deployed on multiple ubuntu nodes

This document describes how to deploy kubernetes on multiple ubuntu nodes, including 1 master node and 3 minion nodes, and people uses this approach can scale to **any number of minion nodes** by changing some settings with ease. Although there exists saltstack based ubuntu k8s installation ,  it may be tedious and hard for a guy that knows little about saltstack but want to build a really distributed k8s cluster. This approach is inspired by [k8s deploy on a single node](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/getting-started-guides/ubuntu_single_node.md).       [Cloud team from ZJU](https://github.com/ZJU-SEL) will keep updating this work.

### **Prerequisites：**
*1 The minion nodes have installed docker version 1.2+*

*2 All machines can communicate with each orther, no need to connect Internet (should use private docker registry in this case)*

*3 These guide is tested OK on Ubuntu 14.04 LTS 64bit server, but it should also work on most Ubuntu versions*

*4 Dependences of this guide: etcd-2.0.0, flannel-0.2.0, K8s-0.12.0, but it should also work on higher versions*

### **Main Steps**
#### I. Make *kubernetes* , *etcd* and *flanneld* binaries

On your laptop, copy `cluster/ubuntu-cluster` directory to your workspace.

The `build.sh` will download and build all the needed binaries into `./binaries`.

You can customize your etcd version or K8s version in the build.sh by changing  variable `ETCD_V` and `K8S_V`, default etcd version is 2.0.0 and K8s version is 0.12.0.

```
$ cd cluster/ubuntu-cluster
$ sudo ./build.sh
```
Please copy all the files in `./binaries` into `/opt/bin` of every machine you want to run as Kubernetes cluster node.

Alternatively, if your Kubernetes nodes have access to Internet, you can copy `cluster/ubuntu-cluster` directory to every node and run:
```
# in every node
$ cd cluster/ubuntu-cluster
$ sudo ./build.sh
$ sudo cp ./binaries/* /opt/bin
```

> We used flannel here because we want to use overlay network, but please remember it is not the only choice, and it is also not a k8s' necessary dependence. Actually you can just build up k8s cluster natively, or use flannel, Open vSwitch or any other SDN tool you like, we just choose flannel here as a example.

#### II. Configue and install every components upstart script
The example cluster is listed as below:

| IP Address|Role |
|---------|------|
|<IP_ADDRESS>| minion|
|<IP_ADDRESS>| minion|
|<IP_ADDRESS>| minion|
|<IP_ADDRESS>| master|

First of all, make sure `cluster/ubuntu-cluster` exists on this node，and run `configue.sh`.

On master( infra1 <IP_ADDRESS> ) node:

```
# in cluster/ubuntu-cluster
$ sudo ./configure.sh
Welcome to use this script to configure k8s setup

Please enter all your cluster node ips, MASTER node comes first
And separated with blank space like "<ip_1> <ip2> <ip3> <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS>

This machine acts as
  both MASTER and MINION:      1
  only MASTER:                 2
  only MINION:                 3
Please choose a role > 2

IP address of this machine > <IP_ADDRESS>

Configure Success
```

On every minion ( e.g.  <IP_ADDRESS> ) node:

```
# in cluster/ubuntu-cluster
$ sudo ./configure.sh
Welcome to use this script to configure k8s setup

Please enter all your cluster node ips, MASTER node comes first
And separated with blank space like "<ip_1> <ip2> <ip3> <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS>

This machine acts as
  both MASTER and MINION:      1
  only MASTER:                 2
  only MINION:                 3
Please choose a role > 3

IP address of this machine > <IP_ADDRESS>

Configure Success
```

If you want a node acts as **both running the master and minion**, please choose option 1.

#### III. Start all components
1. On the master node:

	`$ sudo service etcd start`

	Then on every minion node:

	`$ sudo service etcd start`

	> The kubernetes commands will be started automatically after etcd

2. On any node:

	`$ /opt/bin/etcdctl mk /coreos.com/network/config '{"Network":"<IP_ADDRESS>/16"}'`

	> You can use the below command on another node to comfirm if the network setting is correct.

	> `$ /opt/bin/etcdctl get /coreos.com/network/config`

	> If you got `{"Network":"<IP_ADDRESS>/16"}`，then etcd cluster is working in good condition. **Victory is in sight！**
	> If not , you should check` /var/log/upstart/etcd.log` to resolve etcd problem before going forward.

3. On every minion node

	> You can use ifconfig to see if there is a new network interface named `flannel0` coming up.

	> Make sure you have `brctl` installed on every minion, otherwise run `sudo apt-get install bridge-utils`

	`$ sudo ./reconfigureDocker.sh`

	This will make the docker daemon aware of flannel network.

**All done !**

#### IV. Validation
You can use kubectl command to see if the newly created k8s is working correctly.

For example , `$ kubectl get minions` to see if you get all your minion nodes comming up.

Also you can run kubernetes [guest-example](https://github.com/GoogleCloudPlatform/kubernetes/tree/master/examples/guestbook) to build a redis backend cluster on the k8s．

#### V. Trouble Shooting

Generally, what of this guide did is quite simple:

1. copy bins and files to right dirctories

2. config etcd using inputed IPs

3. start flannel network

So, whenver you have problem, do not blame Kubernetes, **check etcd configuration first**

Please try:

1. Check `/var/log/upstart/etcd.log` for suspicisous etcd log

2. Check `/etc/default/etcd`, as we do not have much input validation, the right config should be like:

`ETCD_OPTS="-name infra1 -initial-advertise-peer-urls <http://ip_of_this_node:2380> -listen-peer-urls <http://ip_of_this_node:2380> -initial-cluster-token etcd-cluster-1 -initial-cluster infra1=<http://ip_of_this_node:2380>,infra2=<http://ip_of_another_node:2380>,infra3=<http://ip_of_another_node:2380> -initial-cluster-state new"`

3. Remove `data-dir` of etcd and run `reconfigureDocker.sh`again, the default path of `data-dir` is /infra*.etcd/

4. You can also customize your own settings in `/etc/default/{component_name}` after configured success.

repository: ZJU-SEL/kubernetes

branch_name: refs/heads/ubuntu-cluster

gha_language: Go

repo_name: ZJU-SEL/kubernetes


text:
# Script Implementation

## Operation

To give the illusion of taking off and landing, the mod makes a copy of the plane - one plane is the grounded version, the other is the airborne version. The grounded version of the plane possesses collisions, while the airborne version does not. When the player passes takeoff speed, the airborne version of the plane is created and everything from the old grounded plane is copied over. When the player lands, the same process occurs into a grounded plane from an airborne plane.

The information about planes is stored in a lua table. To allow the table created during the data stage to be read during runtime - we create a prototype, serialize the table, and store the serialized table in the prototype property `order`. Since Factorio limits the maximum length of the string to 200 characters, we split the string across several prototypes and recombine the string when loading.

```lua
    -- Serialized table format
    {
        grounded = {
            "grounded-plane-name1"=1, -- Number is index into table "data"
            "grounded-plane-name2"=2,
            -- ...
        },
        airborne = {
            "airborne-plane-name1"=2,
            "airborne-plane-name2"=1,
            -- ...
        },
        data = {
            -- Lookup plane in grounded or airborne table for index into data table
            {
                -- Data for plane 1...
            },
            {
                -- Data for plane 2...
            },
            -- ...
        }
    }
    -- In the example above, grounded-plane-name1 and airborne-plane-name2 are linked together, with their data stored at index 1
```

Increased debris damage is accomplished by halving the health of the plane when it is on the ground, therefore damage is 2x more powerful.

## Possible issues

Because the mod copies the grounded version of the plane for the airborne version, one must **ensure that the grounded version of the plane is not modified** after this mod takes a copy. That means loading this mod after any other mod which modifies planes.

## Lua structure

The different modules of the mod are stored under `logic/`, each its own file. The file `utility.lua` is a exception and implements general functions reused throughout the modules.

When the modules are required, they return a table containing a list of keys of Factorio defines for events, e.g., `defines.events.on_tick` mapping to a function which is the event handler. The code in `control.lua` dispatches the events appropriately to all the event handlers of the modules.

Example of a table returned:
```lua
local function f()
end
local table = {}
table[defines.events.on_tick] = f
```

Graphical representation of data structure:
```
                 Require module 1  Require module 2 ...
                  |----------------|
                  v
Event table      [Event 1          Event 2]
                 |                 |
                 v                 v
                 [Event handlers] [Event handlers]
```

repository: jaihysc/Factorio-AircraftRealism

gha_language: Lua

repo_name: jaihysc/Factorio-AircraftRealism


text:
IxMilia.Dwg
===========

A portable .NET library for reading and writing DWG files.

### DWG reference

Reference for the closed DWG format come from the [Open Design Alliance](https://www.opendesign.com/).

[R13-R14](http://www.idea2ic.com/File_Formats/AutoCAD%20R13:R14%20DWG%20File%20Specification.pdf)

[Full specification (R13-R2018)](http://www.opendesign.com/files/guestdownloads/OpenDesign_Specification_for_.dwg_files.pdf).

repository: LagoLagoLago/dwg

repo_name: LagoLagoLago/dwg


text:
# [RFC] Eviction of cached task outputs

**Authors:**

- @MorpheusXAUT
- [blackshark.ai](https://blackshark.ai)

This document: https://hackmd.io/qOztkaj4Rb6ypodvGEowAg?view

## 1 Executive Summary

This RFC describes an approach for cache eviction for Flyte executions, both on a workflow and task level. This will allow for invalidation of single (or multiple) task outputs for a single execution, providing an easy way to remove potentially invalid output data or cleaning up no longer required previous runs without having to change the `cache_version` (thus requiring a re-calculation of other related data).

Additionally, we propose to expose the cache eviction functionality via `flyteadmin` as an API to clean up cached values of previously completed executions of workflows or tasks.

## 2 Motivation

Some large executions might produce invalid/undesirable results for some tasks - even though the execution doesn't fail, its output might still be faulty, requiring a re-calculation to be performed using identical inputs.

At the moment, the only way to force Flyte to ignore the (faulty) cached value of a previous execution during a re-run of the workflow would be to change the `cache_version` of the affected task, causing all other calculations to be performed again as well even though their results might've been correct in the first place.

Depending on the workload executed, this might result in unnecessary and potentially high costs and time requirements to re-process. Evicting some of the cached values would allow re-runs of previously executed workflows to leverage caching where desirable while still re-calculating some of the data that has been deemed "invalid".

In addition, exposing cache eviction functionality via a `flyteadmin` API call would allow Flyte users/administrators to perform housekeeping and clean up their cache, cleanly removing the cached data of previously executions that are no longer relevant executions and would otherwise incur continuous storage costs. By exposing the same functionality used during the cache eviction override, we can ensure the cache maintained by `datacatalog` is consistent with the underlying blob storage.

## 3 Proposed Implementation

Our proposed implementation consists of two parts, which - while related to one another - solve two slightly different problems:

### Cache eviction override for a single execution

Similar to the `interruptible` override flag provided for a single execution of a workflow or task, we propose adding a flag (e.g. `cache_override`) to evict the cached output of an execution and force its calculation to be performed (and cached) again.
This cleanup would be performed automatically by Flyte during the execution of a new workflow or task, returning the updated results:

![cache eviction flowchart](https://i.imgur.com/0NeoYGy.png)

* During the execution preparation, `flytepropeller` would query `datacatalog` as before, trying to find the cached output for a task and its inputs.
* If no cache entry was found, the current behaviour remains the same - the task is executed and its result is stored (if caching has been enabled for the task).
* Should a cache hit occur, `flytepropeller` would check the `cache_override` flag of the execution config:
    * If the override has been set, `flytepropeller` would skip retrieving the entry from `datacatalog` and continue execution, overwriting the cached data with the updated results after the task finished successfully.
    * If no override has been set, the cached value is returned as before.
* ~~As a slight variation, the cache eviction of existing entries could be performed before the tasks is executed again (although that might require additional synchronization to avoid race conditions during concurrent executions).~~

We propose to add the new override flag to the existing execution config, allowing for single tasks to be picked out and re-computed on demand. Whilst this would also expose the override on a workflow level, support for evicting a whole workflow from cache during an execution is not strictly necessary as this would be very similar to incrementing the (already implemented) `cache_version` - using the workflow value as a default for all its tasks (if set) should be relatively easy to add though.

The following Flyte components would need to support this change:

#### `datacatalog`

`datacatalog` needs to support the eviction of its cache entries, removing them from both its database as well as the underlying blob storage.
All major cloud providers currently supported should provide sufficient functionality in their SDK/CLI.

Current reservations need to be respected - if the requesting executor is not the current owner, we potentially need to wait until the previous reservation has been released or synchronize access to ensure we're not running into race conditions with simultaneous executions.

#### `flyteidl`

The protobuf definitions in `flyteidl` need to include a new (optional) parameter for enabling the cache eviction override for a single execution - this should most likely be added to the `WorkflowExecutionConfig`.

#### `flytepropeller`

`flytepropeller` needs to be extended to support the additional execution config option to evict cache entries as well as calling appropriate `datacatalog` APIs and handling synchronization.

#### `flyteadmin`

`flyteadmin` needs to accept an updated config for execution requests to support the eviction override as well as pass it along to `flytepropeller`. The new flag should be available via API to either be invoked programatically (e.g. via a user script) or via `flyteconsole`.

#### `flyteconsole`

Similar to the `interruptible` override currently available, we propose to add an optional execution launch setting to `flyteconsole` to easily trigger a single task to be executed again using identical inputs.

#### `flytekit`

We should extend the [`flytekit.remote`](https://docs.flyte.org/projects/flytekit/en/latest/remote.html#remote-access) functionality to support setting the `skip_cache` flag for a single execution.

#### `flytectl`

`flytectl` should support the new `skip_cache` override while creating executions via CLI.

### Evicting cache of a past execution

In addition to the cache eviction override while launching a workflow, we propose to expose the same functionality via `flyteadmin` as an extension to the existing `AdminService`:

#### Extension of existing `flyteadmin` endpoints

We could extend existing `flyteadmin` endpoints (and introduce some new ones) to support eviction of cached workflow/task results:

* The [`UpdateExecution`](https://github.com/flyteorg/flyteidl/blob/ac94eb4c6ffbe17df5b146337135f59914ffe3bf/protos/flyteidl/service/admin.proto#L281) endpoints and its [`ExecutionUpdateRequest`](https://github.com/flyteorg/flyteidl/blob/e749b82a70027d3364f4e5b98ce2cfbffb4eef54/protos/flyteidl/admin/execution.proto#L351) could be extended to include an `evict_cache` flag.
    * If the new flag is set, `UpdateExecution` would evict the cache of the referenced workflow and all of its sub-workflows/-tasks.
    * If a [dynamic](https://github.com/flyteorg/flyteidl/blob/aded40037d1a4d2ea32c6dd18644ccf16072124f/protos/flyteidl/admin/node_execution.proto#L116) or [workflow](https://github.com/flyteorg/flyteidl/blob/aded40037d1a4d2ea32c6dd18644ccf16072124f/protos/flyteidl/admin/node_execution.proto#L108) node are encountered, `flyteadmin` would [list executions](https://github.com/flyteorg/flyteidl/blob/aded40037d1a4d2ea32c6dd18644ccf16072124f/protos/flyteidl/service/admin.proto#L343) for the node and recursively evict the cache of all child executions as well.
    * `flyteadmin` would tolerate partial failures while evicting the cache of an execution - any errors encountered would be propagated back to the user. Running the eviction again would attempt to remove the remaining cached entries.
* We further propose adding a new endpoint equivalent to `UpdateExecution` for handling tasks execution entities (e.g. `UpdateTaskExecution`), supporting the `evict_cache` flag mentioned above.
    * The task execution would be identified using a `TaskExecutionIdentifier`.
    * Whilst `UpdateTaskExecuion` would only contain the `evict_cache` flag at the moment, this approach would be preferred to not break convention of performing CRUD operations on the entity specified in the message name by e.g. re-using `UpdateExecution` to also handle tasks as well.

#### Standalone `flyteadmin` endpoints

As a (less preferred) alternative to the extension of existing functionality mentioned above, we could implement new, completely independent endpoints:

* Similar to `GetExecutionData`, provide an endpoint such as `EvictExecutionCache`, removing all cached outputs of all tasks within the specified workflow execution.
    * The workflow execution would be identified using a `WorkflowExecutionIdentifier`.
    * Execution of the workflow must have already concluded.
    * `flyteadmin` would automatically iterate all tasks included in the workflow and recursively clean up cached data as necessary.
    * If any reservations exist for the cached resources to be deleted, `flyteadmin` would wait until it can ensure no other executor is accessing the data.
* Similar to `GetTaskExecutionData`, provide an endpoint such as `EvictTaskExecutionCache`, removing the cached output of a specific task.
    * The task execution would be identified using a `TaskExecutionIdentifier`.
    * Execution of the task (and its parent workflow, if available) must have already concluded (successfully).
    * If any reservations exist for the cached resource to be deleted, `flyteadmin` would wait until it can ensure no other executor is accessing the data.

As most of the required functionality should already be added while implementing the cache eviction override for an execution, this additional change would likely only require some smaller extension of the `flyteadmin` service.

Whilst our main intent for this `AdminService` extension is for automated/scripted cleanup using user-provided scripts, this functionality could also be added to other Flyte tools:

#### `flytekit`

[`flytekit.remote`](https://docs.flyte.org/projects/flytekit/en/latest/remote.html#remote-access) could be extended to support eviction of a task/workflow's cached results remotely.

#### `flytectl`

`flytectl` should support the task/workflow execution update to evict the cache, similar to the existing `--activate` flag: `flytectl update execution <task/workflow execution identifier> --evictCache`.

#### `flyteconsole`

We propose extending `flyteconsole` to allow users to evict the cache of a finished execution via a button click (including confirmation) using the web UI.

## 4 Metrics & Dashboards

As the implementation of this API extension could potentially lead to additional load on `datacatalog` as well as synchronization delays (due to reservations), it might be useful to track:

* the number of cache evictions (most likely emitted by `flytepropeller`)
* the latency of cache eviction operations (emitted by `datacatalog`)
* the number and delay of synchronization required to evict cache entries/reservations (most likely emitted by `flytepropeller`)

## 5 Drawbacks

The proposed cache eviction changes introduces a slight overhead in execution preparation in case an eviction has been requested since a reservation must be acquired and the stored data has to be removed from `datacatalog` and its underlying blob storage.
Depending on the size of the cached outputs and the blob storage speed, this might induce increased scheduling times for tasks, although no performance impact should occur if no cache eviction is performed.
In order to minimize the execution startup delay, cache eviction could be postponed until the task executed successfully, only requiring a quick check beforehand and ensuring the actual computation can start as soon as possible.

We do not anticipate any noticable impact by the API extension for `flyteadmin` during regular executions, however evicting all cached outputs of a large workflow could introduce some strain on `flyteadmin`/`datacatalog` during processing.

## 6 Alternatives

At the moment, no direct alternative exists to allow for partial re-processing of already cached tasks - the `cache_version` available is not fine-grained enough to achieve the desired outcome. As of now, Flyte users would have to manually remove the "broken" cache entries from `datacatalog`'s database and delete them from the blob storage, potentially resulting in an inconsistent state if not executed properly.

## 7 Potential Impact and Dependencies

As this change spans across most of Flyte's components and repositories, a coordinated effort to introduce and test this proposal will be required. Since we rely on an API change, a `flyteidl` release will be required before additional components can be adapted.

The potential for malicious exploitation is deemed non-existant as no access to any data is provided and most additional communication will be performed intra-cluster. An attacker could potentially cause additional computational costs by removing cached outputs.

## 8 Unresolved questions

1. When should cache eviction happen during a repeated execution?
   Should we evict the cache entry immediately before starting task execution, potentially leaving no cached output available if the execution fails, or postpone the removal until the task has finished (successfully) and new data can be stored right away?
    - **RESOLVED**: eviction will happen after the successfull execution of a task, overwriting the existing data.
2. Should the `cache_override` flag also be added to `flytekit`'s task decorator?
   This would allow users to define tasks/workflows which will automatically evict their cached results, however does not strictly fit with the actual task "definition".
3. Which Flyte tools (`flyteconsole`/`flytectl`) should support the proposed `AdminService` API extension for `flyteadmin`, if any?
    - **RESOLVED**: `flytectl`, `flytekit.remote`, `flyteconsole`
4. Should we support automatic eviction of cached results on workflow archival (opt-out via `flyteconsole`)?
5. Should we evict [Infratask Checkpoints](https://docs.flyte.org/projects/cookbook/en/latest/auto/core/control_flow/checkpoint.html) from the cache as well since they might return cached results? If so, should we evict them from the backend side or pass the `cache_override` flag along to `flytekit`/its `Checkpointer` to skip any available entries?
    - **RESOLVED**: not for the initial implementation. Infratask checkpoints are only relevant for consecutive retries of a task - their results would not be considered when launching another execution with a `cache_override` flag set.

## 9 Conclusion

At the time of writing, Flyte does not provide any functionality to clean up its cache, especially in a targeted, selective manner. This proposal introduces a way for users to control caching behaviour and potentially cut down on computational costs of task re-runs. Whilst the backend portion is relatively clear already, some questions still remain open, especially for the frontend components.

repository: flyteorg/flyte

repo_name: flyteorg/flyte


text:
# mocking.rocks

This readme is work-in-progess and will be updated soon.
Maybe.

Made with `react` and `create-react-app`.

# App / Use

See the running app here:
[https://mocking.rocks](https://mocking.rocks)

This repository is not auto-deployed, the app running at mocking.rocks may or may not be sync'd with the code from this repository.

# License

Licensed under [MIT License](LICENSE).


text:
AppliedScienceProject - Hotel Review Analysis
==============================
* Author: Jiawei Zhao
* Created Time: April 30, 2020

The dataset is download from Kaggle: https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe.
This dataset contains 515,000 customer reviews and scoring of 1493 luxury hotels across Europe. Meanwhile, the geographical location of hotels are also provided for further analysis.

The main goal of this project is to analyze the hotels' situation and predict the sentiment based on reviewers' comments. To apply what I learned from this course, I used the data analysis, data visualization, data preprocessing, create the logistic regression model, and evaluate the model in this project. Based on the analysis, we can see hotels' situation more clearly, like the top 20 popular hotels, hotel location, hotel rating, and so on. I also used the word cloud to display text occurrence. Apply the bag of words and TFIDF model to process the text, and finally, use the logistic regression to predict the sentiment and evaluate the model performance.

The code file is saved under the notebooks file, called HotelReviewsAnalysis.ipynb:
https://github.com/jiaweizhao1008/appliedscienceproject/blob/master/notebooks/HotelReviewsAnalysis.ipynb

(For unknown reason, the map image can not be shown in the github, so I uploaded two figures of hotel location separately. You can find them here: https://github.com/jiaweizhao1008/appliedscienceproject/tree/master/reports/figures)

The raw data could be download by this link:
https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe/download

The data used to train model is saved in src/data/sentiment.csv.zip:
https://github.com/jiaweizhao1008/appliedscienceproject/blob/master/src/data/sentiment.csv.zip

Data Content
-------------
The csv file contains 17 fields. The description of each field is as below:

* Hotel_Address: Address of hotel.
* Review_Date: Date when reviewer posted the corresponding review.
* Average_Score: Average Score of the hotel, calculated based on the latest comment in the last year.
* Hotel_Name: Name of Hotel
* Reviewer_Nationality: Nationality of Reviewer
* Negative_Review: Negative Review the reviewer gave to the hotel. If the reviewer does not give the negative review, then it should be: 'No Negative'
* ReviewTotalNegativeWordCounts: Total number of words in the negative review.
* Positive_Review: Positive Review the reviewer gave to the hotel. If the reviewer does not give the negative review, then it should be: 'No Positive'
* ReviewTotalPositiveWordCounts: Total number of words in the positive review.
* Reviewer_Score: Score the reviewer has given to the hotel, based on his/her experience
* TotalNumberofReviewsReviewerHasGiven: Number of Reviews the reviewers has given in the past.
* TotalNumberof_Reviews: Total number of valid reviews the hotel has.
* Tags: Tags reviewer gave the hotel.
* dayssincereview: Duration between the review date and scrape date.
* AdditionalNumberof_Scoring: There are also some guests who just made a scoring on the service rather than a review. This number indicates how many valid scores without review in there.
* lat: Latitude of the hotel
* lng: longtitude of the hotel

Data Exploration
------------------
Analyze the data features, we make the data visualiztion in these sides.
* Hotel frequency: shows the top 20 hotel that be chosen in Europe.
* Hotel location: shows the hotel distribution in different europen courtries, and show the detailed location of hotels in London.
* Review date: review date is similar to checkout date, by comparing the checkout date in 2015, 2016 and 2017, we can know the rough day that traveler's stay in the hotel.
* Reviewer's country: shows which country has the most people traveling in Europe.
* Average rating of hotel: show the average rating of hotels.
* Hotel levels: divide the hotel level based on the average rating of hotel.
* Wordcloud: display the positive words and negative words.

Data Preprocessing
-------------------
Replace the 'no negative' and 'no positive' comments with null, merge the positive and negative comments together. Justify the review sentiment by reviewer_score column.

Clean the reveiwers' comment, tokeniz words, remove stopwords and pos tag all.

Use sentiment itensity analyzer to analyze the review sentiment, classify the sentiment to four types, neg, neu, pos and compound. This method is referenced from https://www.kaggle.com/jonathanoheix/sentiment-analysis-with-hotel-reviews. :)

Modelling
---------
Choose two columns, clean and is_neg column. Use two methods, bag of words model and tfidf to process the text document, apply the logistic regression to train the model.

Model Evaluation
-----------------
Evaluate the model performance, the accuracy of logistic regression is good. The difference of using bags of words and tfidf to process text is not obvious.

Project Organization
------------

    ├── LICENSE
    ├── Makefile           <- Makefile with commands like `make data` or `make train`
    ├── README.md          <- The top-level README for developers using this project.
    ├── data
    │   ├── external       <- Data from third party sources.
    │   ├── interim        <- Intermediate data that has been transformed.
    │   ├── processed      <- The final, canonical data sets for modeling.
    │   └── raw            <- The original, immutable data dump.
    │
    ├── docs               <- A default Sphinx project; see sphinx-doc.org for details
    │
    ├── models             <- Trained and serialized models, model predictions, or model summaries
    │
    ├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
    │                         the creator's initials, and a short `-` delimited description, e.g.
    │                         `1.0-jqp-initial-data-exploration`.
    │
    ├── references         <- Data dictionaries, manuals, and all other explanatory materials.
    │
    ├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
    │   └── figures        <- Generated graphics and figures to be used in reporting
    │
    ├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
    │                         generated with `pip freeze > requirements.txt`
    │
    ├── setup.py           <- makes project pip installable (pip install -e .) so src can be imported
    ├── src                <- Source code for use in this project.
    │   ├── __init__.py    <- Makes src a Python module
    │   │
    │   ├── data           <- Scripts to download or generate data
    │   │   └── make_dataset.py
    │   │
    │   ├── features       <- Scripts to turn raw data into features for modeling
    │   │   └── build_features.py
    │   │
    │   ├── models         <- Scripts to train models and then use trained models to make
    │   │   │                 predictions
    │   │   ├── predict_model.py
    │   │   └── train_model.py
    │   │
    │   └── visualization  <- Scripts to create exploratory and results oriented visualizations
    │       └── visualize.py
    │
    └── tox.ini            <- tox file with settings for running tox; see tox.testrun.org

--------

The work I submitted represents my work and my work alone.  I abode by the academic integrity policy and I am aware of the consequences associated with engaging in academic misconduct.


text:
# 6.867 Final Project

See More:
- [Preprocessing](https://github.com/zareenc/6.867-project/blob/user-attributes/src/preprocessing/README.md)
- [Classifiers](https://github.com/zareenc/6.867-project/blob/user-attributes/src/classifiers/README.md)

## Requirements
- Python 3
- Python packages:
   - `numpy`
   - `scikit-learn`
   - `statistics`
- NLTK packages:
```
$ sudo pip install -U nltk
$ python
> import nltk
> nltk.download('punkt')
> nltk.download('averaged_perceptron_tagger')
> nltk.download('stopwords')
```

## Using this code

See the [Preprocessing README](https://github.com/zareenc/6.867-project/blob/user-attributes/src/preprocessing/README.md) and [Classifiers README](https://github.com/zareenc/6.867-project/blob/user-attributes/src/classifiers/README.md) for more detailed information about processing data and running classifiers. While each script to process the data takes in a different set of arguments, most of the classifiers take in the same ones.

The usual process to run a classifier is
```
python classifier.py path_to_train_csv path_to_validation_csv path_to_test_csv
```

Some of the classifiers have additional arguments. See the Classifiers README for more details.


text:
_ _              ___  ______
              (_) |            / _ \ | ___ \
     _ __ ___  _| |_ _ __ ___ / /_\ \| |_/ /
    | '_ ` _ \| | __| '_ ` _ \|  _  ||  __/
    | | | | | | | |_| | | | | | | | || |
    |_| |_| |_|_|\__|_| |_| |_\_| |_/\_| 2.2

 A python program to create a fake AP and sniff data.

# new in 2.0:
  * SSLstrip2 for HSTS bypass

  * Image capture with Driftnet

  * TShark for command line .pcap capture

# features:
  * SSLstrip2

  * Driftnet

  * Tshark

  * Full featured access point, with configurable speed limit

  * mitmproxy

  * Wireshark

  * DNS Spoofing

  * Saving results to file

# requirements:
  Kali Linux / Raspbian with root privileges

  A wireless card and an ethernet adapter / 2 wireless card

  Python3 (mitmAP will install the dependenices, you don't have to do it)

# downloading:

"git clone https://github.com/xdavidhu/mitmAP"

# starting:
  * Kali Linux -> "sudo python3 mitmAP.py"

  * Raspberry PI -> "sudo python3 mitmAP_rpi.py"

Important: At the first run, choose 'y' on installing dependencies and on creating the config files!

# disclaimer:
  I'm not responsible for anything you do with this program, so please only use it for good and educational purposes.


text:
# Generating project via generators
Atmo has generators which allows you generate source code which you could use to make changes or deploy it.

![Widget Frame](./images/Generator.PNG)

In the header, click the `Generate Project` button which will open a popup. You will get list of all the generators installed.
Atmo comes with the default `atmo-gen-expressjs-es5` generator. Click on it and the generated code will be availble in a folder called `project` in the current working directory.

repository: yohangz/atmo

repo_name: yohangz/atmo


text:
---
title: Frequently Asked Questions
sidebar: talk_sidebar
permalink: faq.html
summary:
---

### How are new stories/assets added to Talk? Is there an API?

There are three ways that new assets can make their way into Talk: _just in time_, _active_ and manual.

#### Just in Time asset creation

Talk ships with a _just in time_ mechanism that works out of the box without integration with any CMS or manual work needed.

The _just in time_ flow looks like this:

* Request comes in for a stream on an asset that doesn't yet exist.
* Talk screens the domain against the domain whitelist, fails if doesn't pass.
* Then, concurrently
  * Talk creates a new asset record and returns the stream data (which will be empty)
  * Schedules a job to scrape the new page and fill in asset information.

The scraping mechanism utilizes [metascraper](https://www.npmjs.com/package/metascraper) and is queued using the [Que](https://www.npmjs.com/package/kue). If your Talk deployments is configured to run separate job worker cluster, scraping will be performed by them.

#### Active (or push based) asset creation

If tighter CMS integration is required to push custom data into assets and/or keep data in sync as changes are made in a CMS an _active_ push based workflow must be implemented.

This is an ideal candidate for a plugin. If you are interested in working on it, please [contact us](https://coralproject.net/contact.html)!

#### Manual asset creation

Sometimes you want to load a lot of assets into the database. The most common use case for this is populating the database during an initial installation. We recommend writing a script that transforms the data from it's source and inserts it into the _assets_ collection.

For current schema information, please see the [asset model](https://github.com/coralproject/talk/blob/master/models/asset.js).

### Where are your http API docs?

Coral relies on GraphQL for the vast majority of it's client <-> server communication. All core queries, mutations and subscriptions are defined along with types and comments in our central [TypeDef](https://github.com/coralproject/talk/blob/master/graph/typeDefs.graphql). For plugin graph api typedefs, see each plugin's `/server/` directory.

In addition, Talk Server ships with [GraphiQL](https://github.com/graphql/graphiql). GraphiQL provides a full data layer IDE including interactive documentation. The autocompletes and documentation are populated from introspection meaning that Core _and plugin_ apis will be fully explorable.

To access GraphiQL:

* [Install Talk](install-source.html).
* Open http://localhost:3000/api/v1/graph/iql in your browser. (Note, your server an port may differ.)

### Where is documentation for a specific component?

We strive for clear inline documentation across our codebase, but have gaps. Contributions to documentation would be greatly appreciated and is a great way to start contributing to the project!

If you are considering changing a core component (aka, one that is not in a plugin), you are entering the realm of a core developer. We strongly ask that you reach out the coral team before forking and changing core code. We are glad to help talk through your product need and come up with a strategy for implementing as a plugin, or working with you to extend the plugin API for your use case.

### How do I contribute to these docs?

Contributions to the docs are much appreciated and a great way to get involved in the project.

Fork the Talk repo, clone it locally (no need to go through the install from source process), then:

```
cd docs
docker build --no-cache -t mydocs .
docker run -v "$PWD:/src" -p 4000:4000 mydocs serve -H <IP_ADDRESS>
```

You can edit the files in docs with any editor and view the live updates in a browser by hitting `http://localhost:4000`.

Once you've made the changes, file a PR back to the `coralproject/talk` repo.

repository: StephanieDClark/coral-talk

repo_name: StephanieDClark/coral-talk


text:
---
layout: post
title:  "Email: Tracking A Receiver's Geolocaiton/Knowing If Your Email Was Read"
date:   2017-05-06
tags:
- Networking
- Security
- Hacking
- Metasploit
- Python
---

### The Problem
This will probably be one of my most interesting posts. In this post I am going to explain how something as simple as reading an email could expose someone's geolocation and/or how you could know if an email was read or not.

Recently, (and for the 100th time) I received an scam email in my spam folder telling me that I won $850,000 USD and they asked for my personal info:

![Screenshot showing the scam email I received](/images/scam-email.png)

I was thinking how I could possibly trick the scammers or gain more info about them or possibly hack them so that they would learn their lesson. I initially sent them a link to a malicious Metasploit payload (Supposedly my identification documents) that once opened I would get their IP info (e.g., through Apache HTTP logs) and upon running the executable I would gain access to their machine.

Unfortunately, based on my server logs, they did not even click on the link so I started to wonder if my email was read at all!

### Did They Read My E-mail?
The first (non-practical) idea that comes to mind is to embed some JS code in your HTML email and send it to the victim, however, by no exception all email applications block JS code for security reasons.

### The Solution
But fortunately (Or unfortunately) there is even an easier way: Embedding external images/resources in your email. The idea is that if I embed an external image in the body of my email like the following:

```HTML
<meta charset="utf-8">
Hi:<br>
Here is a screenshot of my passport:
<img src="http://<YOUR-DOMAIN-GOES-HERE>/test.png">
```

Once the reader opens the email, the browser will try to load the image and therefore it would send an HTTP request to my server, and bingo! We can simulate clicking a link, and finally, get the IP info of the victim as well as knowing the exact time our email was opened!

### Different Mail Clients
Some mail applications block images by default (I think now we know why!). For example, I noticed that Yahoo does this:

![Screenshot Showing Yahoo Mail Blocking Images](/images/email-track.png)

But surprisingly, Gmail seems to load images without prompting the user:

![Screenshot Showing Gmail Not Blocking Images](/images/email-track-gmail.png)

And finally, the URLs do not even have to point to an actual file that exists on the server. For example, to track different users I can send a different URL to every victim! (As long as I know which person received which URL):

![Screenshot Showing Python Build-in HTTP Server](/images/python-http-server.png)

<small>P.S.  The above is not my nor the scammer's IP address  :) (Hint: VPN is sometimes useful!)</small>

### Tracking Geo-location by IP

Of course, there is no definite way to find the geo-location of an IP address but at least this should give us an idea of whereabouts of the victim. There are various services on the internet that keep track of IP addresses by geo-location and my favorite one is:

`http://ipinfo.io/<IP ADDRESS HERE>`

For example:

`http://ipinfo.io/<IP_ADDRESS>`

After all, this is just one out of many things that we can do during the reconnaissance stage of our hacking adventure!

**Update (YY-mm-dd) 2017/05/06:** They did read my email and I got their IP info. Some screenshots:

![](/images/scammer-caught.png)
![](/images/scammer-caught2.png)


text:
# Mongodb

MongoDB is a general purpose, document-based, distributed database built for modern application developers and for the cloud era.

## Usage

```
refer the demo.js file
```

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

repository: rohanpradev/Mongodb

repo_name: rohanpradev/Mongodb


text:
# Project Details

## Disclaimer

This project is **not** official, related, or approved by Orangetheory in any way. This is a 3rd party project that exists just to get more analysis and information out of the data that you generate during an Orangetheory class (ie, your own data).

## Security

This project does **not** and **will not** collect or track your data in any way. All sign-in credentials and requests are sent directly to official OTF servers; no data provided or retrieved from OTF is ever persisted, saved, or viewed by anybody but you. This project **does** look at which pages are viewed (ie Trends, Class history, etc) in order to watch for errors that occur so I can fix them, but **no personal data** is ever viewed or saved by this.

## Limitations

Since this project is based on reverse-engineering, certain aspects may be buggy or not available. I'll try to update this to provide more functionality, but there are limitations based on the data that is available.

## Contributing

Contributions are very welcome. All contributions should be done through pull-requests and will be code-reviewed to ensure maintainability and to ensure the privacy statement above is maintained.

## Running via Docker

You can run this application via Docker, after installing docker run the following commands from the location that you cloned the repo to:
```bash
docker build -t otf-tracker .
docker run -d -p 8080:80 --name otf-tracker otf-tracker
```

If everything worked, you can open the app by going to: http://localhost:8080

repository: mathewtitus/otf-tracker

repo_name: mathewtitus/otf-tracker


text:
---
layout: example
title: Warming Stripes
permalink: /examples/warming-stripes/index.html
spec: warming-stripes
image: /examples/img/warming-stripes.png
---

Warming stripes (sometimes referred to as climate stripes, climate timelines or stripe graphics) are data visualization graphics
that use a series of coloured stripes chronologically ordered to visually portray long-term temperature trends.
Warming stripes reflect a "minimalist" style, conceived to use colour alone to avoid technical distractions
to intuitively convey global warming trends to non-scientists. [Wikipedia: Warming stripes](https://en.wikipedia.org/wiki/Warming_stripes)

Originaly designed by [Wikipedia: Ed Hawkins (climatologist)](https://en.wikipedia.org/wiki/Ed_Hawkins_(climatologist)).

This Vega example made by Andrzej Leszkiewicz [@avatorl](https://github.com/avatorl)

This implementation of the warming stripes chart has a legend. And the chart is interactive: hover over a color stripe to highlight the stripe.
The tick on the left side of the legend shows temperature for the selected stripe (year) or 0°C if cursor is not on the stipres.

{% include example spec=page.spec %}

repository: vega/vega

repo_name: vega/vega


text:
---
layout: post
title: (Ruby) Slack Bot for BTCUSD price notifications
categories: [trading, utils]
tags: [ruby, bots]
repo: https://bitbucket.org/xin_chao/priceshirley
permalink: btc-price-slack-bot/
description: Slack Bot that checks BTCUSD on BitFinex and OKCoin (Quarterlies) and pushes regular report or price change notifications to a Slack channel.
---

What is it?

Slack Bot that checks BTCUSD on BitFinex and OKCoin (Quarterlies) and pushes regular report or price change notifications to a Slack channel.

Works on the free Openshift’s Ruby 2.0.0 cartridge.

Setting up Slack incoming hook

Log in to your Slack (or create a new private one only for notifications like this).

In your apps directory should be an option somewhere to add Custom Integrations, and under that Incoming Webhooks.

https://YOURSLACK.slack.com/apps/ASFGHJUYTR-incoming-webhooks

Create new incoming hook and use the URI as variable hook (explained further down).

Setting up notifications

Create separate files for different time intervals and have them run by separate cronjobs.

price reporting

require_relative("mod_priceshirley.rb")

include PriceShirley
hook = "https://hooks.slack.com/services/THIS-is/what-you-get/from-slack-when-creating-incoming-hook"
PriceShirley::Reporter.new(hook).worker

price alert

require_relative("mod_priceshirley.rb")
include PriceShirley
hook = "https://hooks.slack.com/services/THIS-is/what-you-get/from-slack-when-creating-incoming-hook"
delta = 0.15 # percentage change to fire the alert
interval = "Minutely" # 1 word or with underscores
PriceShirley::Observer.new(hook).periodiccheck(delta, interval)

The alert only checks the current price versus the previous one so it all depends on how often you will let the cron run.

Result

This is a resulting notification:

The code

Source: https://bitbucket.org/xin_chao/priceshirley/src/

The main part is a small Ruby module that can be copypasted to Openshift’s backend.

repository: altcointrading/ct-tools-recovery

repo_name: altcointrading/ct-tools-recovery


text:
[![Build Status](https://travis-ci.org/flapdoodle-oss/de.flapdoodle.embed.mongo.svg?branch=embed-mongo-4.x)](https://travis-ci.org/flapdoodle-oss/de.flapdoodle.embed.mongo)
[![Maven Central](https://img.shields.io/maven-central/v/de.flapdoodle.embed/de.flapdoodle.embed.mongo.svg)](https://maven-badges.herokuapp.com/maven-central/de.flapdoodle.embed/de.flapdoodle.embed.mongo)

# Make Peace, No War!

# Organization Flapdoodle OSS

We are a github organization. You are invited to participate. Every version < 4.x.x is considered as legacy.

# Embedded MongoDB

Embedded MongoDB will provide a platform neutral way for running mongodb in unittests.

## Why?

- dropping databases causing some pains (often you have to wait long time after each test)
- its easy, much easier as installing right version by hand
- you can change version per test

## How?

- download mongodb (and cache it)
- extract it (and cache it)
- java uses its process api to start and monitor the mongo process
- you run your tests
- java kills the mongo process

## License

We use http://www.apache.org/licenses/LICENSE-2.0

## Dependencies

### Build on top of

- Embed Process Util [de.flapdoodle.embed.process](https://github.com/flapdoodle-oss/de.flapdoodle.embed.process)

### Other ways to use Embedded MongoDB

- in a Maven build using [maven-mongodb-plugin](https://github.com/Syncleus/maven-mongodb-plugin) or [embedmongo-maven-plugin](https://github.com/joelittlejohn/embedmongo-maven-plugin)
- in a Clojure/Leiningen project using [lein-embongo](https://github.com/joelittlejohn/lein-embongo)
- in a Gradle build using [gradle-mongo-plugin](https://github.com/sourcemuse/GradleMongoPlugin)
- in a Scala/specs2 specification using [specs2-embedmongo](https://github.com/athieriot/specs2-embedmongo)
- in Scala tests using [scalatest-embedmongo](https://github.com/SimplyScala/scalatest-embedmongo)

## Howto

- [Use Cases](docs/UseCases.md)
- [Customizations](docs/Howto.md)

### Maven

	<dependency>
		<groupId>de.flapdoodle.embed</groupId>
		<artifactId>de.flapdoodle.embed.mongo</artifactId>
		<version>4.7.0</version>
	</dependency>

### Spring Integration

As the spring projects
[removed the embed mongo support in 2.7.0](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.7-Release-Notes#springmongodbembeddedfeatures-configuration-property-removed)
you should consider to use one of these integration projects.
It should behave mostly like the original spring integration, but there are some minor differences:
- version in 'spring.mongodb.embedded.version' is used in package resolver and is not matched against version enum.
- 'spring.mongodb.embedded.features' is not supported (not the way to change the config of mongodb)

If you have any trouble in using them fell free to create an issue.

- [Spring 2.6.x](https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo.spring/tree/spring-2.6.x)
- [Spring 2.7.x](https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo.spring/tree/spring-2.7.x)
- [Spring 3.0.x](https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo.spring/tree/spring-3.0.x)

gha_language: Java


text:
---
title: Producing Result Sets
---

SPARQL has four result forms:

-   SELECT – Return a table of results.
-   CONSTRUCT – Return an RDF graph, based on a template in the
    query.
-   DESCRIBE – Return an RDF graph, based on what the query
    processor is configured to return.
-   ASK – Ask a boolean query.

The SELECT form directly returns a table of solutions as a result
set, while DESCRIBE and CONSTRUCT use the outcome of matching to
build RDF graphs.

## Solution Modifiers

Pattern matching produces a set of solutions. This set can be
modified in various ways:

-   Projection - keep only selected variables
-   OFFSET/LIMIT - chop the number solutions (best used with ORDER
    BY)
-   ORDER BY - sorted results
-   DISTINCT - yield only one row for one combination of variables
    and values.

The solution modifiers OFFSET/LIMIT and ORDER BY always apply to
all result forms.

### OFFSET and LIMIT

A set of solutions can be abbreviated by specifying the offset (the
start index) and the limit (the number of solutions) to be
returned. Using LIMIT alone can be useful to ensure not too many
solutions are returned, to restrict the effect of some unexpected
situation.  LIMIT and OFFSET can be used in conjunction with
sorting to take a defined slice through the solutions found.

### ORDER BY

SPARQL solutions are sorted by expression, including custom
functions.

    ORDER BY ?x ?y

    ORDER BY DESC(?x)

    ORDER BY x:func(?x)  # Custom sorting condition

### DISTINCT

The SELECT result form can take the DISTINCT modifier which ensures
that no two solutions returned are the same - this takes place
after projection to the requested variables.

## SELECT

The `SELECT` result form is a projection, with DISTINCT applied, of
the solution set. `SELECT` identifies which named variables are in
the result set.  This may be "`*`" meaning "all named variables"
(blank nodes in the query act like variables for matching but are
never returned).

## CONSTRUCT

CONSTRUCT builds an RDF based on a graph template.  The graph
template can have variables which are bound by a WHERE clause.  The
effect is to calculate the graph fragment, given the template, for
each solution from the WHERE clause, after taking into account any
solution modifiers. The graph fragments, one per solution, are
merged into a single RDF graph which is the result.

Any blank nodes explicitly mentioned in the graph template are
created afresh for each time the template is used for a solution.

## DESCRIBE

The CONSTRUCT form, takes an application template for the graph
results. The DESCRIBE form also creates a graph but the form of
that graph is provided the query processor, not the application.
For each URI found, or explicitly mentioned in the DESCRIBE clause,
the query processor should provide a useful fragment of RDF, such
as all the known details of a book. ARQ allows domain-specific
description handlers to be written.

## ASK

The ASK result form returns a boolean, true of the pattern matched
otherwise false.

[Return to index](index.html)

repository: apache/jena-site

repo_name: apache/jena-site


text:
# SOS Pizza!
Alexa Skill for emergency declaration via fake pizza order. I built this project when I register Garuda Hackathon 2020.

## Tech Stack
Alexa Skill, NodeJS, ExpressJS, Axios

## Description
- Alexa-skill directory consists of files that I use to build this project on Amazon Developer Console.
- Glitch directory consists of files for the project backend. I use Glitch to host my server that sending API to Telegram.

## More information
You can find more information about this project here https://devpost.com/software/sos-pizza

repository: bonasunu/pizzaSOS

repo_name: bonasunu/pizzaSOS


text:
---
layout: post
title: A semi-automatic categorization of GitHub projects
---

After few months from launch, [gitwatcher.com](http://gitwatcher.com/) is
slowly but constantly adding new users to the system and today, we reach the
nice number of 73 active users.

Few but good, just like books and friends should be, right ? What I mean, is
that all of us are skilled programmers already using [GitHub
](https://github.com/)for fun and profit and now, by tagging, we are also
adding a collective value too.

Tagging the repositories we are watching on GitHub in the pursue of being able
to find it again the next time we need it, has at first the personal value of
keeping our things organized and easily findable. As secondary effect, it
enables cooperative semi-automatic categorization  based on
“[folksonomy](http://en.wikipedia.org/wiki/Folksonomy)”.

What we are trying to get here, is a brand new “[trends
page](http://gitwatcher.com/trends)“, where the best GitHub projects are
listed by category.

How can we do it ? Despite the quite extensive literature in  “Automatic
Categorization Systems” field,  gitwatcher.com wants to go easy and
cooperative.

It will start from a really basic kind of categorization system looking each
user’s watchlist for a specific set of tags, say “ruby”, “web” and “framework”
for example, then assign the relative repository to the category “Ruby Web
Frameworks”.

Categories are currently generated by admins at gitwatcher.com, who give them
a name and a minimum set of tags to be included in, but the future is open for
experimenting with better, maybe more social and collaborative solutions.

If you have any idea on how that should be done, please let me know. Add your
suggestion by commenting this article and contributing to the development of
the GitWatcher free platform.

repository: rhoml/rhommelldotcom

repo_name: rhoml/rhommelldotcom