text:
---
layout: post
subheadline: "Instructors"
title: "Reopening Instructor Training"
teaser: "Two open instructor training classes this fall"
header:
   image_fullwidth: "light-blue-wood-texture.jpg"
categories:
   - blog
comments: true
show_meta: true
tags: ["Instructor Development"]
authors: ["Greg Wilson"]
redirect_from: /blog/reopening-instructor-training/
---

For the last ten months,
the [Software Carpentry Foundation](http://software-carpentry.org/scf/) has worked toward three goals
for its instructor training program:

1.  Make the content more relevant.

2.  Increase the number of people able to deliver instructor training.

3.  Find a format that meets everyone's needs in a sustainable way.

They have made a lot of progress on all three,
and are therefore now able to offer instructor training once again
to people who aren't affiliated with our partner organisations,
but would like to teach Data Carpentry, Software Carpentry, or both
(as the course is shared by both organisations).
If you wish to apply to take part
in one of the two open-enrolment classes they will offer this fall,
please fill in the form at:

<https://amy.carpentries.org/workshops/request_training/>

to tell them about yourself,
what excites you about teaching,
and how Software and Data Carpentry can help in your community.
They will notify applicants as spaces become available.
If you have any questions,
please mail
[training@software-carpentry.org](mailto:training@software-carpentry.org).

If you would like to accelerate the process,
check out our [Partnership program](http://www.datacarpentry.org/partnerships/).
Organisational partners make ongoing commitments to supporting our organisation
and are prioritised for instructor training.
If you need help making the case at your organisation,
please [mail us](mailto:partnerships@software-carpentry.org):
we'd be happy to chat.

Please note that as a condition of taking this training, you must:

*   abide by our code of conduct, which can be found at
    <http://datacarpentry.org/code-of-conduct/> and
    <http://software-carpentry.org/conduct/>,

*   agree to teach at a Data Carpentry or Software Carpentry workshop
    within 12 months of the course,
    and

*   complete three short tasks after the course in order to complete certification.
    The tasks take a total of approximately 8-10 hours,
    and are described at
    <http://swcarpentry.github.io/instructor-training/checkout/>.

For more information on instructor training,
please see the course material at:

<http://swcarpentry.github.io/instructor-training/>

Please also see [this additional post](http://software-carpentry.org/blog/2016/07/more-on-instructor-training.html), which answers some frequently-asked questions about this training.

gha_language: SCSS


text:
---
name: Bug Report
about: Building or Using WasmEdge, but it's not working as you expect?
---

## Description

### Current State

<!-- Please shortly describe the bug you have found -->

### Expected

<!-- Please shortly describe what you expect instead -->

## Environment

- Hardware Architecture: (e.g. x86\_64 or aarch64)
- Operating system: (e.g. Ubuntu 20.04 or CentOS 7.6)

The following information is optional. Please provide them only if you have built from source.
- C++ Compiler version:
- CMake version:
- CMake flags: (e.g. `-DCMAKE_BUILD_TYPE=Release -DWASMEDGE_BUILD_AOT_RUNTIME=ON`)

## Steps to Reproduce

<!-- Please provide as much information as necessary to reproduce the bug. -->

repository: WasmEdge/WasmEdge

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: WasmEdge/WasmEdge


text:
# hunterio_api

To use, add hunter.io API key to api_keys.txt, set LIMIT, CB_PATH(input file path) and NUM in settings.py. Input file must contain
column 'Orgnization name' and 'Website'. E.g. MoviePass, https://www.moviepass.com/

!!!!!! To save your requests, don't delete the file "emails_searched_by_domain.csv" !!!!!!

To save me requests, I only implemented the (Domain Search)[https://hunter.io/api/docs#domain-search] function, to use other
functions like Email Finder and Email Verifier, you need to implement them by yourself.

TO DO:
1. Interact with google sheet instead of local csv to save requests!

license: MIT


text:
---
layout: post
title: "How do websites communicate securely?"
author_github: nishanthebbar2011
date: 2017-12-28 23:33:44
image: '/assets/img/'
description: 'How cryptography ensures secure communication'
tags:
- SSL
- Public Key Cryptography
categories:
- CompSoc
github_username: 'nishanthebbar2011'
comments: true
---

The inherent need for human beings has always been to communicate and share information,albeit selectively. For this purpose, the information is to be coded in such a way that it can be deciphered only by the recipient, regardless of whether the recipient is right next to the sender or on the other side of the world. __*The communication channel is assumed to be plagued with adversaries.*__.These adversaries have access to this coded information and are constantly trying to pry.So, the basic problem has always been to:
__*transfer secure information over such insecure channels.*__

So, how DO you communicate when everyone is an adversary and nobody is trustworthy?
The answer is simple.

## Cryptography

> "Cryptography is the art and science of making a crypto system that is capable of providing information security."

The primary objective of cryptography is to provide basic security services like data integrity, confidentiality, user-authenticity and non-repudiation.

## Crypto-systems

Given below is a simple model of a crypto-system

![Crypto-system](/blog/assets/img/Public-key-crypto/cryptosystem.jpg)

There are two types of crypto-systems,based on how the encryption is carried out.

### 1.Symmetric key encryption

Here, a single key is used for both encryption and decryption of the messages and such a key is established in advance by both the sender and the recipient.Thus,there has to exist "trust" between both sender and receiver, so as to not divulge the key.This was the most common method of encryption before the 1970's.

![Symmetric key](/blog/assets/img/Public-key-crypto/symmetric_key_encryption.jpg)

Suppose Alex wants to send a message to Carl using symmetric key encryption , then both of them will have to agree upon a key beforehand and use it to encrypt and decrypt the messages.

### 2. Asymmetric key encryption/Public Key Cryptography

Here, two different keys are used for both encryption and decryption purposes and there exists some mathematical relation between the keys and thus decryption is possible.One of them is the private key and the other one is the public key.It is assumed that the private key is kept secret by a particular individual.

An individual(recipient) makes one of his keys public.A sender can encrypt a message with the help of this public key and such an encrypted message is transmitted over the insecure channel. Only the recipient can decrypt this message with the help of his private key, since he alone possesses it. This is clearly a more elegant solution than symmetric key encryption, that relies on "trust".

![Asymmetric key ](/blog/assets/img/Public-key-crypto/asymmetric_key_encryption.jpg)

The crux of this system is to ensure that it is computationally infeasible to deduce the private key from the public key and the encrypted message.Obviously, it is important to ensure that the public key actually belongs to the recipient. This is usually accomplished with the help of a trusted third party, that hands out digital certificates.These parties are called __*Certificate Authorities(CA's)*__.The public key is usually huge and is stored on such digital certificates whereas, the private key is stored on the system itself.

Also with public-key encryption systems, authenticity of digital systems or documents can also be ascertained with the help of Digital signatures. The content is signed with an individual's private key , and since the public key is easily available, the identity of the user is easily verified.

Suppose Alex sends a message(Using Carl's public key) and a digitally signed document to Carl, using a public-key encryption system, these are the advantages,in a nutshell:

__1.__ It is possible to ascertain Alex's identity from his public key and digital signature on the document.

__2.__ Only Alex could have signed the document,since he alone possesses the private key. Therefore it is not plausible for him to deny   sending it.

__3.__ Only Carl possesses the private key for decrypting the message. He,alone can decrypt the message.

__4.__ When the signature is verified by Carl, it checks that the contents of the document or message match what was in there when the signature was applied. Thus, integrity of the data is preserved.

## The SSL Protocol

 One of the major applications of public key cryptography is it's use in Secure Sockets Layer(SSL) protocol to ensure secure transactions   between web browsers and servers.The protocol uses a CA to identify one or both end of the transactions.This,in short, is how it works:

__1.__ A browser requests a secure page (usually https://).

__2.__ The web server sends its public key with its certificate.

__3.__ The browser checks that the certificate was issued by a trusted party (usually a trusted root CA), that the certificate is still valid and that the certificate is related to the site contacted.

__4.__ The browser then uses the public key, to encrypt a random symmetric encryption key and sends it to the server with the encrypted URL required as well as other encrypted http data.

__5.__ The web server decrypts the symmetric encryption key using its private key and uses the symmetric key to decrypt the URL and htp data.

__6.__ The web server sends back the requested html document and http data encrypted with the symmetric key.

__7.__ The browser decrypts the http data and html document using the symmetric key and displays the information.

Thus, as long as the CA is trustworthy, it is possible for the web browsers and servers to communicate securely and that is how all the information that is continuously exchanged on the internet stays safe and secure.

gha_license_id: MIT


text:
# YAAL

----

Yet Another Async Library. Execute any number of tasks, with any number of arguments, in parallel or series. Receive all the results, and then easily manipulate them to get the data you need. The one async function to rule them all (or at least that's the goal).

Install with:

```bash
npm install yaal
```

Then use like this:

```javascript
    // You only need this one function.
	var yaal = require("yaal");

	// Stat a group of files, one at the time
    yaal(fs.stat, ["file1.txt", "file2.txt", "missing"], 1, function (err, res) {
    	if (err) {
        	console.log("One of the raised errors: " + err.any());
        }

        // Let's process all the received stats, skipping those not found
        res.compact().forEach(processStat);
    });
```

[Click to skip the boring stuff and see more code.](#more_code)

----
### Background

I know what you're thinking. "Are you insane?" "Isn't there enough async libraries already?" "Don't you have anything better to do with your time?"

Maybe on all three counts.

The truth is, I really liked the excellent [js async library](https://github.com/caolan/async). It's just that I needed a few additional features. Like the ability to get all the results, even if there was an error. Or to handle ALL the raised errors, not just the first one.

So I started hacking at a solution. I decided the correct approach was to wrap all raised errors (and results) into custom objects, to allow for easier processing. Also, I preferred one versatile function in place of many simple ones (less verbose API). I thought I came up with a really cool idea. I looked around, but surprisingly none of the other libraries I found had the kind of interface I envisioned. Furthermore, they all suffered from the crippling deficit of being invented nowhere near here.

Thus, ***yaal*** was born.

**TLDR:** *I wanted something like async.js that doesn't stop on first error. I made yaal*

----
### Features

 - Simple installation and usage (single function)
 - Callback / closure syntax, following node.js standards (no huge refactoring required)
 - Three execution modes:
  - Array of tasks, receive array of results
  - Hash of tasks, receive hash of results
  - Single task, executed on array of arguments, receive array of results
 - All raised errors returned, but they are still easy to handle thanks to custom return types
 - Execute in series, in parallel or with custom number of parallel tasks at once
 - Can provide metadata on timings of each task (useful for profiling)
 - Can stop on the first error (acting like most other async libs)
 - Can stop on the first result
 - Can generate hash from input arrays, with customizable key lookup
 - Full test suite and [documentation](#documentation)
 - No dependencies

----

### Documentation

#### Basics

Here's how you use yaal:

> `yaal(fn, <[args]>, <true/false/number..."switch1,switch2"...{options}>, <callback>)`

`fn` must be the first argument. It can be one of:

- **An array**: Execute a list of tasks using args for each
- **A hash**: Execute each value in the hash using args for each
- **A function**: Execute function on each argument

Args (the second arguments) isn't mandatory. Callback must be the last argument. Everything in between is interpreted as one of:

- **parallelism**: A number or true/false. Determines how many tasks can be executed at once. `true` is for infinite, `false` for 1. Defaults to `true`.
- **switches**: Some of the options can be switched to `true` by providing 'magic' strings as arguments. All available switches are listed here and in [vars.js](lib/vars.js). You can also combine multiple switches inside one string. Eg: `"meta, first,fatal"`
- **options**: Options hash (a last resort). The full list of options is available inside [vars.js](lib/vars.js) file.

#### Custom types (results and errors)

##### Count

> `<err/res/meta>.count`

The number of actual values that are in the array / hash. For example, if a single error is raised, results array will have one less count than its length.

```javascript
yaal(
    [function (cb) { cb(new Error()); },
    function (cb) { cb(null, "a"); },
    function (cb) { cb(null, "b", "c"); }],
    function (err, res) {
		console.log(err.length); // > 3
		console.log(err.count); // > 1
		console.log(res.length); // > 3
		console.log(res.count); // > 2
    });
)
```

##### Compact

Gets rid of the empty values in errors or results array / hash.

> `<err/res>.compact()`

Note this also removes the information on which function led to which outcome. After calling `compact()` on an array, `count` property should be the same as `length`.

```javascript
		// ... continuing from previous code
		console.log(err.compact().length); // > 1
		console.log(res.compact()); // > [["a"], ["b", "c"]]
```

##### Flat and flatten

Normally, each task is expected to return a single value in its callback. These values then become members of the results (res) array or properties on the res hash.. Such array or hash is then considered "flat" and has `flat` property set to `true`.

> `res.flat`

However, if any of your callbacks return multiple values, all the results will become *"nested"* within arrays. Flat property will be set to `false`.

```javascript
yaal(
    [function (cb) { cb(null); },
    function (cb) { cb(null, "a"); },
    function (cb) { cb(null, "b", "c"); }],
    function (err, res) {
    	console.log(res.flat); // > false
        console.log(res[0]); // > []
        console.log(res[1]); // > ["a"]
        console.log(res[2]); // > ["b", "c"]
    });
)
```

If you want to get rid of the nesting, you can use the `flatten` function.

> `res.flatten(<index>, <fluid>)`

Without any arguments, all elements are preserved. In case of an array, the values are just dumped into a new array with the "empty" ones removed.

```javascript
		var res2 = res.flatten();
        console.log(res2.flat); // > true
        console.log(res2); // > ["a", "b", "c"]
```

In case of hashes, duplicate properties are renamed to pattern "`<oldname>_<index> = <value>`" (by default, can be changed).

```javascript
yaal({
		x: function (cb) { cb(null, "a", "b"); },
		y: function (cb) { cb(null, "c"); },
		z: function (cb) { cb(null); }
	},
    function (err, hash) {
    	console.log(hash); // {x: ["a", "b"], y: ["c"], "z": []}
    	var hash2 = hash.flatten();
    	console.log(hash2); // {x: "a", x_1: "b", y: "c", z: undefined}
    });
)
```

If you call flatten with an index, it will extract only a single value for each result and throw away the rest.

```javascript
		console.log(res); // > [[], ["a"], ["b", "c"]]
		console.log(res.flatten(1)); // > [undefined, undefined, "c"]
```

Notice that, in this case, the `undefined` from the first callback was left intact. You can use negative value to index the array from the end.

If the second argument is true, we will try to find the first non-empty value if the index overflows (like it did in the previous example).

```javascript
		console.log(res); // > [[], ["a"], ["b", "c"], ["d", "e", "f"]]
		console.log(res.flatten(-1)); // > [undefined, "a", "c", "f"]
		console.log(res.flatten(-3)); // > [undefined, "a", "b", "d"]
```

##### Any

If you just want any value from the errors or results array / hash, you can call

> `<err/res>.any()`

```javascript
yaal(
    [function (cb) { cb(new Error("1")); },
    function (cb) { cb(new Error("2")); }],
    function (err, res) {
    	console.log(err.any().message); // > 1
    });
)
```

Currently, for arrays it returns the first value, but it shouldn't be relied upon.

##### Each

> `<err/res>.each(<all>, function (item, key/index) {}, <thisArg>)`

Iterates over a results or errors object and calls the supplied function for each element.

The first argument (`all`) determines whether the fn will be called for everything or only for non-empty values. Is is by default `false` and can be left out if you're only interested in hits.

You can return false to end the iteration. The last argument becomes `this` within your callback, if you supply it.

```javascript
var files = ["a.txt", "not_there1", "not_there2"];
yaal(fs.stat, files, function (err, res) {
	if (err) {
		console.log(err.count); // > 2
		err.each(function (e, index) {
			console.log("Couldn't stat '" + files[index] + "'");
			return false;
		});
		// Output: Couldn't stat 'not_there1'
	}
	//...
});
```

#### Options

#### `"meta"` switch

If you provide `"meta"` switch in the arguments, or set `meta: true` in options, callback will be given a value with detailed execution times of the tasks. It will follow the same format of res and err: array for array, hash for hash.

```javascript
yaal(fns, args, "meta", function (err, _, meta) {
	console.log(meta.startedAt); // > when we called yaal()
    console.log(meta.completedAt); // > when all the tasks ended
    console.log(meta[0].startedAt, meta[0].completedAt); // > times for the first task
});
```

#### `"fatal"` switch

Provide `"fatal"` in arguments or options to switch to the 'single error death' style of error handling, like in async.js. The first raised error will be immediately returned unwrapped. The remaining tasks will be canceled.

```javascript
yaal([fnGood, fnBad], yaal.FATAL, function (err, res) {
	console.log(err); // > Error: returned by fnBad
    console.log(res.length); // > 2
    console.log(res[0]); // > ??? (who knows, depends on the timing)
});
```

#### `"first"` switch

Provide `"first"` switch in arguments or options to return the first result (unwrapped) matching the criteria (by default, 'truthy'). Execution is immediately stopped and no further tasks processed. In case no result match the criteria, we return null (also configurable).

```javascript
yaal(processors, item, "first", function (err, res) {
	if (res) {
		console.log("Processing result:" + res);
	} else {
		console.log("No processor was able to handle " + item);
	}
});
```

#### `"hash"` switch

A way to produce a hash-based result from an array-of-tasks or single-task input.

In the former case, hash keys are extracted from task function names. In case of anonymous functions, keys are stringified indexes from the input array (can be customized in [vars.js](lib/vars.js))

```javascript
var fns = [
	function getData() { /*...*/ },
	function () { /*...*/ }
];
yaal(fns, "hash", function (err, res) {
	console.log(Object.keys(res)); // > ['getData', '1']
});
```

If used in a single-task scenario, the keys for the resulting hash will by default be extracted from the first element of each submitted argument.

```javascript
yaal(toUpperCase, ["a", "b"], "hash", function (err, res) {
	console.log(res.a) // > "A"
	console.log(res.b) // > "B"
});
```

Hash switch allows an additional form: `hash$num`, where `$num` is the specific index from which to extract hash key. Negative values are indexed from right. This is only applicable in cases with nested argument arrays.

```javascript
yaal(upload, [[file, "site1.com"], [file, "site2.com"]], "hash1", function (err, res) {
	console.log(res["site1.com"]) // > "Ok"
	console.log(err["site2.com"]) // > "[Error: Connection timeout]"
});
```

#####For more details about the options, consult the [vars.js](lib/vars.js) file.

----

### Code examples

Execute a list of tasks in parallel. Handle all the errors.

```javascript
yaal([
      saveToDB,
      writeToLog,
      sendToAffiliates
  ],
  [customerLead],
  function (err) {
	if (err) {
    	err.compact().forEach(that.emit.bind(that, "error"));
    }
});
```

Load records into a hash. Escape in case of any error.

```javascript
var records = {
	user: getUserDetails,
    offers: getOffers,
    cart: getCart
};
yaal(records, [dc, userId], function (err, res) {
	if (err) {
    	return handleError(err.any());
    }
    console.log("User " + res.user.name + " has "
    	+ res.offers.length + " available offers");
});
```

Ping each server in a list, performing max 10 pings at one time. Take only the time values.

```javascript
function ping(ip, callback) {
    // ...
    callback(null, success, ms, raw);
}

yaal(ping, ips, 10, function (err, res) {
	if (err) {
    	err.forEach(function (e, i) {
        	if (e) console.log("Couldn't ping ip " + ips[i] + ": " + e.message);
        });
        return;
    }
    console.log(res[0]); // > ["success", 15, {stdout: "...", stderr: "..."}]
    var times = res.flatten(1);
    console.log(times[0]); // > 15
});
```

Query multiple databases (with multiple arguments each). Compare the response times using the `meta` switch.

```javascript
	yaal(testQuery, [[myConn, x], [pgConn, y]], 1, "meta", function (err, _, meta) {
    	if (err) { return; }

        var elapsedMySQL = meta[0].completedAt - meta[0].startedAt,
        	elapsed = meta.completedAt - meta.startedAt;
        console.log("It took MySQL " + elapsedMySQL + " ms");
        console.log("Total time: " + elapsed + " ms");
    });
```

For advanced usage examples (with switches and more), check out the [documentation](#documentation) examples and the `spec/` folder.

----

### Feature updates

Version|Date      |Description
-------|----------|-----------
0.6    |2014/08/07|Production ready
0.7    |2014/08/08|Added `"fatal"` switch
0.8    |2014/08/09|Added `"first"` switch
0.8.1  |2014/08/09|Added comma notation for switches (`"switch1, switch2"`)
0.9    |2014/08/11|Added `<res/err>.each()` method
0.9.2  |2014/08/12|Added `emptyErrorsToNull` option
0.9.3  |2014/08/18|Added `hashDuplicateKeyFormat` option
0.10.0 |2014/08/25|Added `hash` switch

----

### Breaking changes

Version|Date      |Description
-------|----------|-----------
0.9.3  |2014/08/18|Changed the way duplicate hash keys are numbered. Used to be: `["key_0", "key_1", "key_2"]`. Now: `["key", "key_1", "key_2"]`.

----

### TODO

Ideas for future updates. Near the top: expect them soon. Near the bottom: meh.

- ~~`first` switch. Stop execution and return with the first truthy value. One result is returned. Sort of useful for a "find" functionality.~~
- ~~`fatal` switch. Any error is fatal and stops the execution. One error is returned. Like async.js.~~
- ~~Single task applied to an array of arguments, but producing a hash of results, with picked element of each argument serving as key.~~
-  Is it possible to add some kind of fixed arguments in a single-task scenario, that will be supplied for each call?
- Single task applied on each key/value of a hash, producing hash of results.
- Context for callback with a few useful methods. For example, call `this.each(fn)` to iterate over all errors and results at once.
- Multiple functions mapped to multiple arguments (so far, we have `1 -> many` and `many -> 1`).
- `chain` switch: results from previous function used as arguments for the next one.
- `safe` switch to catch the errors and pretend they were in callback.
- Callback commands. Instead of error, use the first argument in callback to provide all sorts of commands to the state machine. Primary use: `stop` command to end the execution immediately (but without an error)
- Allow adding more tasks after the initial yaal call (by returning some kind of "job" object)
- `repeat` switch. Repeat operation until error or `stop`.

Your own ideas, feedback, bug reports or PRs welcome.

----

### Licence

Apache v2. Read it [here](LICENSE).


text:
### CS3205 Team 2
# Kanon : Medical Research Query Portal

## Project Introduction
Our team’s subsystem provides a web interface and control functions for researchers to use to query for medical data. Our Medical Query Research Portal allows for displaying of information from the database, as long as that information cannot be used to identify individuals.  This is achieved by enforcing the k-anonymity property of the result sets through data anonymization algorithms.

## K-Anonymity Algorithm Concept

### Quasi-Identifiers

Attributes of a dataset can be classified into 2 categories: quasi-identifiers and sensitive attributes.
- Quasi-identifiers are attributes that can be used to identify a person, such as race and age. The specific quasi-identifiers of our dataset are sex, zip code, date of birth, ethnicity and nationality.
- Sensitive attributes are characteristics of a person that may be of interest to a researcher, such as symptoms, blood type, medical readings and history.

### Methodology

K-anonymity works such that any set of quasi-identifiers must appear in at least k records in the anonymized dataset, whereby the value of k can be chosen. In this application, it is set to a default factor of 3. In order to achieve the above, the web application applies data generalization and suppression techniques.

Generalization is the replacement of individual values of attributes by a broader category. Specifically, zip code (postal code) can be generalized to a region (e.g. Queenstown) and date of birth to a age group (e.g. 30-39 years old). However, after the process of generalization, there may still remain records whose set of quasi-identifiers does not appear in at least k records.

Suppression then takes place by omitting these records from the result returned to the researcher. Therefore, all records that are retrieved by the researcher will have a set of quasi-identifiers that appear in at least k records in the retrieved dataset.

## Architecture Design

![Architecture diagram](https://imgur.com/LEqzoeK.png)

- The application will be hosted at https://cs3205-2.comp.nus.edu.sg
- Upon connection, user is forwarded to cs3205-2 via [port 80]
- The nginx web server then forwards to the Thin server via [port 8080]
    - We will be running Thin as our application server
    - The implementation programming language is Ruby, which runs a Sinatra web application framework
- A local SQLite database stores application specific information if needed
- Communication to the overall system database (at Server 4) will be performed via RESTful API
    - Communication link to Server 4 is protected with Basic Auth and our own client cert

# Web Application Design
![Application diagram](https://imgur.com/N6Jf7kJ.png)

Our system is a Sinatra application with Ruby:
- Front end UI resides in views/
- CSS, images, Javascript for frontend UI manipulation resides in public/
- Functions and business logic defined in lib/kanon/web_app.rb
- Models defined in lib/kanon/models/
- Queried result-sets pass through anonymizer module lib/kanon/anonymizer.rb before being returned to the researcher
- Communication with Server 4 defined by functions in lib/kanon/webapi.rb
- Global values stored in lib/kanon/konstants.rb

# Application Testing

An admin researcher account is provisioned for each testing group, please contact us for the details. For normal researcher account, please use the registration interface. You will also need a mobile device with Google Authenticator installed.

# Security Claims

## Server and Infrastructure Security

S1-SSL : 		It is not possible to perform sniffing and man-in-the-middle attacks on the connection between server 2 and 4

- Attackers are unable to view the data passing between server 2 and 4 as the connection is protected with the use of TLS/SSL.

S2-WEBAPI :	It is not possible to directly invoke the Web API exposed by Server 4 for Server 2

- The link between server 2 and server 4 is protected with the use of client certificate authentication and basic authentication. A valid client certificate must be presented alongside with the correct credentials in order to invoke server 4’s Web API.

## Web Application Security

W1-CSRF :		An attacker cannot force an user to execute unwanted state-changing actions on a web application in which they're currently authenticated.
- With the implementation of CSRF tokens, an attacker cannot dupe a user into clicking/accessing an URL that perform an action as the permission of the legitimate logged-in user. Form actions are accompanied with a CSRF token that changes with every load of the form, and is validated on the server side.

W2-SESSION :	It is not possible for a single user to have 2 concurrent sessions at any time.

- A single user is only allowed to log into one session at any time. If a user tries to log in using another browser or another system, the previous session associated with the same user will be terminated and he/she will be required to re-login.

W3-COOKIES :	It is not possible for users to tamper with the session parameters.

- An attacker cannot modify his session cookie to impersonate another user or to perform actions as another user. All session parameters are signed with a random secret every time the application first runs and cookies passed to the application is validated on the server side to ensure they are valid and not tampered with.

W4-SQL :		It is not possible to perform SQL injection attempts via form submissions.

- User inputs to the web application are sanitized server side before passing to server 4. Server 4 uses parameterized SQL queries to prevent code injection through malformed inputs.

W5-VALIDATE :	Form inputs are sanitized and validated

- Login and registration forms are validated for password length and empty fields both front and backend. Inputs are sanitized too in case if there are any special characters used.

W6-OTP :		Even if an attacker has access to a user’s login credentials, he will not be able to login without gaining access to the user’s 2FA device.

- Every login is accompanied by a one-time password (OTP) check, which can only be retrieved with the user’s secondary factor authenticating device (Google Authenticator on the user’s mobile device).

## Functional Claims

F1-2FA :		New registration requires 2FA (OTP with Google Authenticator) to be configured, before the researcher can access search features with the new account.

- A new registration is followed by a prompt to link the account to the user’s Google Authenticator mobile application, where OTP will be sent for every login. The OTP configuration process must be completed before a user is able to perform any other tasks in the application.

F2-ROBOT :		Recaptcha is implemented for registration to reduce spam. It’s based off Google Recaptcha V2 api.

- Captcha prevents brute forcing of parameters by scripts and bots and encourage human testing. This reduces traffic on the server side and minimize server load.

F3-ADMIN :		It is not possible for a normal researcher to execute the action of an admin researcher, namely, to view all request for permission, approve and decline request for permission.

- Before performing an admin action, the access level of the researcher (e.g. normal or admin) is checked, and the admin action will only be followed through if the researcher is verified as an admin.

F4-PERMISSIONS :	It is not possible to retrieve search results without first obtaining permission(s) for searching various conditions.

- Researchers that sign up are required to apply for permission to condition categories pertaining to their field of study. Application for a category must be approved by an admin researcher before the new researcher can gain access to view datasets pertaining to the category. Checks are also done before search to ensure that the conditions selected by the researcher are those that are granted to him/her.

F5-KANON :		It is not possible to identify a record from the result set to an individual patient.

- The Medical Query Research Portal allows for displaying of information from the database, as long as that information cannot be used to identify individuals.  This is achieved by enforcing the k-anonymity property of the result sets through data anonymization algorithms. It is to note that data files will not be treated as an identifier to a patient, as it is out of the project’s focus (as discussed during consultations) to run k-anonymization algorithms for the data files. As such, a pseudo sensitivity trigger will be used to decide if the data file is deemed as private or disclosable. The data files will still be generalized to some extent to maintain business and functional realism.

F6-DOWNLOAD : 	It is not possible to reuse a download link to retrieve the intended data file.

- A one-time download link to a data file upon query is generated for the research to download should he/she wishes to. Upon activation, the link will be destroyed. It is impossible to retrieve the same file with the same link. In the case where a malicious researcher brute-forces download links to retrieve data, the security concerns and implications are trivial as files will not identify the patient nor is sensitive (it will be unavailable in this case).

gha_language: JavaScript


text:
Kago
==================

# Installation

## PECL

	pecl install channel://pecl.ycnrg.org/Kago

## From Source

	git clone https://git.ycnrg.org/scm/ykg/kago.git
	cd kago
	phpize
	./configure
	make
	sudo make install

With either installation methods, you'll need to add `zend_extension=kago.so` to your `php.ini` file,
or create an additional file in `conf.d` (if enabled for your PHP build).

repository: yellowcrescent/kago

repo_name: yellowcrescent/kago


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

### Description

In ImageMagick 7.0.7-12 Q16, an infinite loop vulnerability was found in the function ReadPSDChannelZip in coders/psd.c, which allows attackers to cause a denial of service (CPU exhaustion) via a crafted psd image file.

### POC

#### Reference
- https://github.com/ImageMagick/ImageMagick/issues/869

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

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

repo_name: trickest/cve


text:
# The taxi environment

Inspired by [Taxi-v3 gym](https://gym.openai.com/envs/Taxi-v3/) ([source on GitHub](https://github.com/openai/gym/blob/master/gym/envs/toy_text/taxi.py)).

It differs from the gym in that way:
- the passenger always start at location `A`
- the passenger destination is determined:
    - **task 1**: location `B`
    - **task 2**: location `C`
    - **task 3**: location `D`

The `options` folder is only used by the Hierarchical RL baselines. It defines a set of sensible options to tackle the tasks defined for this domain.

repository: logic-and-learning/AdvisoRL

repo_name: logic-and-learning/AdvisoRL


text:
# Harrimanella hypnoides (L.) Coville SPECIES

#### Status
ACCEPTED

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

#### Published in
Proc. Washington Acad. Sci. 3:575, fig. 66. 1901

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
published: false
category: WINE
---

### Example: FixletDebugger on OSX using WineBottler
- https://github.com/jgstew/jgstew.github.io/blob/master/_posts/2015-03-17-FixletDebugger-on-OSX-using-WineBottler.md
- https://forum.bigfix.com/t/fixletdebugger-on-osx-using-winebottler/12778

# Work in progress

- https://www.winehq.org/wwn/384#Wine64%20on%20OS%20X
- http://portingteam.com/topic/10450-macwine-64bit-news/
- http://www.wine-reviews.net/2016/04/run-64bit-wine-197-on-your-mac-osx.html
- http://www.wine-reviews.net/2016/04/experimental-64-bit-wine-os-x-packages.html
- https://www.playonmac.com/en/
- http://wineskin.urgesoftware.com/tiki-index.php
- http://winebottler.kronenberg.org/
- https://www.codeweavers.com/support/wiki/64bit_Support
- https://mike.kronenberg.org/winebottler-1-5-30-now-with-codesigning-support/
- https://www.ibm.com/developerworks/community/wikis/home?lang=en#!/wiki/Tivoli%20Endpoint%20Manager/page/Utilities

--------------

Trying to run http://software.bigfix.com/download/bes/95/util/CLI<IP_ADDRESS>.zip in wine gave the error:
- unimplemented function KERNEL32.dll.GetCurrentConsoleFontEx
- seems to be fixed in 1.8.3 : https://www.winehq.org/announce/1.8.3


text:
<!-- TABLE OF CONTENTS -->
## Table of Contents

- [Table of Contents](#table-of-contents)
- [Installation](#installation)
- [Usage](#usage)
- [Contributing](#contributing)
- [Tests](#tests)
- [License](#license)
- [Contact](#contact)
- [Creator and Acknowledgements](#creator-and-acknowledgements)

<h1> ## Read Me Project </h1>

  Generates Read Me Templates

Screenshot of Project (VS Code):
![Screenshot](./screen.PNG?raw=true "Screenshot")

## Installation
To get a local copy up and running follow these simple steps.

VS Code to create Javascript file and run in Node Terminal

Prerequisites
This is an example of how to list things you need to use the software and how to install them.

  npm
  npm install npm@latest -g

-Installation-
Clone the repo
  git clone https://github.com/github_username/repo.git
Install NPM packages
  npm install

## Usage

This project can be used for undefined. Additional screenshots, code examples and demos work well in this space. You may also link to more resources.

For more examples, please refer to the Documentation

## Contributing

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Regarding this project I respectfully make the following requests regarding contributions:

You are welcome to contribute to this project

Example of how to contribute:
-- Fork the Project --
Create your Feature Branch
  (git checkout -b feature/AmazingFeature)
Commit your Changes
  (git commit -m 'Add some AmazingFeature')
Push to the Branch
  (git push origin feature/AmazingFeature)
Open a Pull Request

## Tests

See the open issues for a list of proposed features (and known issues). Testing completed and any known issues include the following:
 Still have to  get badge feature on license working and check video snippet

## License

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
2019 Trilogy Education Services, a 2U, Inc. brand. All Rights Reserved.

Resources utilised to edit the code:
* Monash University ReadMe and Slide Materials
* Mozilla MDN WebDocs: https://developer.mozilla.org/en-US/
* W3 Schools: https://www.w3schools.com/
* Stack Overflow: https://www.stackoverflow.com/

**Badges**

![Made with love in Bairnsdale ](https://madewithlove.now.sh/au?heart=true&template=plastic&text=Bairnsdale+)


text:
---
type: rule
archivedreason:
title: Do you run Dog Food Stats (after TFS 2010 migration)?
guid: e2472404-8058-45f7-96e1-ddb6a8bdb49f
uri: run-dog-food-stats-after-tfs2010-migration
created: 2009-11-08T02:01:52.0000000Z
authors: []
related: []
redirects:
- do-you-run-dog-food-stats-(after)
- do-you-run-dog-food-stats-after

---

Running the "Dog Food" stats on your new TFS 2010 server is a good way to see if the upgrade was successful. You should check the new values against the [stats you noted down from your TFS 2008 server](/do-you-run-your-dog-food-stats-before1).

1. On TFS2010, run the DogFoodStats queries and save the results
2. Compare the numbers are the same
    **Note:** Number will differ slightly (usually increases as TFS2010 checks in a few more items)
    **Note:** Grant Holliday has never published exactly why they are not the same.

::: greybox
### TFS2008

-- Files:

1 28052

2 335168

-- Compressed file size:

11837952896

-- Uncompressed file sizes:

24868196032

-- Areas & Iterations:

1096
:::
**Figure: Have a look at the dogfoodstats you ran before**

::: greybox
### TFS2010

-- Areas and Iterations:

1096

-- Files:

347629

-- Compressed File Sizes:

11296

-- Uncompressed File Sizes:

23723
:::
**Figure: You should get the same number or more for your TFS2010 server. We’re not worried unless it’s slightly less**

gha_language: TSQL


text:
# Breast Cancer Classifier (Deep Learning) 🔬

[![](https://img.shields.io/github/license/sourcerer-io/hall-of-fame.svg?colorB=ff0000)](https://github.com/akshaybahadur21/Breast-Cancer-Deep-Learning/blob/master/LICENSE.txt)  [![](https://img.shields.io/badge/Akshay-Bahadur-brightgreen.svg?colorB=ff0000)](https://akshaybahadur.com)

This code helps you classify malignant and benign tumors using Deep Learning.

## Code Requirements 🦄
You can install Conda for python which resolves all the dependencies for machine learning.

## Description 🧪
Deep learning (also known as deep structured learning or hierarchical learning) is part of a broader family of machine learning methods based on learning data representations, as opposed to task-specific algorithms. Learning can be supervised, semi-supervised or unsupervised.

Deep learning models are loosely related to information processing and communication patterns in a biological nervous system, such as neural coding that attempts to define a relationship between various stimuli and associated neuronal responses in the brain.

## Python  Implementation 👨🔬

1) Dataset- UCI-ML
2) I have used 30 features to classify
3) Instead of 0=benign and 1=malignant, I have used 1=benign and 2=malignant

## Results 📊

<img src="https://github.com/akshaybahadur21/Breast-Cancer-Deep-Learning/blob/master/b_cancer_dl.gif">

## Execution 🐉
To run the code, type `python B_Cancer_DL.py`

```
python B_Cancer_DL.py
```

repository: sotojcr/Breast-Cancer-Deep-Learning

repo_name: sotojcr/Breast-Cancer-Deep-Learning


text:
---
last_modified_on: "2021-07-07"
title: Strapi
description: Getting started with Strapi and Qovery
---

import Jump from '@site/src/components/Jump';

[Strapi](https://strapi.io) is an open-source headless CMS built with Node. It comes with an excellent admin UI that lets your entire team create and manage content for your websites and apps. Strapi makes your content available via an API and can therefore be used in many different ways.

Here is a list of quickstarts for Strapi and Qovery

<Jump to="/guides/tutorial/how-to-deploy-strapi-with-postgresql/" leftIcon="book">

Deploying Strapi with PostgreSQL

</Jump>


text:
# Guard::Qu

Guard::Qu automatically starts/stops/restarts qu workers

*forked from [Guard::Resque](http://github.com/railsjedi/guard-resque)*

## Install

Please be sure to have [Guard](http://github.com/guard/guard) installed before continue.

Install the gem:

    gem install guard-qu

Add it to your Gemfile (inside test group):

    gem 'guard-qu'

Add guard definition to your Guardfile by running this command:

    guard init qu

## Usage

Please read [Guard usage doc](http://github.com/guard/guard#readme).

I suggest you put the qu guard definition *before* your test/rspec guard if your tests depend on it
being active.

## Guardfile

    guard 'qu', :environment => 'development' do
      watch(%r{^app/(.+)\.rb$})
      watch(%r{^lib/(.+)\.rb$})
    end

Feel free to be more specific, for example watching only for `app/models` and `app/jobs`
to avoid reloading on a javascript file change.

## Options

You can customize the qu task via the following options:

* `environment`: the rails environment to run the workers in (defaults to `nil`)
* `task`: the name of the rake task to use (defaults to `"qu:work"`)
* `queue`: the qu queue to run (defaults to `"default"`)
* `trace`: whether to include `--trace` on the rake command (defaults to `nil`)
* `stop_signal`: how to kill the process when restarting (defaults to `TERM`)

## Development

 * Source hosted at [GitHub](http://github.com/wprater/guard-qu)
 * Report issues/Questions/Feature requests on [GitHub Issues](http://github.com/wprater/guard-qu/issues)

Pull requests are very welcome! Make sure your patches are well tested. Please create a topic branch for every separate change
you make.

## Guard::Delayed Authors

[David Parry](https://github.com/suranyami)
[Dennis Reimann](https://github.com/dbloete)

Ideas for this gem came from [Guard::WEBrick](http://github.com/fnichol/guard-webrick).

## Guard::Qu Authors

[Will Prater](https://github.com/wprater)

I hacked this together from the `guard-resque` gem for use with Qu. All credit go to the original authors.

repository: wprater/guard-qu

extension: markdown

repo_name: wprater/guard-qu


text:
---
title: Python Week 6
layout: post
author: ozzy.johnson
permalink: /python-week-6/
source-id: 13ImW4PMT6SEoMklsF7_vhVfPDFEJ9TNUjAOM0OqQGFg
published: true
---

    Title
    Progressing with Python
    Date
    9/07/18

    Starting point:
    Python on Code Academy

    Target for this lesson?
    To have made progress in understanding and working on Python.

    Did I reach my target?
(add details to "Lesson Review")
     Yes

    Lesson Review

    How did I learn? What strategies were effective?

    Reading the instructions fully and carefully was very important in this section of Python, Lists and Dictionaries. It took time and a lot of going back to other exercises, but I finished the lesson on the last section of it. Unfortunately I earned no badges today.

    What limited my learning? Which habits do I need to work on?

    Getting distracted by other people and not focusing on my own learning slowed me down. If I had focused more, I may have earned a badge.

    What will I change for next time? How will I improve my learning?

    Read the Instructions given to me very carefully, and stay focused on my learning will really help me improve my speed and care in Python.


text:
---
title: "Videos"
page_id: "videos"
warning: false

---

### Concepts and workflows:

* Getting Started

    *   moving around in Postman - [Navigating Postman](/docs/postman/launching_postman/navigating_postman/)
    *   making a request in Postman - [Requests](/docs/postman/sending_api_requests/requests/)
    *   managing and sharing Postman Collections
    *   Postman tests - [Test script](/docs/postman/scripts/test_scripts/)

* Digging Deeper

    *   using environments and variables in Postman - [Environments and globals](/docs/postman/environments_and_globals/manage_environments/)
    *   workflow automation - [Branching and looping](/docs/postman/scripts/branching_and_looping), [Monitors](/docs/postman/monitors/intro_monitors/)
    *   using cookies and authentication helpers in Postman - [Cookies](/docs/postman/sending_api_requests/cookies/), [Authorization](/docs/postman/sending_api_requests/authorization)

* Advanced

    *   Collaboration
    *   Documentation
    *   Monitors
    *   Mock servers

### Features:

##### Playlists:

*   Postman "How To" Playlist (2017)

    * [Intro to Postman & Postman Collections](https://www.youtube.com/watch?v=ptvV_Fc3hd8&list=PLM-7VG-sgbtCJYpjQfmLCcJZ6Yd74oytQ&index=1)
    * [How to use global variables in Postman](https://www.youtube.com/watch?v=TU1i1CgjVR8&list=PLM-7VG-sgbtCJYpjQfmLCcJZ6Yd74oytQ&index=2)
    * [How to add tests to a Postman Collection](https://www.youtube.com/watch?v=ElJBJIeJ90o&list=PLM-7VG-sgbtCJYpjQfmLCcJZ6Yd74oytQ&index=3)
    * [How to use code snippets in postman](https://www.youtube.com/watch?v=fhfuQGvLPj0&list=PLM-7VG-sgbtCJYpjQfmLCcJZ6Yd74oytQ&index=4)
    * [How to use Environments in Postman](https://www.youtube.com/watch?v=wArvaHYdw2I&list=PLM-7VG-sgbtCJYpjQfmLCcJZ6Yd74oytQ&index=5)
    * [How to add an environment variable using code snippets](https://www.youtube.com/watch?v=jzJT_o3_t1Q&list=PLM-7VG-sgbtCJYpjQfmLCcJZ6Yd74oytQ&index=6)
    * [How to use the Postman collection Runner](https://www.youtube.com/watch?v=6XjOtI-FPHg&list=PLM-7VG-sgbtCJYpjQfmLCcJZ6Yd74oytQ&index=7)

*   Postman Pro Playlist (2017)

    * [Intro to Postman Pro - Collaboration](https://www.youtube.com/watch?v=1_7IVWySh2A&index=1&list=PLM-7VG-sgbtCr3URSt3ySIs_nyW9niiyn)
    * [Intro to Postman Pro - Document & Publish](https://www.youtube.com/watch?v=ERk8RkfqxM4&list=PLM-7VG-sgbtCr3URSt3ySIs_nyW9niiyn&index=2)
    * [Intro to Postman Pro - Monitoring](https://www.youtube.com/watch?v=xiRx81jlYOQ&t=3s&list=PLM-7VG-sgbtCr3URSt3ySIs_nyW9niiyn&index=3)


text:
---
layout: default
title: Birth of the Weave
parent: History
nav_order: 2
---

# Birth of the Weave

Approximately 1000 years ago, in the last decades of the Reign of the Dragons, magic began to reappear in Doloria among the common folk. What was once a power of the dragons was now manifesting in humans, gnomes and elves over the land. While the ability to harness and control this power was still unknown, this gift signaled a change in the hearts of the people and collective opinions about the rule of the dragons. With a growing movement against the tyranny of the dragons, the combined races led by human paladin Helena Dolor, gnomish wizard Galivox Vitruvian and elven druid Caledor drove the dragons to the edges of the continent, starting the Draconic Fall.

Each race took this emergence of magic differently. Humans heralded it as a gift from The Gods, a reward for their servitude, given to them in a time of need. The elven community reexamined and relearnt the Eladrin Scripts for some way to re-link this plane with the Feywild. The gnomes saw progress and utility in magic and began to research it, eventually creating many of the magic objects and tools seen today.

repository: dean-l/doloria

repo_name: dean-l/doloria


text:
# Changelog

## 2.2.24

+ Fixed bugs related to or expression in generated methods

## 2.2.23

+ `onlyNonNull` for set columns, insert, upsert and update

## 2.2.22

+ Deduplication in attach during upsert
+ `attach` gets amn optional `upsert` parameter to control upsert or insert

## 2.2.21

+ `newModel` instead of `model` is used in generated `upsert` code

## 2.2.16

+ Fixed `builder.dart` library name

## 2.2.10

+ `fetchBy*` bug fix when pivots are empty

## 2.2.8

+ Immutability
+ Fixes for reflexive relations

## 2.2.6

+ Fixed autoincrement

## 2.2.5

+ Reflexive relations

## 2.1.20

+ `IgnoreColumn` on getters fix

## 2.1.17

+ Better exception printing for field parse exceptions

## 2.1.16

+ Dart2 fixes

## 2.1.15

+ Relations without associations

## 2.1.14

+ Generate `preloadAll` for many-to-many relations
+ Do not generate tableName

## 2.1.12

+ Added `only` to `update`

## 2.1.10

+ Removed `findWhere` and `removeWhere`. They are now in `Bean`.

## 2.1.9

+ Added `findOneWhere`

## 2.1.8

+ Autoincrement cascading

## 2.1.6

+ Return insert id for associations

## 2.1.5

+ Changed `NumField` to `DoubleField`

## 2.1.4

+ Using `parseValue` for parsing value from Database

## 2.1.2

+ Fixed bug where `BoolField` is generated as `BitField`

## 2.1.1

+ Dart2 support

gha_language: Dart


text:
(devices-none)=
# Type: `none`

```{youtube} https://www.youtube.com/watch?v=6NCLnd5_guQ
```

```{note}
The `none` device type is supported for both containers and VMs.
```

A `none` device doesn't have any properties and doesn't create anything inside the instance.

Its only purpose is to stop inheriting devices that come from profiles.
To do so, add a device with the same name as the one that you do not want to inherit, but with the device type `none`.

You can add this device either in a profile that is applied after the profile that contains the original device, or directly on the instance.

repository: lxc/incus

gha_language: Go

repo_name: lxc/incus


text:
### [CVE-2021-26563](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-26563)
![](https://img.shields.io/static/v1?label=Product&message=DiskStation%20Manager%20(DSM)&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-863%3A%20Incorrect%20Authorization&color=brighgreen)

### Description

Incorrect authorization vulnerability in synoagentregisterd in Synology DiskStation Manager (DSM) before 6.2.4-25553 allows local users to execute arbitrary code via unspecified vectors.

### POC

#### Reference
- https://www.talosintelligence.com/vulnerability_reports/TALOS-2020-1158

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


text:
# GoTo Amsterdam 2019
Repository for findings, projects and knowledge from The GoTo Amsterdam 2019

## Recommendations
Make sure Java 11 is installed: [AdoptOpenJDK](https://adoptopenjdk.net/releases.html?variant=openjdk11&jvmVariant=hotspot) (a more recent version can be used for these labs as well).
You can find the JavaDoc for Java 11 [here](https://docs.oracle.com/en/java/javase/11/docs/api/index.html).

Alternatively you can use [Brew](https://docs.brew.sh/Installation.html) to install java.
Just fire this command
 ```brew cask install java ```
 You can verify the version with
 ```brew cask info java```


text:
---
title: Install Voyager Community Edition
description: Installation guide for Voyager Community edition
menu:
  docs_{{ .version }}:
    identifier: install-voyager-operator
    name: Community Edition
    parent: installation-guide
    weight: 10
product_name: voyager
menu_name: docs_{{ .version }}
section_menu_id: setup
---

# Install Voyager Community Edition

Voyager Community edition is available under [AppsCode-Community-1.0.0](https://github.com/appscode/licenses/raw/1.0.0/AppsCode-Community-1.0.0.md) license and free to use for both commercial and non-commercial purposes. `Community Edition` only manages Voyager custom resources in the `demo` Kubernetes namespace. A full features comparison between the Voyager Community edition and Enterprise edition can be found [here](https://voyagermesh.com/pricing/).

To use the Voyager Community edition, you can grab **1 year** free license from [here](https://license-issuer.appscode.com/?p=voyager-community). After that, you can issue another license for one more year. Typically we release a new version of the operator at least quarterly. So, you can just grab a new license every time you upgrade the operator.

## Get a License

In this section, we are going to show you how you can get a **1 year** free license for the Voyager Community edition. You can get a license for your Kubernetes cluster by going through the following steps:

- At first, go to [AppsCode License Server](https://license-issuer.appscode.com/?p=voyager-community) and fill-up the form. It will ask for your Name, Email, the product you want to install, and your cluster ID (UID of the `kube-system` namespace).
- Provide your name and email address. You can provide your personal or work email address.
- Then, select `Voyager Community Edition` in the product field.
- Now, provide your cluster-ID. You can get your cluster ID easily by running the following command:

  ```bash
  $ kubectl get ns kube-system -o=jsonpath='{.metadata.uid}'
  ```

- Then, you have to agree with the terms and conditions. We recommend reading it before checking the box.
- Now, you can submit the form. After you submit the form, the AppsCode License server will send an email to the provided email address with a link to your license file.
- Navigate to the provided link and save the license into a file. Here, we save the license to a `license.txt` file.

Here is a screenshot of the license form.

Fig: Voyager License Form

You can create licenses for as many clusters as you want. You can upgrade your license any time without re-installing Voyager by following the upgrading guide from [here](/docs/setup/upgrade/index.md#updating-license).

> Voyager licensing process has been designed to work with CI/CD workflow. You can automatically obtain a license from your CI/CD pipeline by following the guide from [here](https://github.com/appscode/offline-license-server#api-reference).

## Install

Voyager operator can be installed as a Helm chart or simply as Kubernetes manifests.

    Helm 3 (Recommended)

    YAML

## Using Helm 3

Voyager can be installed via [Helm](https://helm.sh/) using the [chart](https://github.com/voyagermesh/installer/tree/{{< param "info.version" >}}/charts/voyager) from [AppsCode Charts Repository](https://github.com/appscode/charts). To install, follow the steps below:

```bash
$ helm repo add appscode https://charts.appscode.com/stable/
$ helm repo update

$ helm search repo appscode/voyager --version {{< param "info.version" >}}
NAME                  CHART VERSION APP VERSION DESCRIPTION
appscode/voyager      {{< param "info.version" >}}   {{< param "info.version" >}}     Voyager by AppsCode - Secure L7/L4 Ingress Cont...
appscode/voyager-crds {{< param "info.version" >}}   {{< param "info.version" >}}     Voyager Custom Resource Definitions

# provider=acs
# provider=aks
# provider=aws
# provider=azure
# provider=baremetal
# provider=gce
# provider=gke
# provider=kind
# provider=openstack
# provider=metallb
# provider=digitalocean
# provider=linode

$ helm install voyager-operator appscode/voyager \
  --version {{< param "info.version" >}} \
  --namespace voyager --create-namespace \
  --set cloudProvider=$provider \
  --set-file license=/path/to/the/license.txt
```

To see the detailed configuration options, visit [here](https://github.com/voyagermesh/installer/tree/{{< param "info.version" >}}/charts/voyager).

## Using YAML

If you prefer to not use Helm, you can generate YAMLs from Voyager chart and deploy using `kubectl`. Here we are going to show the procedure using Helm 3.

```bash
$ helm repo add appscode https://charts.appscode.com/stable/
$ helm repo update

$ helm search repo appscode/voyager --version {{< param "info.version" >}}
NAME                  CHART VERSION APP VERSION DESCRIPTION
appscode/voyager      {{< param "info.version" >}}   {{< param "info.version" >}}     Voyager by AppsCode - Secure L7/L4 Ingress Cont...
appscode/voyager-crds {{< param "info.version" >}}   {{< param "info.version" >}}     Voyager Custom Resource Definitions

# provider=acs
# provider=aks
# provider=aws
# provider=azure
# provider=baremetal
# provider=gce
# provider=gke
# provider=kind
# provider=openstack
# provider=metallb
# provider=digitalocean
# provider=linode

$ kubectl create ns voyager
$ helm template voyager-operator appscode/voyager \
  --version {{< param "info.version" >}} \
  --namespace voyager \
  --set cloudProvider=$provider \
  --set-file license=/path/to/the/license.txt    \
  --set cleaner.skip=true | kubectl apply -f -
```

To see the detailed configuration options, visit [here](https://github.com/voyagermesh/installer/tree/{{< param "info.version" >}}/charts/voyager).

## Verify installation

To check if Voyager operator pods have started, run the following command:

```bash
$ kubectl get pods --all-namespaces -l app.kubernetes.io/name=voyager --watch

NAMESPACE   NAME                               READY   STATUS    RESTARTS   AGE
voyager     voyager-operator-84d575d55-5lphm   1/1     Running   0          6m42s
```

Once the operator pods are running, you can cancel the above command by typing `Ctrl+C`.

Now, to confirm CRD groups have been registered by the operator, run the following command:

```bash
$ kubectl get crd -l app.kubernetes.io/name=voyager
```

Now, you are ready to create your first ingress using Voyager.

## Configuring RBAC

Voyager creates an `Ingress` CRD. Voyager installer will create 2 user facing cluster roles:

| ClusterRole           | Aggregates To | Description                           |
|-----------------------|---------------|---------------------------------------|
| appscode:voyager:edit | admin, edit   | Allows edit access to Voyager CRDs, intended to be granted within a namespace using a RoleBinding. |
| appscode:voyager:view | view          | Allows read-only access to Voyager CRDs, intended to be granted within a namespace using a RoleBinding. |

These user facing roles supports [ClusterRole Aggregation](https://kubernetes.io/docs/admin/authorization/rbac/#aggregated-clusterroles) feature in Kubernetes 1.9 or later clusters.

## Using kubectl

Since Voyager uses its own TPR/CRD, you need to use full resource kind to find it with kubectl.

```bash
# List all voyager ingress
$ kubectl get ingress.voyager.appscode.com --all-namespaces

# List voyager ingress for a namespace
$ kubectl get ingress.voyager.appscode.com -n <namespace>

# Get Ingress YAML
$ kubectl get ingress.voyager.appscode.com -n <namespace> <ingress-name> -o yaml

# Describe Ingress. Very useful to debug problems.
$ kubectl describe ingress.voyager.appscode.com -n <namespace> <ingress-name>
```

repository: voyagermesh/voyager

gha_language: Shell

repo_name: voyagermesh/voyager


text:
### Summary

- [ ] What is the problem that your PR is solving?
- [ ] Are there any open issues relating to this?
- [ ] Is this PR dependent on PRs in other repositories?

### Other information
Is there anything else important or relevant to this PR?
This could include benchmarks, or other information.

Your PR will be reviewed, and I will work with you
to get your changes merged. If merged, your PR will be added to the
changelog in the next release.

If your changes involve documentation updates, please mention it,
and link to the corresponding PR in [bowler-docs](https://github.com/bowlerjs/bowler-docs).

Thanks for your contribution!

repository: bowlerjs/generator-bowler

repo_name: bowlerjs/generator-bowler


text:
## Using the GraphQL API

The schema that specifies the API operations of your GraphQL server is defined in [`./schema.graphql`](./schema.graphql). Below are a number of operations that you can send to the API using the GraphQL Playground.

Feel free to adjust any operation by adding or removing fields. The GraphQL Playground helps you with its auto-completion and query validation features.

### Call the subscription and watch for it in the GraphQL Playground

```graphql
subscription latestPost {
  latestPost {
    title
    content
  }
}
```

This will listen whenever you create a new draft as follows:

### Create a new draft

```graphql
mutation {
  createDraft(
    title: "Join the Prisma Slack"
    content: "https://slack.prisma.io"
    authorEmail<EMAIL_ADDRESS>  ) {
    id
    published
  }
}
```

Running the above mutation will automatically send the created data to the subscription!

### For viewing it best

- Keep two tabs of the GraphQL Playground open side by side.
- Run the subscription in one tab.
- Fire the mutation in the other tab and view results in the subscriptions tab in real-time!

repository: stanpython/prisma-examples

repo_name: stanpython/prisma-examples


text:
---
title: 'Introduction'
description: 'The Axios module for Nuxt'
position: 1
category: ''
menuTitle: 'Introduction'
features:
  - Automatically set base URL for client & server side
  - Exposes `setToken` function to `$axios` so we can easily and globally set authentication tokens
  - Automatically enables `withCredentials` when requesting to base URL
  - Proxy request headers in SSR
  - Fetch Style requests
  - Integrated with Nuxt progress bar
  - Integrated with Proxy Module
  - Auto retry requests with axios-retry
---

<alert type="warning">

Axios module supports Nuxt 2. Nuxt 3 users can use the new isomorphic [useFetch](https://v3.nuxtjs.org/getting-started/data-fetching/) ([migration guide](https://nuxt.com/docs/migration/component-options/#isomorphic-fetch)).

</alert>

Secure and easy [Axios](https://github.com/axios/axios) integration for [Nuxt](https://nuxtjs.org).

## Features

<list :items="features"></list>

Enjoy light and dark mode: <app-color-switcher class="inline-flex ml-2"></app-color-switcher>

## Logo

Axios does not have an official logo yet, we decided to use the actual proposal submitted here: https://github.com/axios/axios/issues/2130

## Links

* [GitHub](https://github.com/nuxt-community/axios-module)
* [Release Notes](/releases)
* [Migration Guide](/migration)

<alert type="info">

To get started head to [Setup](/setup) section.

</alert>

## Online courses

<promote-block></promote-block>

repository: nuxt-community/axios-module

repo_name: nuxt-community/axios-module


text:
# post-ci-status

A tool to update GitHub PR statuses for a given node-test-commit job.

### Usage

```bash
bundle install
JENKINS_TOKEN=definethis! bundle exec ruby run.rb
# node-test-commit job you would like updated:
13711
```

### License

Copyright (c) 2017+ Jon Moss under the MIT License.


text:
---
title: Hello World
date:<PHONE_NUMBER>770
author: Jacob Clevenger
twitter: wheatjs
gravatar: d2eccc131bb7a5815d1ef3695ad30b04
cover: https://source.unsplash.com/ItaV89TNkks/1600x900
description: Welcome to my new site!
public: true
---

Welcome to my new site!

I've been meaning to create this site for a while now and after various distractions I've finally done it! In fact,
it only took me two days to have a fully working site, not bad, right?

Well here is a brief overview of how I did it. First things first, this site is built using [Vue 3](https://v3.vuejs.org/) <vscode-icons-file-type-vue /> and the super fast
[Vite](https://vitejs.dev/) <vscode-icons-file-type-vite />. I generated the site using [Antfu's Vitesse](https://github.com/antfu/vitesse) to get a
solid baseline. With this I get the following out of the box:

- <twemoji-printer /> [Server Side Generation](https://github.com/antfu/vite-ssg)
- <twemoji-file-folder /> [File based routing](https://github.com/hannoeru/vite-plugin-pages)
- <twemoji-mobile-phone /> [Zero-Config PWA Support](https://github.com/antfu/vite-plugin-pwa)
- <twemoji-rocket /> [Markdown Support](https://github.com/antfu/vite-plugin-md)

This is just a few of the features I get out of the box. For a more comprehensive list take a look at the [Vitesse](https://github.com/antfu/vitesse)
GitHub page. All of these features make it very easy to setup a blogging platform with just a little configuration. I took some inspiration
from [Antfu's Personal Site](https://antfu.me) where he has a very similar tech stack.

Anyway, I'll go more into depth about creating this site in later posts. Until then, thanks for stopping by <twemoji-grinning-face-with-smiling-eyes />

One more thing, if you'd like to take a look at the source code for this site you can [check it out here](https://github.com/wheatjs/wheatjs.me)

gha_language: Vue


text:
# @atlaskit/theme

## 2.4.1
- [patch] Re-releasing due to potentially broken babel release [9ed0bba](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/9ed0bba)

## 2.4.0
- [minor] Update styled-components dependency to support versions 1.4.6 - 3 [ceccf30](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/ceccf30)

## 2.3.4
- [patch] updated the repository url to https://bitbucket.org/atlassian/atlaskit-mk-2 [1e57e5a](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/1e57e5a)

## 2.3.3
- [patch] Packages Flow types for elements components [3111e74](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/3111e74)

## 2.3.2
- [patch] added a new layer tooltip [2215bc7](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/2215bc7)

## 2.3.1
- [patch] Resolved low hanging flow errors in field-base field-text comment icon item and website, $ [007de27](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/007de27)

## 2.3.0
- [minor] Add React 16 support. [12ea6e4](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/12ea6e4)

## 2.2.9

## 2.2.8

## 2.2.7

## 2.2.6

## 2.2.5

## 2.2.4
- [patch] moved theme to new atlaskit repo [a25b940](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/a25b940)
- [patch] moved theme to new atlaskit repo [a25b940](https://bitbucket.org/atlassian/atlaskit-mk-2/commits/a25b940)

## 2.2.3 (2017-10-27)

* bug fix; triggering storybooks ([87e7247](https://bitbucket.org/atlassian/atlaskit/commits/87e7247))
* bug fix; removed unused dependency on util-shared-styles from the Theme component ([253d8fc](https://bitbucket.org/atlassian/atlaskit/commits/253d8fc))

## 2.2.2 (2017-10-26)

* bug fix; fix to rebuild stories ([793b2a7](https://bitbucket.org/atlassian/atlaskit/commits/793b2a7))

## 2.2.1 (2017-10-22)

* bug fix; update styled components dep and react peerDep ([5539ada](https://bitbucket.org/atlassian/atlaskit/commits/5539ada))

## 2.2.0 (2017-09-27)

* feature; export "layers" from theme ([15aebe6](https://bitbucket.org/atlassian/atlaskit/commits/15aebe6))

## 2.1.0 (2017-09-13)

* feature; [@atlaskit](https://github.com/atlaskit)/theme now has a named getTheme() function export ([b727679](https://bitbucket.org/atlassian/atlaskit/commits/b727679))

## 2.0.1 (2017-08-11)

* bug fix; Add placeholder color to theme ([ba023fb](https://bitbucket.org/atlassian/atlaskit/commits/ba023fb))

## 2.0.0

Initial Release

repository: mironcao/jitsi-meet

repo_name: mironcao/jitsi-meet


text:
# Changelog

## 2019-10-11

### Added

- Added biomass widget
- Added height widget
- Added layer for biomass and height widget
- Added units in all the tooltips
- Added button to show open a modal with a detailed info of the widget

### Changed

- Unified decimals in all the widgets
- Changed sentences in all the widgets

### Fixed

- Fixed axis comma formatting for Activity widget
- Fixed an error where biomass widget breaks the application
- Fixed typo for the modal info in the widgets

## 2019-09-13

### Added

- Activity widget connected to real data
- Fullscreen control added to map

### Changed

- Widgets legend
- Widgets tooltip

## 2019-09-06

### Added

- Images for highlighted places
- First version of mangrove height widget
- Widget layer interactivity for coverage and net change widgets
- API end point for country ranking (activity widget).

### Changed

- Ipad styles
- Url fully parameterised
- Widget years order and units
- Styles adjusted in Highlighted hotspots

## 2019-08-29

### Added

- Mangrove Activity widget
- Map interactivity: Country, AOI (Rufiki and Saloum) dashboards.
- More Info modal for widgets
- Alerts Widget with provided data.
- Add tags for locations in search.

### Changed

- No data error for coverage widget
- Improved search button styles
- Update to<EMAIL_ADDRESS>- Select styles, km added to coverage tooltip
- Hardcoded continental USA boundaries for map.
- Added coverage Widget unit selector
- Improvements on net change widget.
- Mangrove coverage as default widget for desktop.
- WDPA labels appear on top of other layers.
- Refactor map component.
- Interactive Datepicker, month and year dropdown.
- Fix header scroll bug.

## 2019-08-09

### Changed

- Header layour changed.
- Header is fixed when user scrolls.

## 2019-08-02

### Added

- Countries list showed in alphabetical order.
- Hotspots included in Search countries modal.
- Header fixed on sidebar scroll.
- Language-selector.
- Storybook stories:
	- Map.
	- Header.
	- Modal.
	- Location modal.

### Changed

- Dates selector (arrow styles and functionality restricted).
- Global Styles adjusments.
- widget buttons styles.

## 2019-07-26

### Added

- API.
- Loader spinner.
- Storybook stories:
	- Chart.
	- Button group.
	- Spinner.

### Changed

- Widgets load.
- Widget download data link to component.
- Collapse widget button styles.
- Action Bar in header updated.
- Search modal interaction improved.

### Fixed

- Sentece in widget updated.

repository: Jinksi/mangrove-atlas

repo_name: Jinksi/mangrove-atlas


text:
The Pivot control and related tabs pattern are used for navigating frequently accessed, distinct content categories. Pivots allow for navigation between two or more content views and relies on text headers to articulate the different sections of content.

- Tapping on a pivot item header navigates to that header's section content.
- Swiping left or right on a pivot item header navigates to the adjacent section.
- Swiping left or right on section content navigates to the adjacent section.
- Pivots are stationary when all pivot headers fit within the allowed space.
- Pivots carousel when all pivot headers don't fit within the allowed space.

Tabs are a visual variant of Pivot that use a combination of icons and text or just icons to articulate section content.

repository: DannyFeliz/office-ui-fabric-vue

repo_name: DannyFeliz/office-ui-fabric-vue


text:
# Basic voltha install with helm

Minimal setup without seba pods.  Assumes a working k8s environment, single server or cluster.  Helm must also already be installed.  See other notes for k8s and helm setup.
This should be runnable as a non-root user assuming previous install steps allowed this.

## Verify Docker Repo Access

The docker images used are downloaded from the foundry docker repo docker-repo.dev.atl.foundry.att.com.   This repo requires your source public IP to be added to a whitelist before being able to download images.   Contact<EMAIL_ADDRESS>for access.

To test this access works run the following:

Test locally installed Foundry CA approves https server cert
```
curl -v https://docker-repo.dev.atl.foundry.att.com:5000/v2/_catalog
```

Test docker pull
```
docker pull docker-repo.dev.atl.foundry.att.com:5000/ubuntu:16.04
```

## Clone needed github repos

Checkout needed repos.  Some of this may exist if youve followed previous notes
```
cd ~/
mkdir -p source
cd ~/source
git clone https://github.com/donNewtonAlpha/voltha.git
git clone https://github.com/donNewtonAlpha/helm-charts.git
cd ~/

# this may exists if you used previous notes
ln -s ~/source/voltha/k8s/foundry-node/foundry-k8s-cluster
```

## Helm setup

Foundry specific values, currently dockers images from the foundry docker-repo
```
cd ~/source/helm-charts

helm repo add incubator https://kubernetes-charts-incubator.storage.googleapis.com/
helm repo add cord https://charts.opencord.org/master
helm repo update
helm repo list
```

## Install charts

Install Kafka and etcd-operator from hosted repos
```
helm install -n cord-kafka incubator/kafka --version 0.8.8 --set persistence.enabled=false --set zookeeper.persistence.enabled=false
helm install -n etcd-operator stable/etcd-operator

# wait until the 3 etcd CustomResourceDefinitions are added
kubectl get crd | grep etcd
```

Install etcd-operator managed etcd cluster
```
helm install -n etcd-cluster etcd-cluster

# wait until all 3 etcd-cluster-XXXX are Running
kubectl get pods -o wide |grep etcd-cluster
```

Install voltha.  Note the custom values.  There we define the docker images we want to run, and the kafka that we want voltha to share with xos and onos.
```
helm dep update voltha
helm install -n voltha voltha -f ~/foundry-k8s-cluster/simple-voltha-values.yaml
```

Install onos.  Values point to a custom onos image with aaa, olt and sadis apps built in.
```
helm dep update onos
helm install -n onos onos -f ~/foundry-k8s-cluster/simple-onos-values.yaml
```

Properly inject onos config for olt, aaa, and sadis
For now just run curl shell script to inject needed config.  xos/nem/seba will provide this later
```
cd ~/foundry-k8s-cluster
./quick-onos-update.sh master0 ~/source/voltha/onos-config/network-cfg.json
```

### Verify cluster operation

Login verify apps running.  Manually add subscribers if there is no radius available
```
ssh -p 30110 voltha@master0
# username/password voltha/admin
#   devices
#   table should say empty
#

ssh -p 30115 karaf@master0
# username/password karaf/karaf
#   apps -s -a
#   should list the installed apps
```

At this point you can use the voltha cli to preprovision and enable one or more edgecore OLT linecards.  Be sure to run bal_core_dist and openolt on the edgecore linecard.  Voltha will discover the onu, inform onos, and eap/dhcp should take over.

repository: donNewtonAlpha/voltha

repo_name: donNewtonAlpha/voltha


text:
UI Engineer (Product Research) Tech Test
========================================

Thank you for taking the time to do our technical test. It consists of two parts:

* [A coding test](#coding-test)
* [A few questions](#technical-questions)

In order to avoid bounced emails we would like you to submit your results by uploading the relevant zip file to a shared **Google Drive** folder. In order to obtain the URL for this folder, please supply your **Gmail** or **Google-based email address** to either your agent or the Just Eat member of staff who assigned you the test.

Please make this a **single** zip file named `{yourname}-{role-applied-for}.zip` containing:

1. one folder containing the coding test
2. a single markdown file with the answers to the questions

## Coding Test

The test is simple, just:

* Create an HTML file (and any additional CSS/JavaScript files you need) that does something with the JSON in [this sample of restaurant search results](restaurant-search-results.md).

The test is open-ended, but please don't feel you need to spend more than an hour on it. We're looking for code that is readable and that shows off your abilities, but most of all we want to see something interesting.

##  Questions

* What would you add to your test if you had more time?
* What's the best thing added to JavaScript in the last few years?
* What's a feature you wish existed when you're ordering takeaway online?
* What JSON would describe you?

Thanks for your time, we look forward to hearing from you!

gha_language: Scala


text:
# <%=servicePName%>

<%=servicePName%> description

A Micro service in GoLang based that
- enables fast development of [gRPC](https://grpc.io/) based micro services
- exposes the gRPC services as REST / Json via [grpc gateway](https://github.com/grpc-ecosystem/grpc-gateway) interface
- exposes metrics endpoint, which [Prometheus](https://prometheus.io/) could scrape from
- support tracing and metrics instrumentation using [OpenCensus](https://opencensus.io/)
- exposes health check end points
- defines state management interface. A default setup for [PostgreSQL](https://www.postgresql.org/)
- provides standard CLI
- build [Docker](https://www.docker.com/) container image
- enables [Kubernetes](https://kubernetes.io/) friendly deployment using [Helm charts](https://helm.sh/)
- enables consistent logging

## Getting Started

### Building
#### Pre-Req
- [Go 1.11](https://golang.org/dl/)
- [Docker](https://store.docker.com/search?q=&type=edition&offering=community)
- [Protocol Buffers 3.6.1](https://github.com/protocolbuffers/protobuf/releases)
- *[Kubernetes](https://docs.docker.com/docker-for-mac/kubernetes/)* - `Optional` If you want to deploy

#### Binary
`make`

#### Docker Image
`make docker-build`

### Development workflow
- Add your project specific flags / command line arguments in `cmd/<%=servicePName%>/server.go`
- Define your protobuf messaages and grpc services in `<%=servicePName%>.proto` file.
- Run `make gen`. This will generate requred structs and service methods from the proto file.
- Implement the business logic for your service methods in `pkg/server` package
- Run `make build`. This will build a binary `<%=pkgName%>` under `./bin` folder
- Often times the service needs to interact with some store. For example a sql store or a nosql store like mongo or bolddb. A Store interface defines all the persistence/repo methods and you there could be multiple implementations for the persistence layer. The store interface methods and various implmentations are defined in `pkg/state` package.

### Running

#### on localhost
After a successful build using make you can

`./bin/<%=pkgName%>`

#### on localhost using docker
Similarly you can the docker image after

`docker run --rm <%=pkgName%>:dev`

#### on a kubernetes cluster

`todo`

repository: vshiva/generator-go-micro-svc

repo_name: vshiva/generator-go-micro-svc


text:
# Recipe Scraper
A simple scraper to get around the fluff stuff (and ads!) in the the standard blog recipes you find on the web today. Gets the ingredients and directions. That's it.
## How To Use:
1. Make sure you have NodeJS installed on your machine.
2. Clone this repo to a directory of your choice.
3. Run ```npm install``` while in the same directory of this repo to install dependencies.
4. Then run ```node findRecipe.js``` to run scraper.
5. Follow the prompts to search for and save recipes.

## Example Usage:

After running ```node findRecipe.js```  in your terminal, it will ask you what you want to make. We'll say tacos (cause tacos are awesome). The recipe scraper will search google's top results for taco recipes and try to extract just the instructions and ingredients. While it does that it will display the urls it is currently searching, like this:

After it is done searching, it will display the first recipe it found.

From here, there are a few things you can do. Your options are displayed below the recipe.

You can view another recipe it found if you would like.

Or you can save the recipe to a .txt file by hitting highlighting convert recipe to txt file and hitting enter.

Finally, You can search for another recipe.

Hope you enjoy!

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

repository: jhigfolio/recipe-scraper

repo_name: jhigfolio/recipe-scraper


text:
## Packaging

### Issues:

 - Mapping from quark files/packages to backend namespace constructs
   is currently poorly defined, e.g. builtin does not go to a stable
   namespace so any constructs defined within cannot be used from
   outside of quark.

 - Further, this is difficult to fix because the "global" metadata
   produced by the compiler is specific to a given distro/compilation
   unit.

 - The quark "standard library" needs to be able to grow beyond what
   is manually included in builtin.q, e.g. for ardana we need to pull
   in functionality from hub.q.

 - Distributing quark packages is complex, because every quark library
   needs to be pushed via each backend package management system.

### Solutions:

 - We need to precisely define what constitutes a distributable unit
   and define an explicit mechanism for specifying dependencies
   between these distributable units.

 - By defining an explicit external dependency mechanism that
   references other quark files by URL, we have allowed for a single
   top level quark file to define a distribution unit that can be
   mapped into backend artifacts with proper dependencies.

 - By using URLs, we need no special package management
   infrastructure. Github and static web servers can function in the
   same role that pypi, maven central, etc does for other languages.

 - By building backend packages at the target rather than at the
   source, we can significantly simplify distribution since all we
   need to distribute is the url for the quary entrypoint itself.

### Packaging Model:

The quark distribution unit and compilation unit are one and the same.

package foo 1.2.3; <--- package statement, marks a quark file as an entrypoint and a distribution/compilation unit

use url-or-relative-path;  <--- use statement, declares a dependency on another distribution/compilation unit

namespace blah; <--- sets the default namespace for a file, if absent the namespace defaults to the package name

namespace bleh {} <--- sets the namespace for constructs within the braces, this is a top level namespace

namespace .blah {} <--- sets the namespace for the constructs within, but relative to the file's namespace

namespace foo.bar.baz {} <--- shorthand for nested namespace

namespace foo { <--- longhand for nested namespace
   namespace bar {
       namespace baz {
          ...;
       }
   }
}

include url-or-relative-path; <--- lexical inclusion

include url-or-relative-path.java; <--- include for java backend
include url-or-relative-path.py; <--- include for py backend

import foo; <--- import all names from a given namespace
import foo.Bar; <--- import a single name
import foo as bar; <--- alias a namespace
import foo.Bar as Baz; <--- alias a name

$java {
  java statement
}

$py {
  python statement
}

$ruby {
  ruby statement
}

$java(java expression)

$py(python expression)

dep <group> <name> <version>; <--- does this work for non maven/gradle stuff?

Distribution Unit == Compilation Unit == file/url-that-is-passed-to-compiler == later maybe replaced with construct in entry-point file that includes name, version, and possibly allows for customization of how name is mapped to backend package.

Namespace is independent of distribution unit.

A single distribution unit unit may bring with it many namespaces.

use statement specifies dependencies between distribution units

include statement operates as textual include

Import/alias statement operates on namespaces.

include mechanism also operates on native files

how do included files get pulled into namespace? -- maybe not at all, include foo.py and then native statement to import foo
need native statement construct

```
entry.q:
  use http://example.org/foo.q;
  use foo/bar/baz.q;
  ...
  include qux.q;
  ...
  p1.p2.p3.Bar;

  import p1.p2.p3.Bar as Bar;
  import p1.p2.p3.*;
```

```
use --> inter-project dependency, not an import
  for python install_requires or requirements.txt
  for js this means depencey in package.json
  for java this means dependency in pom.xml

include --> intra-project dependency, i.e. like catting the files together

distribution package vs namespace package

pip install foo --> distribution package
import foo --> namespace package

build A.q --> B.2

   A.whl --> B.whl

quark install A.q produces A.whl --> B.whl
  B.q           is correct whl intalled? if no build and install
  builtin.q
  directory.q

quark install A.q

pip install slack --> slack and datawire-quark-core

we replace builtin with these two implicit statements at the start of every .q file:
  use http://github.blah/master/datawire-quark-core.q;
  import datawire.*;

hello service

hello.q --> hub.q;
goodbye.q --> hub.q;

hub.q has a singleton routing table;

quark freeze hello.q goodbye.q --> one giant static thing;

1. simplify our release process
2. be able to actually use quark to spec out the full runtime API

use "users.q";
//  -- or --
use "http://users.blah.com/v1/users.q";
//  -- or --
use "http://users.blah.com/users.q";

include "util.q"; // the same as use except "statically links" util.q
                  // into the current distribution unit

// With this statement as a pure extension of the current quark model,
// the names made available by an include statement have no *enforced*
// relationship with the argument passed to use.

// This makes it difficult to figure out where stuff is defined from
// reading its usage.

// We could make file name == top level package. File names would
// become important, and we would address the above issue. With just
// this change, builtin becomes magic or we need a way to do from blah
// import *, e.g.:

from "builtin.q" include *

// We could decouple these things, e.g.:

use "builtin.q";
from builtin import *;

foo/user.q:
include "user/one.q";
include "user/two.q";

namespace user {
  from one export *;
  from two export *;
}

foo/user/one.q:
namespace user.one {
}

foo/user/two.q:
namespace user.two {
}

//===============

user.q:
include "user/one.q";
include "user/two.q";
namespace user {

}

one.q:
namespace user {
    // stuff
}

two.q:
namespace user {
    // other stuff
}

// Magic path becomes a concern here. We don't want to have classpath
// hell.

package hello {

    class Request {...}
    class Response {...}

    interface Hello extends Service {
        @delegate(rpc)
        Response hello(Request request);

        @delegate(rpc)
        users.User introduction(); // I can do this because User is defined in users.q
    }

    class HelloClient extends Client, Hello  {}
    class HelloServer extends Server<Hello> {}

}

// What happens if I am a user that has both a direct dependency on
// users and an indirect dependency on users via the hello service?
//  - Do I need to compile all my service dependencies in one go?
//  - Can we be smart enough to produce backend packages with the
//    right set of interdependencies?
//  - What do users actually want here?

// How do we tell where the boundaries between distriution units are?
// We want the hello.q distribution unit to depend on the users.q
// distribution unit, however hello.q might include/import/use some
// sort of util.q which is in a separate file, but does not want to be
// independently distributed. In this example we want to "refer to"
// users, but "contain" util.

pip install datawire-quark                         # Wow, this quark thing is super easy to install!

-- pick your language --

quark package --python https://hello.datawire.io/hello.q
pip install hello/py/dist/hello*.whl --user
python
>>> import hello
>>> hello.Client().hello("foo")                    # Wow, its super easy to access the hello service with a real API (as opposed to reading tons of english)
"Hello foo, greetings from datawire!"

quark package --python https://slack.datawire.io/slack.q
pip install slack/py/dist/slack*.whl --user
python
>>> import slack
>>> client = slack.SlackClient("*api-token*")
>>> client.post("#lobby", "Hello world!")          # Wow, I just accessed the slack service without reading through pages of documentation to understand their calling convention.
```

repository: bozzzzo/quark

repo_name: bozzzzo/quark


text:
# Udacity: Secret Message
A python program to encode and decode secret messages.

#Purpose
This program was created as part of a Udacity nanodegree course.  The course itself provided the tools to create a basic cipher program. I then took the program a step further but adding more functionality. The messages are presented via image files rather than through console output.  Additional functionality could possibly provide a solution for both.

I am new to python and have zero experience in real cryptography.  This program is for learning purposes.

#Changelog
coming soon

repository: crmontgomery/udacity-secret-message

gha_language: Python

repo_name: crmontgomery/udacity-secret-message


text:
---
customer: CNES
customer_long: Centre National d'Etudes Spatiales
prime_contractor:
image: Project-CNES-CHRONOS-EN pict 1.png
size: small
name: CHRONOS
title: Realization of a processing orchestrator and mission for SWOT
domains: Platform
department: SPACE
program: Generic
domains: Platform
summary: "Design, build and commission a generic processing orchestrator for the SWOT data production centre."
---

> __Customer__\: Centre National d'Etudes Spatiales (CNES)

> __Programme__\: Generic

> __Supply Chain__\: CNES >  CS Group SPACE

# Context

CS Group responsabilities for Realization of a processing orchestrator and mission for SWOT are as follows:
* Specification & Design
* Realization of developments
* Mission Statement

![Main Picture](Project-CNES-CHRONOS-EN pict 1.png)

The features are as follows:
* Running workflows on local, HPC or Cloud resources (no locking)
* Exploitation:
	* Ergonomic and modern web HMI;
	* Monitoring the execution of workflows;
	* Visualization of the links between input data, processing chains and output data;
	* Alerts and acknowledgements;
	* Access to logs, execution contexts, pause/resume.
* Monitoring: HMI activity report; System status monitoring.
* Security: Management of access rights; High availability.
* Efficient: 200K tasks / day, 100M processing instances, 500M references.

# Project implementation

The project objectives are as follows:
* Design, build and commission a generic processing orchestrator for the SWOT data production centre.

The processes for carrying out the project are:
* Software V-Model, Requirement engineering, Continuous Integration

# Technical characteristics

The solution key points are as follows:
* HPC/Cloud hybridization for running processing workflows using Apache Mesos and SafeScale™
* Workflow description with CWL standard
* Integration of many COTS and in particular the TOIL workflow manager
* Micro-service architecture
* Easy to maintain: API; Extension points for HMIs; Extensible data model.

The main technologies used in this project are:

{:class="table table-bordered table-dark"}
| Domain | Technology(ies) |
|--------|----------------|
|Operating System(s)|Linux RH Secure|
|Programming language(s)|Java, Python, SQL|
|Interoperability (protocols, format, APIs)|CWL, REST, AMQP, Yaml, XML|
|Production software (IDE, DEVOPS etc.)|Git|
|Main COTS library(ies)|Hibernate, JAXB, AdminLTE, GFal2, Spring, Docker, Postgresql, RabbitMQ, IPA, KeyCloack, ElasticStack, GitLab, Centreon, Toil, Apache Mesos, SafeScale, Apache Atlas, Ansible, AWX|

{::comment}Abbreviations{:/comment}

*[CLI]: Command Line Interface
*[IaC]: Infrastructure as Code
*[PaaS]: Platform as a Service
*[VM]: Virtual Machine
*[OS]: Operating System
*[IAM]: Identity and Access Management
*[SIEM]: Security Information and Event Management
*[SSO]: Single Sign On
*[IDS]: intrusion detection
*[IPS]: intrusion prevention
*[NSM]: network security monitoring
*[DRMAA]: Distributed Resource Management Application API is a high-level Open Grid Forum API specification for the submission and control of jobs to a Distributed Resource Management (DRM) system, such as a Cluster or Grid computing infrastructure.