text:
# 3x3x3

### R3D1R1

       000
       000
       001
<PHONE_NUMBER>44
<PHONE_NUMBER>44
<PHONE_NUMBER>33
       553
       555
       225

Found by: @TehPers
Significance: Top face value is 1

### U3D1R3L1F3B1U1D3

       242
       202
       242
<PHONE_NUMBER>13
<PHONE_NUMBER>43
<PHONE_NUMBER>13
       424
       454
       424

Found by: @aaronryank
Significance: Left face value is 1

### U1R3U1F3D2

       000
       000
       544
<PHONE_NUMBER>22
<PHONE_NUMBER>44
<PHONE_NUMBER>22
       255
       255
       110

Found by: ?
Significance: Has a period of 1260, the highest period a 3x3x3 cube can have for any given set of rotations.

repository: Cubically/algorithms

repo_name: Cubically/algorithms


text:
---
title: "Low expectations"
date: "2013-10-05 12:00:00"
categories: ["politics"]
---

> Switzerland will hold a vote on whether to introduce a basic income for all adults, in a further sign of growing public activism over pay inequality since the financial crisis. A grassroots committee is calling for all adults in Switzerland to receive an unconditional income of 2,500 Swiss francs (2,800 USD) per month from the state, with the aim of providing a financial safety net for the population. Reuters via Basic Income UK

As you're no doubt very bored of hearing, I'm interested in the idea of a Basic Citizen Income: a non–withdrawable, non–means tested income for every UK citizen, regardless of employment status, age and marital status.

I blogged [a couple of examples of how it might work in the UK](/2013/09/basic-income-examples/), using figures published by Dr Malcolm Torry. Unfortunately, it'll never happen, due to our punitive attitude to poor people.

What's interesting about the Swiss proposal is the amount they'll be voting on. In the UK 2800 USD amounts to about £1750, i.e. the average full–time worker's net pay.

In my examples, anyone over the age of 24 would receive £308 a month, *around £1400 less than in Switzerland*. And yet it still seems a million miles away. (Note: Dr Torry's figures assume housing and council tax benefits remain the same. They substantially increase UK state derived income.)

What does this say about UK expectations of pay and quality of life?

license: MIT

repository: eklausme/saaze-paternoster

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: eklausme/saaze-paternoster


text:
---
type: rule
archivedreason:
title: Do you make sure the Primary Field is always the first column in a view?
guid: 2d7b56ea-cd7d-4b02-950b-ba4a662594ee
uri: make-sure-the-primary-field-is-always-the-first-column-in-a-view
created: 2020-06-29T21:32:13.0000000Z
authors:
- title: Adam Cogan
  url: https://ssw.com.au/people/adam-cogan
- title: Mehmet Ozdemir
  url: https://ssw.com.au/people/mehmet-ozdemir
related: []
redirects:
- do-you-make-sure-the-primary-field-is-always-the-first-column-in-a-view

---

When modifying existing or creating custom views in Dynamics (or Model-driven PowerApps) always pay special attention to the first column. The first column should always contain the Primary Field for the entity that the view is based on. For example, all views for Opportunities should use Topic (name), Contacts should use Full Name (fullname) as the first column.

The reason for this is the Primary Field in a view displays as a hyperlink to the underlying record. It is very convenient (and natural) to click the first item in the view, as this will then take you to the record. If any other field is used the user will either need to double click the row to navigate to the record (non-lookup) or will be taken to a completely different entities record (lookup field).

Some examples below:

<!--endintro-->

::: bad
![Bad Example: A lookup field is the first column](bad-primary-field.png)
:::

In this example Account is the first column in the view, the natural tendency is the click the first column, and seeing that it's a hyperlink further confirms to the user that this is something they can click on. Clicking the first column ("Northwind Traders") would navigate to the Northwind Traders Account form and not the Opportunity form for Northwind Traders.

::: bad
![Bad Example: A regular field is the first column](bad-primary-field-2.png)
:::

In this example Probability is the first column in the view, again users tend to click the first column in the view. In this example, a single click would select the entire row (with tick box selected to the left of the grid), and a double click on the first column would navigate to the Opportunity record.

::: good
![Good Example: Primary Field is the first column](good-primary-field.png)
:::

In this example, the Primary Field is the first column of the view, and single-clicking the first column view navigates to the opportunity record as expected.

### Summary

Understanding column ordering in view is import and making sure the first column in a view is always the Primary Field will make much easier for your users.

branch_name: refs/heads/main


text:
# Accessible Form Fields

This guide sets out the accessible implementation of form fields, covering text inputs, radio buttons, checkboxes, and `<select>` elements. For further guidance specific to mobile/native applications, please consult the [BBC Mobile Accessibility Guidelines](http://www.bbc.co.uk/guidelines/futuremedia/accessibility/mobile/forms/labelling-form-controls). For field validation advice, see [Accessible Form Validation](/validation).

## Native form elements

The most efficient and robust way to implement accessible form fields is to use the native `<input>`, `<textarea>`, and `<select>` elements. These elements have predefined and expected behaviors, and automatically communicate their roles, values, and states to assistive technologies.

It is _possible_ to emulate native form element behavior with WAI-ARIA attribution and JavaScript, but it
is rarely a good idea. Implementations tend towards complexity, and are necessarily more likely
to break because they depend on JavaScript in order to function.

```html
<!-- native -->
<input type="checkbox">

<!-- WAI-ARIA (requiring JavaScript to switch the checked state) -->
<div role="checkbox" aria-checked="false" tabindex="0"></div>
```

It is also not possible to access and serialize non-native form elements using methods like `FormData()` because the elements cannot be identified to their parent form. This is because they do not support the `name` attribute.

```js
var form = document.querySelector("form");
var data = new FormData(form); // Would be empty
```

### Input types

Where specialist HTML5 input types are well supported, it is advised they are used in place of the generic (and default) `type="text"`. The `number` `type`, for example, helpfully restricts input to numerals, allows incrementation—typically by providing up and down buttons—and elicits the display of a numerical virtual keyboard.

### Visual design

It's imperative form elements are easily recognizable, so the authored visual design should not stray far from operating system and user agent conventions.

- Radio buttons should be round
- Checkboxes should be square
- Select elements should include a downwards pointing arrow
- Text fields should appear as a bordered box that a user enters text into

Styling some form elements directly is difficult, but you can 'defer' styles from a visually hidden input to a proxy element. Consider the following markup:

```html
<label>
  <input type="checkbox" class="visually-hidden">
  <span class="fake-checkbox">
    <span class="fake-check" aria-hidden="true">✓</span>
  </span>
  <span class="text">The label</span>
</label>
```

We can style the `fake-checkbox` element's `:focus` and `:checked` states, like so:

```css
.fake-check {
  display: none; /* hide to begin with */
}

[type="checkbox"]:focus + .fake-checkbox {
  box-shadow: 0 0 0 0.125rem blue;
}

[type="checkbox"]:checked + .fake-checkbox .fake-check {
  display: inline-block;
}
```

**Note:** A unicode point (as in the example) can be used, but should be hidden using `aria-hidden="true"` so that the value is not interpreted in screen readers. A custom SVG would be preferable. Do not use a `background-image` because it is liable to be eliminated in high contrast themes.

## Labels

All controls within a web application need labels to identify them. Typically, `<button>`s and links are labeled by their text content. Form elements are conventionally labeled _by association_ to a `<label>` element. This associative relationship is created by making the form element's `id` and the `<label>`'s `for` attribute share the same value. In the following example, the shared value is `dog`.

```html
<label for="dog">Your dog's name</label>
<input type="text" id="dog" name="dog">
```

In this example, a screen reader user would hear _"Your dog's name, text input"_ (or similar) upon focusing the `<input>`. Since screen reader users tend to traverse forms by focus, from field to field, it is only by associating the label to the field directly that they would hear the label text. An unassociated label would simply be 'skipped over'.

**Note:** It is a common misconception that the `name` attribute is used in label calculation. Although it often takes the same value as the `id`, it is only the `id` that associates the label to the input.

### Group labels

Sometimes multiple form elements should be grouped together under a common label. The standard method for creating such a group is with the `<fieldset>` and `<legend>` elements. The `<legend>` must be the first child inside the `<fieldset>`.

```html
<fieldset>
  <legend>Group label</legend>
  <!-- individually labeled elements -->
</fieldset>
```

This is most important when providing radio button controls: a group of radio buttons, sharing a common `name` attribute, constitute _a single_ form field and the `<legend>` labels this field.

```html
<fieldset>
  <legend>Your favorite pet</legend>
  <label>
    <input type="radio" name="favorite-pet">
    Cat
  </label>
  <label>
    <input type="radio" name="favorite-pet">
    Dog
  </label>
  <label>
    <input type="radio" name="favorite-pet">
    Seahorse
  </label>
</fieldset>
```

Note the use of labels _wrapping_ inputs in the above example. Only when wrapping inputs in `<label>`s can you omit the `for` and `id` association. It is a common pattern for radios and checkboxes.

It's quite legitimate to place headings inside `<legend>`s. In fact, this helps to give your form a semantic structure (navigable by screen reader users) without having to create separate and redundant labels.

```html
<fieldset>
  <legend><h2>Group label</h2></legend>
  <!-- individually labeled elements -->
</fieldset>
```

The usual rules regarding heading levels and nesting apply. That is, if you were to include a nested fieldset, the heading level should reflect the parent/child structure.

```html
<fieldset>
  <legend><h2>Group label</h2></legend>
  <!-- individually labeled elements -->
  <fieldset>
    <legend><h3>Nested group label</h3></legend>
    <!-- individually labeled elements -->
  </fieldset>
</fieldset>
```

### Placeholders

The `placeholder` attribute should not supplant the `<label>` element as a primary label for the following reasons:

- Not all assistive technologies support placeholders
- Some users perceive inputs displaying placeholders as already completed
- When the placeholder is replaced with a value, no label is available for checking the value against the requirement
- The default text color for placeholders fails WCAG contrast requirements in many browsers

Use placeholders sparingly, and as intend, to provide hints. To help differentiate placeholder text from a real value, use an italic style and prefix the placeholder text with _"E.g."_ or similar.

### Descriptions

Where space permits (and the visual design should allow for this), use descriptions in place of placeholders. Descriptions can simply be part of the `<label>` and will therefore be part of accessible label calculation.

In the following example, the `<small>` element is used to demarcate the description visually. By default, it will display smaller text. You can place it on a new line by applying `display: block`. Note that `<label>` elements are inline level, so it is non-conforming to include block elements inside them.

```html
<label for="dog">
  Your dog's name
  <small>For example: 'Doggy McDog-Face'</small>
</label>
<input type="text" id="dog" name="dog">
```

### Invisible labels

It is strongly recommended that form fields have visible and persistent labels; labels that do not disappear upon focus or input.

However, in some specific circumstances an invisible but accessible label is acceptable. For example, a single input search form may have a submit button that reads "Search" — effectively providing a label for both the input and the button itself. In this case, you can hide the `<label>` visually, using a technique that keeps the label available to assistive technologies.

```html
<label for="search" class="visually-hidden">Your search term</label>
<input id="search">
<button type="submit">Search</button>
```

The `visually-hidden` utility class looks like the following. Incorrectly using `display: none` would hide the label _both_ visually and from assistive technologies.

```css
.visually-hidden {
  clip-path: inset(100%);
  clip: rect(1px, 1px, 1px, 1px);
  height: 1px;
  width: 1px;
  overflow: hidden;
  position: absolute;
  white-space: nowrap;
}
```

Invisible group labels can work in much the same way:

```html
<h2>Group label</h2>
<fieldset>
  <legend class="visually-hidden">Group label</legend>
  <!-- individually labeled elements -->
</fieldset>
```

In most circumstances group labels, like labels, should be visible. Hence, in the example, the group label is only hidden because a separate heading with the same information is already provided.

### Visual design

- Place labels _above_ form elements. This is especially important on mobile platforms because the invoked virtual keyboard has a habit of obscuring labels to the side or below inputs.
- As stated in the [BBC Mobile Accessibility Guidelines](http://www.bbc.co.uk/guidelines/futuremedia/accessibility/mobile/forms/form-layout), labels should be placed more closely to their associated form elements.
- Descriptions should appear below the principle label text, in a smaller font size


text:
[![Build Status](https://travis-ci.org/SumoLogic/fluentd-kubernetes-sumologic.svg?branch=master)](https://travis-ci.org/SumoLogic/fluentd-kubernetes-sumologic) [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/SumoLogic/fluentd-output-sumologic/issues)

This page describes the Sumo Kubernetes [Fluentd](http://www.fluentd.org/) plugin.

## Support
The code in this repository has been developed in collaboration with the Sumo Logic community and is not supported via standard Sumo Logic Support channels. For any issues or questions please submit an issue within the GitHub repository. The maintainers of this project will work directly with the community to answer any questions, address bugs, or review any requests for new features.

## Installation

The plugin runs as a Kubernetes [DaemonSet](http://kubernetes.io/docs/admin/daemons/); it runs an instance of the plugin on each host in a cluster. Each plugin instance pulls system, kubelet, docker daemon, and container logs from the host and sends them, in JSON or text format, to an HTTP endpoint on a hosted collector in the [Sumo](http://www.sumologic.com) service.  Note the plugin with default configuration requires Kubernetes >=1.8.  See [the section below on running this on Kubernetes <1.8](#running-on-kubernetes-versions-<1.8)

- [Step 1  Create hosted collector and HTTP source in Sumo](#step-1--create-hosted-collector-and-http-source-in-sumo)
- [Step 2  Create a Kubernetes secret](#step-2--create-a-kubernetes-secret)
- [Step 3  Install the Sumo Kubernetes FluentD plugin](#step-3--install-the-sumo-kubernetes-fluentd-plugin)
  * [Option A  Install plugin using kubectl](#option-a--install-plugin-using-kubectl)
  * [Option B  Helm chart](#option-b--helm-chart)
- [Environment variables](#environment-variables)
    + [Override environment variables using annotations](#override-environment-variables-using-annotations)
    + [Exclude data using annotations](#exclude-data-using-annotations)
    + [Include excluded using annotations](#include-excluded-using-annotations)
- [Step 4 Set up Heapster for metric collection](#step-4-set-up-heapster-for-metric-collection)
  * [Kubernetes ConfigMap](#kubernetes-configmap)
  * [Kubernetes Service](#kubernetes-service)
  * [Kubernetes Deployment](#kubernetes-deployment)
- [Log data](#log-data)
  * [Docker](#docker)
  * [Kubelet](#kubelet)
  * [Containers](#containers)
- [Taints and Tolerations](#taints-and-tolerations)
- [Running On OpenShift](#running-on-openshift)

![deployment](https://github.com/SumoLogic/fluentd-kubernetes-sumologic/blob/master/screenshots/kubernetes.png)

# Step 1  Create hosted collector and HTTP source in Sumo

In this step you create, on the Sumo service, an HTTP endpoint to receive your logs. This process involves creating an HTTP source on a hosted collector in Sumo. In Sumo, collectors use sources to receive data.

1. If you don’t already have a Sumo account, you can create one by clicking the **Free Trial** button on https://www.sumologic.com/.
2. Create a hosted collector, following the instructions on [Configure a Hosted Collector](https://help.sumologic.com/Send-Data/Hosted-Collectors/Configure-a-Hosted-Collector) in Sumo help. (If you already have a Sumo hosted collector that you want to use, skip this step.)
3. Create an HTTP source on the collector you created in the previous step. For instructions, see [HTTP Logs and Metrics Source](https://help.sumologic.com/Send-Data/Sources/02Sources-for-Hosted-Collectors/HTTP-Source) in Sumo help.
4. When you have configured the HTTP source, Sumo will display the URL of the HTTP endpoint. Make a note of the URL. You will use it when you configure the Kubernetes service to send data to Sumo.

# Step 2  Create a Kubernetes secret

Create a secret in Kubernetes with the HTTP source URL. If you want to change the secret name, you must modify the Kubernetes manifest accordingly.

`kubectl create secret generic sumologic --from-literal=collector-url=INSERT_HTTP_URL`

You should see the confirmation message

`secret "sumologic" created.`

# Step 3  Install the Sumo Kubernetes FluentD plugin

Follow the instructions in Option A below to install the plugin using `kubectl`. If you prefer to use a Helm chart, see Option B.

Before you start, see [Environment variables](#environment-variables) for information about settings you can customize, and how to use annotations to override selected environment variables and exclude data from being sent to Sumo.

## Option A  Install plugin using kubectl

See the sample Kubernetes DaemonSet and Role in [fluentd.yaml](/daemonset/rbac/fluentd.yaml).

1. Clone the [GitHub repo](https://github.com/SumoLogic/fluentd-kubernetes-sumologic).

2. In `fluentd-kubernetes-sumologic`, install the chart using `kubectl`.

Which `.yaml` file you should use depends on whether or not you are running RBAC for authorization. RBAC is enabled by default as of Kubernetes 1.6.  Note the plugin with default configuration requires Kubernetes >=1.8. See the section below on [running this on Kubernetes <1.8](#running-on-kubernetes-versions-<1.8)

**Non-RBAC (Kubernetes 1.5 and below)**

`kubectl create -f /daemonset/nonrbac/fluentd.yaml`

**RBAC (Kubernetes 1.6 and above)**

`kubectl create -f /daemonset/rbac/fluentd.yaml`

**Note** if you modified the command in Step 2 to use a different name, update the `.yaml` file to use the correct secret.

Logs should begin flowing into Sumo within a few minutes of plugin installation.

## Option B  Helm chart
If you use Helm to manage your Kubernetes resources, there is a Helm chart for the plugin at https://github.com/kubernetes/charts/tree/master/stable/sumologic-fluentd.

# Environment variables

Environment | Variable Description
----------- | --------------------
`AUDIT_LOG_PATH`|Define the path to the [Kubernetes Audit Log](https://kubernetes.io/docs/tasks/debug-application-cluster/audit/)

 Default: `/mnt/log/kube-apiserver-audit.log`
`CONCAT_SEPARATOR` |The character to use to delimit lines within the final concatenated message. Most multi-line messages contain a newline at the end of each line.

 Default: ""
`EXCLUDE_CONTAINER_REGEX` |A regular expression for containers. Matching containers will be excluded from Sumo. The logs will still be sent to FluentD.
`EXCLUDE_FACILITY_REGEX`|A regular expression for syslog [facilities](https://en.wikipedia.org/wiki/Syslog#Facility). Matching facilities will be excluded from Sumo. The logs will still be sent to FluentD.
`EXCLUDE_HOST_REGEX`|A regular expression for hosts. Matching hosts will be excluded from Sumo. The logs will still be sent to FluentD.
`EXCLUDE_NAMESPACE_REGEX`|A regular expression for `namespaces`. Matching `namespaces` will be excluded from Sumo. The logs will still be sent to FluentD.
`EXCLUDE_PATH`|Files matching this pattern will be ignored by the `in_tail` plugin, and will not be sent to Kubernetes or Sumo. This can be a comma-separated list as well. See [in_tail](http://docs.fluentd.org/v0.12/articles/in_tail#excludepath) documentation for more information.

 For example, defining `EXCLUDE_PATH` as shown below excludes all files matching `/var/log/containers/*.log`,

`...`

`env:`
   - `name: EXCLUDE_PATH`
         `value: "[\"/var/log/containers/*.log\"]"`
`EXCLUDE_POD_REGEX`|A regular expression for pods. Matching pods will be excluded from Sumo. The logs will still be sent to FluentD.
`EXCLUDE_PRIORITY_REGEX`|A regular expression for syslog [priorities](https://en.wikipedia.org/wiki/Syslog#Severity_level). Matching priorities will be excluded from Sumo. The logs will still be sent to FluentD.
`EXCLUDE_UNIT_REGEX` |A regular expression for `systemd` units. Matching units will be excluded from Sumo. The logs will still be sent to FluentD.
`FLUENTD_SOURCE`|Fluentd can tail files or query `systemd`. Allowable values: `file`, `Systemd`.

Default: `file`
`FLUENTD_USER_CONFIG_DIR`|A directory of user-defined fluentd configuration files, which must be in the  `*.conf` directory in the container.
`FLUSH_INTERVAL` |How frequently to push logs to Sumo.

Default: `5s`
`KUBERNETES_META`|Include or exclude Kubernetes metadata such as `namespace` and `pod_name` if using JSON log format.

Default: `true`
`KUBERNETES_META_REDUCE`| Reduces Kubernetes metadata, check [Reducing Kubernetes Metadata](#####reduce-kubernetes-metadata-using-annotations).

Default: `false`
`LOG_FORMAT`|Format in which to post logs to Sumo. Allowable values:

`text`—Logs will appear in SumoLogic in text format.
`json`—Logs will appear in SumoLogic in json format.
`json_merge`—Same as json but if the container logs in json format to stdout it will merge in the container json log at the root level and remove the log field.

Default: `json`
`MULTILINE_START_REGEXP`|The regular expression for the `concat` plugin to use when merging multi-line messages. Defaults to Julian dates, for example, Jul 29, 2017.
`NUM_THREADS`|Set the number of HTTP threads to Sumo. It might be necessary to do so in heavy-logging clusters.

Default: `1`
`READ_FROM_HEAD`|Start to read the logs from the head of file, not bottom. Only applies to containers log files. See in_tail doc for more information.

Default: `true`
`SOURCE_CATEGORY` |Set the `_sourceCategory` metadata field in Sumo.

Default: `"%{namespace}/%{pod_name}"`
`SOURCE_CATEGORY_PREFIX`|Prepends a string that identifies the cluster to the `_sourceCategory` metadata field in Sumo.

Default:  `kubernetes/`
`SOURCE_CATEGORY_REPLACE_DASH` |Used to replace a dash (-) character with another character.

Default:  `/`

For example, a Pod called `travel-nginx-3629474229-dirmo` within namespace `app` will appear in Sumo with `_sourceCategory=app/travel/nginx`.
`SOURCE_HOST`|Set the `_sourceHost` metadata field in Sumo.

Default: `""`
`SOURCE_NAME`|Set the `_sourceName` metadata field in Sumo.

 Default: `"%{namespace}.%{pod}.%{container}"`
`TIME_KEY`|The field name for json formatted sources that should be used as the time. See [time_key](https://docs.fluentd.org/v0.12/articles/formatter_json#time_key-(string,-optional,-defaults-to-%E2%80%9Ctime%E2%80%9D)). Default: `time`
`ADD_TIMESTAMP`|Option to control adding timestamp to logs. Default: `true`
`ADD_STREAM`|Option to control adding stream to logs. Default: `true`
`ADD_TIME`|Option to control adding time to logs. Default: `true`
`CONTAINER_LOGS_PATH`|Specify the path in_tail should watch for container logs. Default: `/mnt/log/containers/*.log`
`PROXY_URI`|Add the uri of the proxy environment if present.
`ENABLE_STAT_WATCHER`|Option to control the enabling of [stat_watcher](https://docs.fluentd.org/v1.0/articles/in_tail#enable_stat_watcher). Default: `true`
`K8S_METADATA_FILTER_WATCH`|Option to control the enabling of [metadata filter plugin watch](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration). Default: `true`
`K8S_METADATA_FILTER_CA_FILE`|Option to control the enabling of [metadata filter plugin ca_file](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration).
`K8S_METADATA_FILTER_VERIFY_SSL`|Option to control the enabling of [metadata filter plugin verify_ssl](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration). Default: `true`
`K8S_METADATA_FILTER_CLIENT_CERT`|Option to control the enabling of [metadata filter plugin client_cert](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration).
`K8S_METADATA_FILTER_CLIENT_KEY`|Option to control the enabling of [metadata filter plugin client_key](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration).
`K8S_METADATA_FILTER_BEARER_TOKEN_FILE`|Option to control the enabling of [metadata filter plugin bearer_token_file](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration).
`K8S_METADATA_FILTER_BEARER_CACHE_SIZE`|Option to control the enabling of [metadata filter plugin cache_size](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration). Default: `1000`
`K8S_METADATA_FILTER_BEARER_CACHE_TTL`|Option to control the enabling of [metadata filter plugin cache_ttl](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#configuration). Default: `3600`
`K8S_NODE_NAME`|If set, improves [caching of pod metadata](https://github.com/fabric8io/fluent-plugin-kubernetes_metadata_filter#environment-variables-for-kubernetes) and reduces API calls.

The following table show which  environment variables affect which Fluentd sources.

| Environment Variable | Containers | Docker | Kubernetes | Systemd |
|----------------------|------------|--------|------------|---------|
| `EXCLUDE_CONTAINER_REGEX` | ✔ | ✘ | ✘ | ✘ |
| `EXCLUDE_FACILITY_REGEX` | ✘ | ✘ | ✘ | ✔ |
| `EXCLUDE_HOST_REGEX `| ✔ | ✘ | ✘ | ✔ |
| `EXCLUDE_NAMESPACE_REGEX` | ✔ | ✘ | ✔ | ✘ |
| `EXCLUDE_PATH` | ✔ | ✔ | ✔ | ✘ |
| `EXCLUDE_PRIORITY_REGEX` | ✘ | ✘ | ✘ | ✔ |
| `EXCLUDE_POD_REGEX` | ✔ | ✘ | ✘ | ✘ |
| `EXCLUDE_UNIT_REGEX` | ✘ | ✘ | ✘ | ✔ |
| `TIME_KEY` | ✔ | ✘ | ✘ | ✘ |

### FluentD stops processing logs
When dealing with large volumes of data (TB's from what we have seen), FluentD may stop processing logs, but continue to run.  This issue seems to be caused by the [scalability of the inotify process](https://github.com/fluent/fluentd/issues/1630) that is packaged with the FluentD in_tail plugin.  If you encounter this situation, setting the `ENABLE_STAT_WATCHER` to `false` should resolve this issue.

### Override environment variables using annotations
You can override the `LOG_FORMAT`, `KUBERNETES_META_REDUCE`, `SOURCE_CATEGORY` and `SOURCE_NAME` environment variables, per pod, using [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/). For example:

```
apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx
spec:
  replicas: 1
  selector:
    app: mywebsite
  template:
    metadata:
      name: nginx
      labels:
        app: mywebsite
      annotations:
        sumologic.com/format: "text"
        sumologic.com/kubernetes_meta_reduce: "true"
        sumologic.com/sourceCategory: "mywebsite/nginx"
        sumologic.com/sourceName: "mywebsite_nginx"
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
```

### Reduce Kubernetes Metadata using annotations
You can also use the "sumologic.com/kubernetes_meta_reduce" annotation to exclude `pod_id`,
`container_id`, `namespace_id`, `namespace_name`, `master_url` and `labels` from Kubernetes Metadata.
```
apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx
spec:
  replicas: 1
  selector:
    app: mywebsite
  template:
    metadata:
      name: nginx
      labels:
        app: mywebsite
      annotations:
        sumologic.com/kubernetes_meta_reduce: "true"
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
```

### Exclude data using annotations

You can also use the `sumologic.com/exclude` annotation to exclude data from Sumo. This data is sent to FluentD, but not to Sumo.

```
apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx
spec:
  replicas: 1
  selector:
    app: mywebsite
  template:
    metadata:
      name: nginx
      labels:
        app: mywebsite
      annotations:
        sumologic.com/format: "text"
        sumologic.com/sourceCategory: "mywebsite/nginx"
        sumologic.com/sourceName: "mywebsite_nginx"
        sumologic.com/exclude: "true"
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
```

### Include excluded using annotations

If you excluded a whole namespace, but still need one or few pods to be still included for shipping to Sumologic, you can use the `sumologic.com/include` annotation to include data to Sumo. It takes precedence over the exclusion described above.

```
apiVersion: v1
kind: ReplicationController
metadata:
  name: nginx
spec:
  replicas: 1
  selector:
    app: mywebsite
  template:
    metadata:
      name: nginx
      labels:
        app: mywebsite
      annotations:
        sumologic.com/format: "text"
        sumologic.com/sourceCategory: "mywebsite/nginx"
        sumologic.com/sourceName: "mywebsite_nginx"
        sumologic.com/include: "true"
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
```

# Step 4 Set up Heapster for metric collection

The recommended way to collect metrics from Kubernetes clusters is to use Heapster and a Sumo collector with a Graphite source.

Heapster aggregates metrics across a Kubenetes cluster. Heapster runs as a pod in the cluster, and  discovers all nodes in the cluster and queries usage information from each node's `kubelet`—the on-machine Kubernetes agent.

Heapster provides metrics at the cluster, node and pod level.

1. Install Heapster in your Kubernetes cluster and configure a Graphite Sink to send the data in Graphite format to Sumo. For instructions, see
https://github.com/kubernetes/heapster/blob/master/docs/sink-configuration.md#graphitecarbon. Assuming you have used the below YAML files to configure your system, then the sink option in graphite would be `--sink=graphite:tcp://sumo-graphite.kube-system.svc:2003`.  You may need to change this depending on the namespace you run the deployment in, the name of the service or the port number for your Graphite source.

2. Use the Sumo Docker container. For instructions, see https://hub.docker.com/r/sumologic/collector/.

3. The following sections contain an  example configmap, which contains the `sources.json` configuration, an example service, and an example deployment. Create these manifests in Kubernetes using `kubectl`.

## Kubernetes ConfigMap
```
kind: ConfigMap
apiVersion: v1
metadata:
  name: "sumo-sources"
data:
  sources.json: |-
    {
      "api.version": "v1",
      "sources": [
        {
          "name": "SOURCE_NAME",
          "category": "SOURCE_CATEGORY",
          "automaticDateParsing": true,
          "contentType": "Graphite",
          "timeZone": "UTC",
          "encoding": "UTF-8",
          "protocol": "TCP",
          "port": 2003,
          "sourceType": "Graphite"
        }
      ]
    }

```
## Kubernetes Service
```
apiVersion: v1
kind: Service
metadata:
  name: sumo-graphite
spec:
  ports:
    - port: 2003
  selector:
    app: sumo-graphite
```
## Kubernetes Deployment
```
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  labels:
    app: sumo-graphite
  name: sumo-graphite
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: sumo-graphite
    spec:
      volumes:
      - name: sumo-sources
        configMap:
          name: sumo-sources
          items:
          - key: sources.json
            path: sources.json
      containers:
      - name: sumo-graphite
        image: sumologic/collector:latest
        ports:
        - containerPort: 2003
        volumeMounts:
        - mountPath: /sumo
          name: sumo-sources
        env:
        - name: SUMO_ACCESS_ID
          value: <SUMO_ACCESS_ID>
        - name: SUMO_ACCESS_KEY
          value: <SUMO_ACCESS_KEY>
        - name: SUMO_SOURCES_JSON
          value: /sumo/sources.json

```

# Templating Kubernetes metadata
The following Kubernetes metadata is available for string templating:

| String template  | Description                                             |
| ---------------  | ------------------------------------------------------  |
| `%{namespace}`   | Namespace name                                          |
| `%{pod}`         | Full pod name (e.g. `travel-products-4136654265-zpovl`) |
| `%{pod_name}`    | Friendly pod name (e.g. `travel-products`)              |
| `%{container}`   | Container name                                          |
| `%{source_host}` | Host                                                    |
| `%{label:foo}`   | The value of label `foo`                                |

## Missing labels
Unlike the other templates, labels are not guaranteed to exist, so missing labels interpolate as `"undefined"`.

For example, if you have only the label `app: travel` but you define `SOURCE_NAME="%{label:app}@%{label:version}"`, the source name will appear as `travel@undefined`.

# Log data
After performing the configuration described above, your logs should start streaming to SumoLogic in `json` or text format with the appropriate metadata. If you are using `json` format you can auto extract fields, for example `_sourceCategory=some/app | json auto`.

## Docker
![Docker Logs](/screenshots/docker.png)

## Kubelet
Note that Kubelet logs are only collected if you are using systemd.  Kubernetes no longer outputs the kubelet logs to a file.
![Docker Logs](/screenshots/kubelet.png)

## Containers
![Docker Logs](/screenshots/container.png)

# Taints and Tolerations
By default, the fluentd pods will schedule on, and therefore collect logs from, any worker nodes that do not have a taint and any master node that does not have a taint beyond the default master taint. If you would like to schedule pods on all nodes, regardless of taints, uncomment the following line from fluentd.yaml before applying it.

```
tolerations:
           #- operator: "Exists"
```

# Running On OpenShift

This daemonset setting mounts /var/log as service account FluentD so you need to run containers as privileged container. Here is command example:

```
oc adm policy add-scc-to-user privileged system:serviceaccount:logging:fluentd
oc adm policy add-cluster-role-to-user cluster-reader system:serviceaccount:logging:fluentd
oc label node —all logging-sumologic-fluentd=true
oc patch ds sumologic-fluentd -p "spec:
  template:
    spec:
      containers:
      - image: sumologic/fluentd-kubernetes-sumologic:latest
        name: fluentd
        securityContext:
          privileged: true"
oc delete pod -l name = fluentd-sumologic
```

## Running on Kubernetes versions <1.8

In order to run this plugin on Kubernetes <1.8 you will need to make some changes the yaml file prior to deploying it.

Replace:

```
      - name: pos-files
        hostPath:
          path: /var/run/fluentd-pos
          type: ""
```
With:

```
      - name: pos-files
        emptyDir: {}
```

## Output to S3

If you need to also send data to S3 (i.e. as a secondary backup/audit trail) the image includes the `fluent-plugin-s3` plugin.  In order to send the logs from FluentD to multiple outputs, you must use the `copy` plugin.  This image comes with an [OOB configuration](conf.d/out.sumo.conf) to output the logs to Sumo Logic. In order to output to multiple destinations, you need to modify that existing configuration.

**Example:** Send all logs to S3 and Sumo:

```
<match **>
  @type copy
  <store>
    @type sumologic
    log_key log
    endpoint "#{ENV['COLLECTOR_URL']}"
    verify_ssl "#{ENV['VERIFY_SSL']}"
    log_format "#{ENV['LOG_FORMAT']}"
    flush_interval "#{ENV['FLUSH_INTERVAL']}"
    num_threads "#{ENV['NUM_THREADS']}"
    open_timeout 60
    add_timestamp "#{ENV['ADD_TIMESTAMP']}"
    proxy_uri "#{ENV['PROXY_URI']}"
  </store>
  <store>
    @type s3

    aws_key_id YOUR_AWS_KEY_ID
    aws_sec_key YOUR_AWS_SECRET_KEY
    s3_bucket YOUR_S3_BUCKET_NAME
    s3_region us-west-1
    path logs/
    buffer_path /var/log/fluent/s3

    time_slice_format %Y%m%d%H
    time_slice_wait 10m
    utc

    buffer_chunk_limit 256m
  </store>
</match>
```

You can replace the OOB configuration by creating a new Docker image from our image or by using a configmap to inject the new configuration to the pod.

More details about the S3 plugin can be found [in the docs](https://docs.fluentd.org/v0.12/articles/out_s3).

## Upgrading to v2.0.0

In version 2.0.0, some legacy FluentD configuration has been removed that could lead to [duplicate logs being ingested into Sumo Logic](https://github.com/SumoLogic/fluentd-kubernetes-sumologic/issues/79).  These logs were control plane components.  This version was done as a major release as it breaks the current version of the [Kubernetes App](https://help.sumologic.com/Send-Data/Applications-and-Other-Data-Sources/Kubernetes/Install_the_Kubernetes_App_and_View_the_Dashboards) you may have installed in Sumo Logic.

After upgrading to this version, you will need to reinstall the [Kubernetes App](https://help.sumologic.com/Send-Data/Applications-and-Other-Data-Sources/Kubernetes/Install_the_Kubernetes_App_and_View_the_Dashboards) in Sumo Logic. If you do not some of the panels in the dashboards will not render properly.

If you have other content outside the app (Partitions, Scheduled Views, Field Extraction Rules or Scheduled Searches and Alerts), these may need to be updated after upgrading to v2.0.0.  The logs, while the same content, have a different format and the same parsing logic and metadata may not apply.

The previous log format that is removed in v2.0.0:
```json
{
   "timestamp":<PHONE_NUMBER>387,
   "severity": "I",
   "pid": "1",
   "source": "wrap.go:42",
   "message": "GET /api/v1/namespaces/kube-system/endpoints/kube-scheduler: (3.514372ms) 200 [[kube-scheduler/v1.10.5 (linux/amd64) kubernetes/32ac1c9/leader-election] <IP_ADDRESS>:46290]"
}
```
Is replaced by the following version.  It is the same log line in a different format enriched with the same metadata the plugin applies to all pod logs.
```json
{
   "timestamp":<PHONE_NUMBER>152,
   "log": "I1005 21:51:21.387204       1 wrap.go:42] GET /api/v1/namespaces/kube-system/endpoints/kube-scheduler: (3.514372ms) 200 [[kube-scheduler/v1.10.5 (linux/amd64) kubernetes/32ac1c9/leader-election] <IP_ADDRESS>:46290]",
   "stream": "stdout",
   "time": "2018-10-05T21:51:21.387477546Z",
   "docker": {
      "container_id": "a442fd2982dfdc09ab6235941f8d661a0a5c8df5e1d21f23ff48a9923ac14739"
   },
   "kubernetes": {
      "container_name": "kube-apiserver",
      "namespace_name": "kube-system",
      "pod_name": "kube-apiserver-ip-172-20-122-71.us-west-2.compute.internal",
      "pod_id": "80fa5e13-c8b9-11e8-a456-0a8c1424d0d4",
      "labels": {
         "k8s-app": "kube-apiserver"
      },
      "host": "ip-172-20-122-71.us-west-2.compute.internal",
      "master_url": "https://<IP_ADDRESS>:443/api",
      "namespace_id": "9b9b75b7-aa16-11e8-9d62-06df85b5d3bc"
   }
}
```


text:
tinyMediaManager
========================

tinyMediaManager (http://www.tinymediamanager.org) is a media management tool written in Java/Swing. It is written to provide metadata for the XBOX Media Center (XBMC). Due to the fact that it is written in Java, tinyMediaManager will run on Windows, Linux and Mac OSX (and possible more OS).

tinyMediaManager is free and will stay free. If you appreciate all the effort that has gone into this application then consider a donation. While it's neither expected nor required it is highly appreciated!
[![Donate][1]][2]

[1]: https://www.paypal.com/en_US/i/btn/btn_donate_SM.gif
[2]: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=manuel.laggner@gmail.com&lc=GB&item_name=tinyMediaManager&currency_code=EUR&bn=PP-DonationsBF:btn_donate_LG.gif:NonHosted

##Version 2##
Version 2.6.9 has been released on 27. July 2015.

##Features##
[http://www.tinymediamanager.org/index.php/features/](http://www.tinymediamanager.org/index.php/features/)

##Screenshots##
more screenshots at [http://www.tinymediamanager.org/index.php/screenshots/](http://www.tinymediamanager.org/index.php/screenshots/)

###Main panel for movies

[![Movie panel](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/movie_panel_main_thumb.jpg)](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/movie_panel_main.jpg)

###Main panel for moviesets

[![Movie set panel](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/movieset_panel_main_thumb.jpg)](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/movieset_panel_main.jpg)

###Search for a movie

[![Movie search](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/moviechooser_dialog_thumb.jpg)](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/moviechooser_dialog.jpg)

###Search for a movieset

[![Movie set search](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/moviesetchooser_dialog_thumb.jpg)](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/moviesetchooser_dialog.jpg)

###Edit movie metadata

[![Edit movie](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/movieeditor_dialog_thumb.jpg)](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/movieeditor_dialog.jpg)

###Main panel for TV shows

[![TV show panel](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/tvshow_panel_main_thumb.jpg)](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/tvshow_panel_main.jpg)

###Change artwork

[![Image chooser](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/imagechooser_dialog_thumb.jpg)](https://github.com/tinyMediaManager/tinyMediaManager/raw/master/screenshots/imagechooser_dialog.jpg)

repository: AresScorpio/tinyMediaManager

repo_name: AresScorpio/tinyMediaManager


text:
---
layout: post
title: "What's the difference between 'i++' and '++i'"
date: 2022-10-02 18:30
tags: computer-science javascript
navigation: true
class: post-template
current: post
---

I have always been familiar with incrementing a variable using `i++`, but recently came across `++i`. It took me a while to truly understand the difference.

`i++` is used as a shorthand for writing `i = i + 1`. `++i` does the same. The difference between the two is in what value is returned from this operation.

```js
const returnIncrementPrefix = (i) => {
  return ++i;
};

returnIncrementPostfix(5); // returns 6
```

In the example above, we use the prefix `++i`. When 5 is used as an argument in this function, 6 is returned. Knowing that `++i` increments by one, this seems to make sense.

What happens when we use the postfix?

```js
const returnIncrementPostfix = (i) => {
  return i++;
};

returnIncrementPostfix(5); // returns 5
```

The above code returns a value of 5. At first this doesn't make sense. We are supposed to be incrementing by 1, right? Shouldn't this also equal 6?

Nope! In the first example, these steps occur:

- i is incremented by 1, giving i a value of 6
- i is returned

We are returned the value of i after it has been incremented.

In the second example using the postfix, i is being returned before it is incremented. The operation doesn't happen until after 5 has been returned to us.

It's all about the order in which the steps occur.

#### Tip for remembering

If you need help remembering which operation does which, think of it this way. If the "++" comes before the i, incrementation happens before it is returned. If the "++" comes after the i, the incrementation happens after it is returned.

Of course, this applies to other operations, including decrementation.

gha_language: HTML

gha_license_id: MIT


text:
Sample GAN implementaion that uses the MNIST data to generate synthetic handwritten digit images.

## Dependencies
* Anaconda 3
* Jupyter Notebook
* Keras
    * Matplotlib.pyplot
    * Numpy

## Installation
* Install [Anaconda 3](https://www.anaconda.com/download/)
* Create a new environment using the Anaconda Navigator
* Install Keras in the new environment;
    * Numpy and Matplotlib.pyplot should automatically install as dependency packages

## Training the GAN
* Launch Jupyter Notebook from the navigator; Make sure you're in the environment where Keras is installed
* In the Jupyter Notebook web app, start a new terminal instance
* Once in the terminal, navigate to the directory with the gan.py file and run with the following command
    * `python gan.py`


text:
# Web Crawler Scrapy of APP Store(Xiaomi)

## Description
We created a Scrapy project to crawl the content in the Xiaomi Appstore homepage. Then Saved the crawled content in MongoDB. Install Python MongoDB driver and modify pipelines.py to insert crawled data into MongoDB. Crawl more content by following next page links.

In this real application, we dealt with different kinds of challenges like dynamic JavaScript by Splash+ ScrapyJS or IP being blocked by random useragent.

Finally, I grabbed 38535 items of Xiaomi appstore, each item contain the information of appid, appname, description, catagory, company name, and title.

## Introduction Video
- [1st](https://www.youtube.com/watch?v=lci558l7cFw)
- [2nd](https://www.youtube.com/watch?v=qdteBkCI1Gg)

### Time
We started this project on 06/04/2016 and have done on 07/02/2016.

### [Demo](https://www.youtube.com/watch?v=HVAR5syRljc&feature=youtu.be)

### Usage
1. Install Scrapy, MongoDB, Splash and ScrapyJS.(If you already have, skil this step. ）
  - [Scrapy](http://doc.scrapy.org/en/latest/intro/install.html)
  - [MongoDB](https://docs.mongodb.com/master/installation/)
  - [Splash](https://splash.readthedocs.io/en/stable/install.html)
  - [ScrapyJS](https://pypi.python.org/pypi/scrapyjs)
2. Start your Splash and MongoDB server.
    + under catalog /MongoDB/bin:

        ```bash
        ./mongod
        ```

    + On the Terminal of docker:

        ```bash
        docker run -p 8050:8050 scrapinghub/splash
        ```

3. Clone a copy of the main appstore crawler repo by running:

    ```bash
    git clone https://github.com/AnkaiLiang/-12WebCralwer.git
    ```

4. Modify the file -12WebCralwer/appstore_crawler/appstore_crawler/settings.py.
Set your Splash server address and the information of MongoDB.
In my case, it's :

    ```python
    SPLASH_URL = 'http://<IP_ADDRESS>:8050'
    MONGODB_SERVER = "localhost"
    MONGODB_PORT = 27017
    MONGODB_DB = "Xiaomi"
    MONGODB_COLLECTION = "appdate"
    ```

5. Go to the catalog /appstore_crawler/, Run the crawler:

    ```bash
    scrapy crawl xiaomi
    ```

### Team
We had 4 people in our team. And we independently completed the entire project coding.
  - [AnkaiLiang](https://github.com/AnkaiLiang)
  - [Taran](https://github.com/songtailun)
  - [Kristy Luo](https://github.com/Kristy-Luo)
  - [jenny91515](https://github.com/jenny91515)

### Acknowledgement
  - BitTiger
  - Jing Li
  - [jamesyx](https://github.com/jamesyxw/crawler)

## Resource
  - [BitTiger Project: Web Crawler Scrapy](https://www.bittiger.io/microproject/oYDSG6MSFihpiNJ66)
  - [Scrapy](http://scrapy.org)
  - [MongoDB](https://www.mongodb.org)
  - [Splash & ScrapyJS](https://github.com/scrapinghub/scrapy-splash)
  - [ScrapyJS & ScrapyJS](https://blog.scrapinghub.com/2015/03/02/handling-javascript-in-scrapy-with-splash/)

## License
See the [LICENSE](LICENSE.md) file for license rights and limitations (MIT).

## Project Information
- category: full stack
- team: 12WebCralwer
- description: a Scrapy project to crawl the content in the Xiaomi Appstore homepage
- stack: mongodb, python

gha_language: Python


text:
# Parakeet
Parakeet is a file software manager. The main goals is to rename lot of file with specification and/or sort them by specific string.

# Warning
I highly discourage the usage of this software if you didn't test the different features in a safe environment.
The reasons are:
* You can easily remove files & folders.
* You can easilty rename files & folders (don't expect the renaming to work very well if you combine multiple tasks or rename it to some kirky string).
* You can easily move files & folders with a sample Regex that capture a group in the string.
* You can do any task in any folders and sub-folders at the same time.
* Only the DocDistTask is safe because it only use the name of the files & folders to find any similitude in other files & folders names. Other than getting the names, it doesn't do anything to files & folers

repository: Serasvatie/Parakeet

gha_language: C#

repo_name: Serasvatie/Parakeet


text:
# payment-reconciliation-consumer
Consumer to allow for reconciliation of payments

## Docker support

Pull image from private CH registry by running `docker pull<PHONE_NUMBER>21.dkr.ecr.eu-west-1.amazonaws.com/local/payment-reconciliation-consumer:latest` command or run the following steps to build image locally:

1. `export SSH_PRIVATE_KEY_PASSPHRASE='[your SSH key passhprase goes here]'` (optional, set only if SSH key is passphrase protected)
2. `DOCKER_BUILDKIT=0 docker build --build-arg SSH_PRIVATE_KEY="$(cat ~/.ssh/id_rsa)" --build-arg SSH_PRIVATE_KEY_PASSPHRASE -t<PHONE_NUMBER>21.dkr.ecr.eu-west-1.amazonaws.com/local/payment-reconciliation-consumer:latest .`


text:
---
layout: default
---

# 1993-07-29 - Re: (fwd) VINYL STICKERS: NEW PRICES, BETTER QUALITY

## Header Data

From: "Jeremy R. Smith"<EMAIL_ADDRESS>To: "Timothy C. May"<EMAIL_ADDRESS>Message Hash: 1f2ea56383a6c33ef5fa2ec4e1d3ffe16f615987688cd25f9e50689010777bc9

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-07-29 08:42:05 UTC

Raw Date: Thu, 29 Jul 93 01:42:05 PDT

## Raw message

```
{% raw  %}From: "Jeremy R. Smith"<EMAIL_ADDRESS>Date: Thu, 29 Jul 93 01:42:05 PDT
To: "Timothy C. May"<EMAIL_ADDRESS>Subject: Re: (fwd) VINYL STICKERS: NEW PRICES, BETTER QUALITY
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Wed, 28 Jul 1993, Timothy C. May wrote:

> Here's mention of getting vinyl stickers made. Even smaller stickers,
> for a "Big Brother Inside" negative campaign, could be even cheaper.
> Paper labels could be cheaper still.
>
> -Tim May
>
>
> From<EMAIL_ADDRESS>(Peter J Menchetti)
> Newsgroups: alt.cyberpunk.tech
> Subject: VINYL STICKERS: NEW PRICES, BETTER QUALITY
> Date: 18 Jul 1993 00:11:00 GMT
>
>
> I have new prices on my vinyl stickers. They are now SCREEN PRINTED
> so that the vinyl will NOT scratch off. My prices are now lower and
> the stickers are better.
>
> Anyone interested in these VINYL WEATHERPROOF GLOSSY STICKERS should
> email<EMAIL_ADDRESS>for details.
>
> They are CHEAP. $15 buys 100 cassette sized 2-color vinyl stickers!
>
> Pete Menchetti  ** Vinyl stickers for cheap, email me! **
>

	I would be interested in ordering some of those.  Where would I
inquire?

						Jeremy Smith
<EMAIL_ADDRESS>
-----BEGIN PGP PUBLIC KEY BLOCK----- Version: 2.2

mQCNAixVlqsAAAEEAMlqS9nz+2dADwxwOglWVJk7xugtC9SMQX6rkJiv/0wkOhSB
RSQcUL5bVfRKJGa4YrnHefmBZaTSvwtFmSUCSqm4yN9n258xda+niz6pJwPDaTIX
7Gr1V8Xr9/J7K3grm8H1VCXJjKTUVt+zPns5KS4K+tQZgdcPQJefZlD5h/jTAAUV
tCdKZXJlbXkgU21pdGggPGplcnNtaXRAZWlzLmNhbHN0YXRlLmVkdT4=
=J0/4
-----END PGP PUBLIC KEY BLOCK-----

{% endraw %}
```

## Thread

+ Return to [July 1993](/archive/1993/07)

+ Return to "["Jeremy R. Smith" <jersmit@eis.calstate.edu>](/authors/jeremy_r_smith_jersmit_at_eis_calstate_edu_)"
+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_netcom_com_timothy_c_may_)"

+ 1993-07-28 (Wed, 28 Jul 93 16:43:23 PDT) - [(fwd) VINYL STICKERS: NEW PRICES, BETTER QUALITY](/archive/1993/07/95c8c1e0881dd36417b7a0b116f537e992413d95c2e57a9a9d53b7087e35413f) -<EMAIL_ADDRESS>(Timothy C. May)_
  + 1993-07-29 (Thu, 29 Jul 93 01:42:05 PDT) - Re: (fwd) VINYL STICKERS: NEW PRICES, BETTER QUALITY - _"Jeremy R. Smith"<EMAIL_ADDRESS>


text:
---
layout: post
title: LFTP - a sophisticated ftp/http client
---

The author of the famous [LFTP](http://lftp.yar.ru/ "Official site") tool, defines it as a sophisticated ftp/http client. After using it for a couple of months, I can now attest to that claim.
It is feature loaded and provide many niceties. Some of the features I use regularly are segmented downloads (splitting a file into parts and transferring those parts concurrently), queues,
directory download/upload and resume.

Quick reference:

Download a directory
> mirror -c --use-pget-n=3 dir_name
>
>> c => resume
>
>> use-pget-n => segmented download with 3 chunks

Upload a directory
> mirror -R -c --use-pget-n=3 <dir_name>

Put current command in background
> Ctrl-Z

Bring backgrounded command back
> wait

Create an empty queue
> queue stop
> queue (if no queue exists)

Queue status (execute only if queue exists, otherwise it would create an empty queue)
> queue

Add current executing command to queue
> queue wait 0

Stop further queued actions (but keep current ones going)
> queue stop

Start all stopped queues
> Exit out of lftp. Upon exit it automatically starts all stopped queues

It can use the SSH Agent to connect using already added keys. On my raspberrypi, I do the following for SFTP connection using SSH Agent
> Start SSH agent
>
> Add desired key to SSH agent (PS: On raspberry pi, need to execute 'eval '$(ssh-agent)')
>
> lftp sftp://<user>@<server>

If asks for password, but hitting ENTER key allows it to connect using the SSH agent.


text:
# Phytophthora vesicula Anastasiou & Churchl., 1969 SPECIES

#### Status
SYNONYM

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

#### Published in
Can. J. Bot. 47: 252 (1969)

#### Original name
Phytophthora vesicula Anastasiou & Churchl., 1969

### Remarks
null

repository: mdoering/backbone

path: /life/Chromista/Oomycota/Oomycetes/Peronosporales/Peronosporaceae/Halophytophthora/Halophytophthora vesicula/ Syn. Phytophthora vesicula/README.md

repo_name: mdoering/backbone


text:
# Web Component Slides

A simple slideshow library built with web components.

## Requirements

* Node
* Bower
* Grunt
* Browser with Web Component support (e.g., Chrome 36+)

## Install

    npm install
    bower install
    grunt

repository: andrewrota/web-component-slides

repo_name: andrewrota/web-component-slides


text:
# FLowGen-CNNs-DAC18:
Demo datasets generated with open source Logic Synthesis framework ABC from UC Berkeley [see https://github.com/berkeley-abc/abc]

Link to paper: https://ycunxi.github.io/cunxiyu/papers/dac18.pdf

[![license](https://img.shields.io/packagist/l/doctrine/orm.svg)](https://github.com/ycunxi/FLowGen-CNNs-DAC18/blob/master/LICENSE.md)
[![dep1](https://img.shields.io/badge/implementation-tensorflow-orange.svg)](https://www.tensorflow.org/)
[![dep2](https://img.shields.io/badge/python-3.4-red.svg)](https://www.python.org/download/releases/3.4/)

## Requirements

- Python 2.7/3.x
- [Tensorflow] backend
- [Keras] high-level neural networks API
- [pandas, numpy, sklearn, h5py]
- [matplotlib] plot
- [ABC] [OPTION] if you are interested in applying to your own designs, you need to generate corresponding data points
        , with your own technology lib; abc.rc file (100k flows) is included in /datasets

# FLowGen-CNNs-DAC18
## Contents
### ABC Random flows
/datasets/abc_100k_random_flows.rc
### Datasets
64-bit Montegomery Multiplier datasets (csv format): datasets/64bitGF/delay/

For example: rw; rw; rf; rfz; b; rf; b; rw; rfz; rs -K 6; b; rf; b; rs -K 6; rwz; rfz; rs -K 6; rw; rwz; rwz; rf; rwz; rfz; rs -K 6

Note: please always start with "strash" ("st") before applying the random flows.

#### How to get data points using your own design and Technlogy library?
Command: **./abc -c "read i10.aig; synthesis_rand_1"**

*stout by ABC shown bellow*

*ABC command line: "read i10.aig; synthesis_rand_1".

Entered genlib library with 15 gates from file "yourLib.genlib".

Converting "yourLib.genlib" into supergate library "yourLib.super".

Maximum level: Original = 35. Reduced due to choices = 35.

Choice stats:  Choice nodes = 0. Total choices = 0.

Nodes =   2063.  Total 5-feasible cuts =      28104.  Per node = 13.6. Time =     0.01 sec

Delay    : Delay =     0.00  Flow =     63162.9  Area =     11799.0   0.0 %   Time =     0.00 sec

AreaFlow : Delay =   218.63  Flow =      8340.9  Area =      8892.0  24.6 %   Time =     0.01 sec

Area     : Delay =   218.63  Flow =         0.0  Area =      7415.0  37.2 %   Time =     0.01 sec

Area     : Delay =   218.63  Flow =         0.0  Area =      7172.0  39.2 %   Time =     0.01 sec

Output  V435(0)    : Delay = (218.63, 218.63)  NEG

Output  V398(0)    : Delay = (218.52, 218.52)  NEG

Output  V432       : Delay = (217.67, 217.67)  POS

Output  V393(0)    : Delay = (216.03, 216.03)  NEG

Output  V357       : Delay = (205.00, 205.00)  POS

Total runtime =     0.06 sec

i10                           : i/o =  257/  224  lat =    0  nd =  1581  edge =   3676  area =7172.00  delay =218.63  lev = 21*

### Demo Code
*These jupyter files only includes the demo training and testing results of CNN classifier. For generating datasets, see above & /datasets dir.*

1) dac18_keras_train_n_inference.ipynb (keras implementation)

Includes training and inference. Trained model has been saved in "dac18_GF_delay_model_save_test.h5"

2) dac18_keras_inference_only.ipynb
Loads pre-trained model and do inference only.

## Reference
*Developing Synthesis Flows without Human Knowledge.* Cunxi Yu, Houping Xiao and Giovanni De Micheli

ACM/IEEE Design Automation Conference (DAC'18)

```
  @article{cunxi-dac18-cnnFlowGen,
    title   = "{Developing Synthesis Flows without Human Knowledge}",
    author  = {Cunxi Yu and Houping Xiao and Giovanni De Micheli},
    journal = {Design Automation Conference (DAC'18)},
    month   = {June},
    year    = {2018},
  }
```

## Contact
Cunxi Yu, LSI, EPFL

Email<EMAIL_ADDRESS>


text:
---
layout: default
---

# 1994-05-06 - Re: Bunch of Clueless Idiots

## Header Data

From: "Fred Heutte"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 2ea770fb2435d26f9b90c3113e5bf4d3cead022513c172a01f90e70e43795305

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-05-06 11:02:12 UTC

Raw Date: Fri, 6 May 94 04:02:12 PDT

## Raw message

```
{% raw  %}From: "Fred Heutte"<EMAIL_ADDRESS>Date: Fri, 6 May 94 04:02:12 PDT
To<EMAIL_ADDRESS>Subject: Re: Bunch of Clueless Idiots
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Aside from the fact that Jim Nalbandian is wrong about the absolutist
argument he propounds about gun ownership and the Second Amendment,
this is clearly a clueless rant and should be ignored.  Heaven forfend
that the discussion here get sidetracked onto gun issues, especially
in respone to a classic shit-disturber post like this.

I'm normally a lurker but definitely *do* read and enjoy and like
chewing on the issues and discussion here.  But my patience ends with
axe-grinding.

see you in the future

phred

"Why make it simple & easy
 When you can make it complex & wonderful!"

{% endraw %}
```

## Thread

+ Return to [May 1994](/archive/1994/05)

+ Return to<EMAIL_ADDRESS>(David Taffs)](/authors/dat_at_ebt_com_david_taffs_)"
+ Return to "["Fred Heutte" <phred@well.sf.ca.us>](/authors/fred_heutte_phred_at_well_sf_ca_us_)"
+ Return to<EMAIL_ADDRESS>(Jim Nalbandian)](/authors/lassiejimlassie_at_netcom_com_jim_nalbandian_)"
+ Return to "[Sandy Sandfort <sandfort@crl.com>](/authors/sandy_sandfort_sandfort_at_crl_com_)"

+ 1994-05-06 (Thu, 5 May 94 23:32:33 PDT) - [Bunch of Clueless Idiots](/archive/1994/05/44f05e3c5c94ed6bff0540f375d29ded076c9efe7ae93cb8e21ff3e9efa4483d) -<EMAIL_ADDRESS>(Jim Nalbandian)_
  + 1994-05-06 (Fri, 6 May 94 04:02:12 PDT) - Re: Bunch of Clueless Idiots - _"Fred Heutte"<EMAIL_ADDRESS>  + 1994-05-06 (Fri, 6 May 94 08:29:28 PDT) - [Re: Bunch of Clueless Idiots](/archive/1994/05/fd633b24d3e7f92828be26ada4df434c5457044080065a74aa5f83faceef23df) - _Sandy Sandfort<EMAIL_ADDRESS>  + 1994-05-06 (Fri, 6 May 94 10:20:30 PDT) - [Re: Bunch of Clueless Idiots](/archive/1994/05/b33443ded35f6ea6441fa0792954d081c3bf1fcfaa3ba4e5a0d764348d5bb9d1) -<EMAIL_ADDRESS>(David Taffs)_


text:
# Arcus

![Nuget (with prereleases)](https://img.shields.io/nuget/vpre/arcus)
![GitHub](https://img.shields.io/github/license/sandialabs/arcus)
![.NetStandard 1.3](https://img.shields.io/badge/targets-.NETStandard%201.3-blueviolet)

Arcus is a C# manipulation library for calculating, parsing, formatting, converting, and comparing both IPv4 and IPv6 addresses and subnets. It accounts for 128-bit numbers on 32-bit platforms.

## Getting Started

The latest stable release of Arcus is [available on NuGet](https://www.nuget.org/packages/Arcus/).

You can also download the source source code and compile it in C#, thus creating an dll file.

An example of code usage can be found later in the [Usage](https://github.com/sandialabs/Arcus#usage) section.

## Usage

At its heart Arcus is split amongst five separate interdependent units. *Types*, *Comparers*, *Converters*, *Math*, and *Utilities*.

### Types

#### `Subnet`

An IPv4 or IPv6 subnetwork representation - the work horse and original reason for the Arcus library. Outside the concept of the `Subnet` object, most everything else in Arcus is auxiliary and exists only in support of making this once facet work. That’s not to say that the remaining pieces of the Arcus library aren’t useful, on the contrary their utility can benefit a developer greatly. That said, once the `Subnet` is mastered the rest of Arcus should follow through nicely.

A `Subnet` may be instantiated in several ways:

To the most common ways to create a subnet is to construct it via a high and low `IPAddress` call the constructor `Subnet(IPAddress primary,  IPAddress secondary)` This construct the smallest possible subnet that would contain both IP addresses typically the address specified are the Network and Broadcast addresses (lower and higher bounds) but this is not necessary. Addresses *MUST* be the same address family (either Internetwork or InternetworkV6)

It is also possible to create a `Subnet` from an `IPAddress` and an `integer` based *route prefix*. Eg: `Subnet(IPAddress ipAddress, int routingPrefix)`

Likewise it may be desired to statically parse a subnet string with `Subnet. Parse(string input)` or it’s safe equivalent of ` bool Subnet.TryParse(string input,  out Subnet subnet)`. For example, one could safely parse the `string` "<IP_ADDRESS>/16" via
```
Subnet subnet;
var success = Subnet.TryParse("<IP_ADDRESS>/16",  out subnet)
```

#### `IPAddressRange`

A basic implementation of a IIPAddressRange used to represent an inclusive range of arbitrary IP Addresses of the same address family. It isn't restricted like a `Subnet` is, allowing for non-power of two sizes, but because of this it's functionality is likewise limited.

### Comparers

The *Comparers* package contains useful Comparer objects for comparing properties of IP Addresses and IP Address composite objects

 * `DefaultAddressFamilyComparer` - A comparer that compares address families. Most frequently `Internetwork` (IPv4) and `InternetworkV6` (IPv6)
 * `DefaultIPAddressComparer` - A comparer for `IPAddress` objects
 * `DefaultIPAddressRangeComparer` - A comparer for `IIPAddressRange`. Compares such that lower order ranges are less that higher order ranges accounting for size at matching range starts

### Converters

The *Converters* package is a package of static utility classes for converting one type into another type

#### `IPAddressConverters`

Static utility class containing conversion methods for converting `IPAddress` objects into something else

### Math

The *Math* package is a package of static utility classes for doing computational mathematics on objects

#### `IPAddressMath`

In some cases the C# `IPAddress` object doesn't go far enough with what you can do with it mathematically, this static utility class containing mathematical methods to fill in the gaps.

##### Incrementing and Decrementing

Incrementing and Decrementing an `IPAddress` is as easy as a call to the `IPAddress Increment(this IPAddress ipAddress, long delta = 1)` method

Incrementing by one is a simple call to the extension method

```
var address = IPAddress.Parse(<IP_ADDRESS>);
var result = address.Increment();   // result is <IP_ADDRESS>
```

Decrementing is just as simple

```
var address = IPAddress.Parse(<IP_ADDRESS>);
var result = address.Increment(-2);   // result is <IP_ADDRESS>
```

*Overflow* and *Underflow* conditions will result in an `InvalidOperationException`

##### Equality

Equality may also be tested via a host of equality extension methods

 * `bool IsEqualTo(this IPAddress alpha, IPAddress beta)`
 * `bool IsGreaterThan(this IPAddress alpha, IPAddress beta)`
 * `bool IsGreaterThanOrEqualTo(this IPAddress alpha, IPAddress beta)`
 * `bool IsLessThan(this IPAddress alpha, IPAddress beta)`
 * `bool IsLessThanOrEqualTo(this IPAddress alpha, IPAddress beta)`

### Utilities

The *Utilities* package contains static classes for miscellaneous operations on specific types

#### `IPAddressUtilities`

Static utility class containing miscellaneous operations for `IPAddress` objects

##### Address Family Detection

A couple of extension methods were created to quickly determine the address family of an IP Address. To determine if an address is IPv4 use `bool IsIPv4(this IPAddress ipAddress)`, likewise `bool IsIPv6(this IPAddress ipAddress)` can be used to test for IPv6.

##### Parsing

It is possible to parse an `IPAddress` from a hexadecimal string into either an IPv4 of IPv6 address using the `IPAddress ParseFromHexString(string input, AddressFamily addressFamily)` method. Likewise it can be done safely with `bool TryParseFromHexString(string input, AddressFamily addressFamily, out IPAddress address)`

Similarly, conversion may be done from an octal string by using `bool TryParseIgnoreOctalInIPv4(string input, out IPAddress address)` or even a `BigInteger` by way of `bool TryParse(BigInteger input, AddressFamily addressFamily, out IPAddress address)`

#### `SubnetUtilities`

Static utility class containing miscellaneous operations for `Subnet` objects that didn't make sense to put on the object itself.

Given two arbitrary IP Addresses of the same family it may be desired to calculate the fewest consecuitive subnetes that would hold the inclusive range between them. For example

```
    SubnetUtilities.FewestConsecutiveSubnetsFor(IPAddress.Parse("<IP_ADDRESS>"), IPAddress.Parse(<IP_ADDRESS>"))
```

would return an `Enumerable` containing the subnets "<IP_ADDRESS>/32", "<IP_ADDRESS>/30", "<IP_ADDRESS>/30", "<IP_ADDRESS>/32"

## Built With

* [NuGet](https://www.nuget.org/) - Dependency Management
* [JetBrains.Annotations](https://www.jetbrains.com/help/resharper/10.0/Code_Analysis__Code_Annotations.html) - Used to keep developers honest
* [moq](https://github.com/moq/moq4/wiki) - Fake it until you make it!
* [Stackoverflow](https://stackoverflow.com/) - Because who really remembers how to code
* [xUnit.net](https://xunit.net/) - Testing, testing, 1, 2, 3...

## Versioning

We use [SemVer](http://semver.org/) for versioning.

## Primary Authors and Contributors

* **Robert H. Engelhardt** - *Primary Developer, Source of Ideas Good and Bad* - [@rheone](https://twitter.com/rheone)
* **Andrew Steele** - *Review and Suggestions* - [@ahsteele](https://twitter.com/ahsteele)
* **Nick Bachicha** - *Git Wrangler and DevOps Extraordinaire* - [@nicksterx](https://twitter.com/nicksterx)

## Copyright

```
Copyright 2018 National Technology & Engineering Solutions of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights in this software.
```

## License

```
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

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

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
```

repository: gitter-badger/Arcus

repo_name: gitter-badger/Arcus


text:
# Kibble Scanner Application
The Kibble Scanners collect information for the Kibble Suite.

## Setup instructions:

 - Edit conf/config.yaml to match your Kibble service

## How to run:

 - On a daily/weekly/whatever basis, run: `python3 src/kibble-scanner.py`.

### Command line options:

    usage: kibble-scanner.py [-h] [-o ORG] [-f CONFIG] [-a AGE] [-s SOURCE]
                             [-n NODES] [-t TYPE] [-e EXCLUDE [EXCLUDE ...]]
                             [-v VIEW]

    optional arguments:
      -h, --help            show this help message and exit
      -o ORG, --org ORG     The organisation to gather stats for. If left out, all
                            organisations will be scanned.
      -f CONFIG, --config CONFIG
                            Location of the yaml config file (full path)
      -a AGE, --age AGE     Minimum age in hours before performing a new scan on
                            an already processed source. --age 12 will not process
                            any source that was processed less than 12 hours ago,
                            but will process new sources.
      -s SOURCE, --source SOURCE
                            A specific source (wildcard) to run scans on.
      -n NODES, --nodes NODES
                            Number of nodes in the cluster (used for load
                            balancing)
      -t TYPE, --type TYPE  Specific type of scanner to run (default is run all
                            scanners)
      -e EXCLUDE [EXCLUDE ...], --exclude EXCLUDE [EXCLUDE ...]
                            Specific type of scanner(s) to exclude
      -v VIEW, --view VIEW  Specific source view to scan (default is scan all
                            sources)

## Directory structure:

 - `conf/`: Config files
 - `src/`:
 - - `kibble-scanner.py`: Main script for launching scans
 - - `plugins/`:
 - - - `brokers`: The various database brokers (ES or JSON API)
 - - - `utils`: Utility libraries
 - - - `scanners`: The individual scanner applications

## Currently available scanner plugins:

 - Apache Pony Mail (`plugins/scanners/ponymail.py`)
 - Atlassian JIRA (`plugins/scanners/jira.py`)
 - BugZilla Issue Tracker (`plugins/scanners/bugzilla.py`)
 - BuildBot (`plugins/scanners/buildbot.py`)
 - Discourse (`plugins/scanners/discourse.py`)
 - Gerrit Code Review (`plugins/scanners/gerrit.py`)
 - Git Repository Fetcher (`plugins/scanners/git-sync.py`)
 - Git Census Counter (`plugins/scanners/git-census.py`)
 - Git Code Evolution Counter (`plugins/scanners/git-evolution.py`)
 - Git SLoC Counter (`plugins/scanners/git-sloc.py`)
 - GitHub Issues/PRs (`plugins/scanners/github.py`)
 - GitHub Traffic Statistics (`plugins/scanners/github-stats.py`)
 - GNU Mailman Pipermail (`plugins/scanners/pipermail.py`)
 - Jenkins (`plugins/scanners/jenkins.py`)
 - Travis CI (`plugins/scanners/travis.py`)

## Requirements:

 - [cloc](https://github.com/AlDanial/cloc) version 1.76 or later `(optional)`
 - git binaries
 - python3 (3.3 or later)
 - python3-elasticsearch
 - python3-certifi
 - python3-yaml

# Get involved
  TBD. Please see https://kibble.apache.org/ for details!

repository: apache/kibble-scanners

repo_name: apache/kibble-scanners


text:
---
title: Whitelisting & filtering traffic
weight: 6
menu:
  docs:
    parent: "Monitoring"
---

Whitelisting Checkly traffic in your firewall or load balancer by IP address is not possible at this moment as Checkly uses a non-static set of IP addresses in the cloud to run its checks.

This is a feature we want to implement so expect changes on this topic in the future.

You can however fetch a list of the [dynamic IP addresses](https://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html) in use at AWS, our cloud provider.

## Filtering Google Analytics

If you want to filter Checkly traffic in Google Analytics because Checkly browser checks are skewing your
numbers, here is one way how to do it:

1. Ad a UTM source tag to the URL's your requesting, i.e.

{{< tabs "Goto example" >}}
{{< tab "Puppeteer" >}}
```js
await page.goto('https://app.checklyhq.com/login?utm_source=monitoring')
 ```
{{< /tab >}}
{{< tab "Playwright" >}}
```js
await page.goto('https://app.checklyhq.com/login?utm_source=monitoring')
 ```
{{< /tab >}}
{{< /tabs >}}

2. In Google Analytics, filter on campaign source.

![filter google analytics traffic on campaign source](/docs/images/monitoring/analytics.png)

For detailed instructions, see [the Google Analytics docs on custom filters](https://support.google.com/analytics/answer/1033162#CustomFilters).

 > Note, it will take some hours for this to take effect.

## Cloudflare Whitelisting

If you are using Cloudflare, one or more of your automated checks might trigger its [bot detection mechanism](https://www.cloudflare.com/learning/bots/what-is-bot-traffic/).

If you want to prevent that from happening, without exposing your website to any and all automated traffic, you might want to set up a new [firewall rule](https://developers.cloudflare.com/firewall/cf-firewall-rules/) allowing traffic from Checkly as long as it contains a specific header or sets a certain user agent.

You can make the header and/or user agent specific to your own Checkly user account by grabbing the first eight digits of your unique user ID, which you can find below your account name on the [Account Settings page](https://app.checklyhq.com/account/). Embedding this value in your checks will enable them to be allowed through by your firewall rules.

### Whitelisting API checks

To whitelist API checks, allow traffic that contains a cookie in the shape of `Cookie: "checkly-account:<UUID>"`, with `<UUID>` being your shortened Checkly ID.

You can then [set the Cookie header](https://checklyhq.com/docs/api-checks/request-settings/#headers) while editing your check.

### Whitelisting browser checks

To whitelist browser checks, allow traffic with user agent containing `Checkly/<UUID>`, with `<UUID>` being your shortened Checkly ID.

You will then be able to set up the matching user agent in your browser checks using
Puppeteer's [setUserAgent method](https://pptr.dev/#?product=Puppeteer&version=v2.0.0&show=api-pagesetuseragentuseragent),
or the `{userAgent}` option passed to Playwright's [newPage method](https://playwright.dev/#version=v1.4.0&path=docs%2Fapi.md&q=browsernewpageoptions--options-useragent).

{{< tabs "User agent example" >}}
{{< tab "Puppeteer" >}}
```js
const puppeteer = require('puppeteer')
const browser = await puppeteer.launch()
const page = await browser.newPage()

const userAgent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36 Checkly/abcd1234'
await page.setUserAgent(userAgent);
```
{{< /tab >}}
{{< tab "Playwright" >}}
```js
const playwright = require('playwright')
const browser = await playwright.chromium.launch()

const userAgent = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36 Checkly/abcd1234'
const page = await browser.newPage({userAgent})
```
{{< /tab >}}
{{< /tabs >}}


text:
Change Log
==========

Version 0.4.1 *(2014-04-17)*
----------------------------

 * Fixed crash on converting @Embedded object with null fields to ContentValues

Version 0.4 *(2014-02-25)*
----------------------------

 * Fixed converting null objects to ContentValues in OptionalTypeAdapter.
 * minSdkVersion = 10

Version 0.3 *(2013-09-21)*
----------------------------

 * Added `getFunctionFor` method returning deserialization `Function<Cursor, T>`.

Version 0.2 *(2013-08-22)*
----------------------------

 * Changed `collectionFromCursor` into `listFromCursor` returning `List<T>` instead of `Collection<T>`.
 * Do not allow multiple @Column annotations with the same column name in scope of a single entity.
 * Added `readonly` argument for @Column annotation to mark that the field should be read from `Cursor`, but not included in `ContentValues`.
 * Added `treatNullAsDefault` argument for @Column annotation to mark that the column should not be included in `ContentValues`, so the backing database can use the default value for this column.

Version 0.1 *(2013-08-14)*
----------------------------

 * Initial release.

repository: Porval/microorm

repo_name: Porval/microorm


text:
# Laser Pointers

### Preconditions
Interface is running in an empty domain where you have edit rights.

### Steps

#### Step 1
- Run the [faceAvatar.js script](./faceAvatar.js?raw=true) (from Menu/Edit/Open and Run scripts From URL...).  Press [SPACE] to rotate around the box.
- Expected: the box should always point towards you
![](./faceAvatar1.jpg)
![](./faceAvatar2.jpg)


text:
# canvas-sequence
Small library that plays image sequences on scroll.

Written in ES6, compiled with Babeljs for browser support. Compatible AMD, CommonJS and plain JS.

# Install
```
npm install
gulp
```

Use `gulp` to automatically recompile when you make changes.

Alternatively, you can use `gulp compile` to recompile only when needed.

# How to use

## Parameters

- **canvasId** (String) : id of the canvas tag you want to use
- **sequencePath** (String) : the path to your image sequence (ex. './img/sequence/').
If your images names are prefixed (ex. img_000.jpg) you must include the prefix in the path.
- **sequenceStart** (Int) : the number of the first frame (ex. if your first frame is img_00056.jpg then sequenceStart = 56)
- **sequenceEnd** (Int) : the number of the last frame
- **fileType** (String) : the file extension you want to use (ex. 'jpg')
- **loadCallback** (function) : a callback to be notified when all images are loaded and ready to use
- **onDraw** (`function(previousFrame:Int, currentFrame:Int)`) : a callback to be notified when the drawn frame changes
- **mode** (String) : Optional, defaults to `SCROLL`. Method to use for
controlling playback of the sequence. See `CanvasSequence.PlayMode` for full
list of supported play modes.
- **fps** (Number) : Optional, defaults to `24`. frames per second to use for video-like playback
- **playOnce** (Boolean) - Optional, defaults to `false`. a flag to make the sequence play
only once (when using `AUTO` mode)
## Init

```javascript
  var sequence = new CanvasSequence('canvas', 'img/sequence_00', 98, 180, '.jpg', function() {
    console.log("Assets are loaded !")
  });
```

repository: ginlane/canvas-sequence

gha_language: JavaScript

repo_name: ginlane/canvas-sequence


text:
# Overview

## The Task

Read through the solution and provide us in a simple document a brief explanation of your understanding of the purpose of the code. In addition, we would like to hear a minimum of 3 improvement suggestions. Please outline the benefits and potential of your suggestions.

## Purpose of the code

Getting binary messages from C++ module and somehow processing it.
It would be easier to understand it all should there business requirements exist.
Without them all that is left to me is to humbly guess which purpose this Node module serves for.

## Suggestions

### Data flow

Since there are several modules residing in the same machine and exchanging data using websockets
on local interface for communication between them would take at least two context switches
for each packet, which slows down the whole thing.

In the first draft of this document I wanted to share with you an idea that unix sockets
should be used instead of websockets, since they are way faster especially when paired with
memory mapped file.

Further reflections of mine lead me to the thought that inter module communications
on the edge machine should be implemented via some kind of a message bus.
At lease I would seek to employ a message bus, since it allows for decoupling of functionality
with all the benefits of such decoupling.

Taking into consideration that the edge machine is quite a powerful one,
I would suggest we should use Redis database with at least one extra module installed: [Redis Streams](https://redis.io/topics/streams-intro).
This would allow us to design the whole system aligned with CQRS ideas and implement proper event sourcing.

Should Redis Streams be employed, we could go further and simplify part of our code removing some libraries.
I would start with removing the RxJS and rewriting the code base using EventEmitters.
This would definitely reduce the amount of JavaScript code in memory that would save some hundreds of bytes
of it and millions of CPU ticks.

Should need arise, I would love to recommend the [redis-fast-driver](https://github.com/h0x91b/redis-fast-driver) library
which is actually written in C++ with a tiny JavaScript wrapper around it.
I have been using it for a couple of years now and have had next to no problems either with it,
or with its author.

NB: please have a look at the [RedisEdge](https://redislabs.com/solutions/redisedge/) and [RedisAI](https://redislabs.com/blog/redis-ai-first-steps/) modules since they might further greatly simplify the whole system.

### Binary messages vs JSON

A lot of effort has been put into defining structures and their validation:

1. every time via `enum`:
   1. [WSConnectionStatus](src/connection/WSConnection.ts)
   2. [RPCRecordType, RPCFunction, RPCCommands, RPCResponseSubject, BinaryDataType](src/constants/Constants.ts)
   3. [BinaryType](src/types/index.ts)
2. some times via `interface`s and `class`es:
   1. [RecognitionMetadata](src/model/person-detection/PersonDetection.ts)
   2. [PlayoutEventOptions, ExtendedPlayoutEventOptions, PlayoutEvent, StartEvent, EndEvent](src/model/playout-event/PlayoutEvent.ts)
   3. [PersonOptions, ContentOptions, FlushOptions](src/poi/test-utils/common.ts)
   4. [BinaryMessage, JSONMessage](src/types/index.ts)
   5. etc.
3. copying an object (actually a `struct`) as in [PersonDetectionMessage.fromObject](src/messages/person-detection/PersonDetectionMessage.ts) via [lodash/cloneDeep](https://lodash.com/docs/4.17.11#cloneDeep)

In all these cases `enum`s, `class`es, and `interface`s denote structures.
Most of them seem (apart from [ContentMessage](src/messages/content/ContentMessage.ts), [PersonDetectionMessage](src/messages/person-detection/PersonDetectionMessage.ts),and [PersonFlushMessage](src/messages/person-flush/PersonFlushMessage.ts)) lack proper validation checks.

Further comes a sketchy list of what I would do if I were given a right to introduce changes to the system as I see fit:

1. I would definitely redefine all of these structures (or at least only those that leave boundaries of a module) in a form of [FlatBuffers IDL](https://google.github.io/flatbuffers/md__schemas.html) and have the `flatc` compiler generate corresponding C++ and JavaScript/TypeScript implementations. This would allow for the following benefits:
   1. strict type checking and validation, since the FlatBuffers support type system.
   2. uselessness of JSON and its validation, thanks to the said type system. Getting rid of JSON would save huge amount of CPU cycles and several hundreds of bytes of RAM. During the development phase it seems like a natural approach to use JSON as the medium, since a lot gets changed in the code base. As the project matures a bit and all the message formats (in our case) get settled down we would no longer want to regularly examine the contents of the messages "by hand". But since this point in time our system would still go on suffering from the bloated nature of JSON. Of course, employing FlatBuffers would require a certain degree of discipline regarding what we transmit via messages, but this would result in a way cleaner and, which is more important, performant system.
   3. TypeScript would become obsolete and the code base would drop quite a lot of hustles connected with code transpilation. The new code would be expressed mostly of simple classes and standalone functions. Very easy for understanding and testing.

NB: as far as I can understand the C++ module provides data in the form of a `msgpack` ([POISnapshot](src/poi/POISnapshot.ts)). Please see [benchmarks](https://google.github.io/flatbuffers/flatbuffers_benchmarks.html). If you are the author of the C++ module
it might be not so time consuming a task to substitute `msgpack` for FlatBuffers to gain even more speed.

### Architecture

I cannot emphasize it more, but I would suggest we should redesign the whole edge system for it
to become a bunch of tiny microservices talking to eash other via Redis.
Let's say, initially they would be written for Node and managed by [PM2](https://github.com/Unitech/PM2/).
Provided that each one does just one thing, it would be very easy for us later to rewrite
at least some of the in a more performant programming language - Rust.

From what I have been given, I could not see how the whole system is deployed onto an edge machine.
Still, I presume there must be some sort of engine (like Kubernetes) supporting it.
We could make our system more secure if we implemented it in Rust and run it within a special
operating system designed from scratch for containers.
I am sure that security is a critical part for our success.

### Project structure

It is simple. Please consider using a monorepo. I have pleasant experience using [Lerna](https://github.com/lerna/lerna).
This would greatly simplify inter service dependencies.

### Logging

Instead of using console, I would recommend using Redis Streams. Its easier, more robust and
performant approach. On the other side of Redis there might be a tiny log transmission service
sitting and injesting the log stream and sending it, for instance, down to the cloud for further
processing.

### CI/CD

This is yet to be figured out. How do you update your software on the edge devices?

### To Sum Up a bit

1. move away from JSON to the strictly typed FlatBuffers
   1. this will reduce RAM requirements;
   2. this will speed up processing messages;
2. move away from websockets on local interface but employ a message bus such as Redis (with appropriate modules)
   1. offload data manipulation tasks to C++ code base of Redis - it processes data way faster and is capable of handling way more data than JavaScript;
   2. it will give you real asynchrony;
3. move away from TypeScript (yes it's a hype, I know) since your code base will be comprised of very tiny services (functions mostly and no longer than a couple of pages of code) whose types will be strictly controlled by FlatBuffers
   1. less software on your `devDependencies` list => less bugs and dependencies, less CPU cycles
4. cut your modules into pieces so that each one does just one type of data conversion
   1. this would allow you later to gradually rewrite your JavaScript code in, say, Rust

repository: Dmitry-N-Medvedev/advertima-review

repo_name: Dmitry-N-Medvedev/advertima-review


text:
---
uuid: 74ab11a3-6a91-4f63-8c09-7de9197e5702
layout: post
title: >-
  React on the Server for Beginners: Build a Universal React and Node App
slug: react-on-the-server-for-beginners-build-a-universal-react-and-node-app
subtitle: null
date: 2016-08-29T21:49:47.000Z
updated: 2016-08-29T21:49:47.000Z
author: Luciano Mammino
author_slug: luciano-mammino
header_img: ./ryoko-tani-universal-javascript-nodejs-react-luciano-mammino-cover.jpg
fb_img: ./react-on-the-server-for-beginners-build-a-universal-react-and-node-app-fb.png
tw_img: ./react-on-the-server-for-beginners-build-a-universal-react-and-node-app-tw.png
status: published
language: en_US
meta_title: null
meta_description: null
tags:
  - node-js
  - react
  - collaboration
---

I recently wrote a new article in collaboration with one of my favourite web development websites: the amazing [Scotch.io](https://scotch.io/).

The article talk about using [React](/tag/react) both on client and on the server (with [Node.js](/tag/node-js)) in an attempt to build a simple "Universal JavaScript" (a.k.a "Isomorphic") application.

The application is called "Judo Heroes" ([did you even noticed recently that I'm kind of fond of Judo?](http://loige.co/extracting-data-from-wikipedia-using-curl-grep-cut-and-other-bash-commands/)) and it showcases some of the best Judo athletes for their number of medals won during the Olympic Games and in other important international tournaments.

[![Judo Heroes main page screenshot](./universal-javascript-judo-heroes-athlete-selection-1.jpg)](https://judo-heroes.herokuapp.com/)

If you are curious you can [check out the live demo](https://judo-heroes.herokuapp.com/) or [have a look at the source code on GitHub](https://github.com/lmammino/judo-heroes).

Then, if you want to follow the tutorial, you should definitely read the article on scotch:

[React on the Server for Beginners: Build a Universal React and Node App](https://scotch.io/tutorials/react-on-the-server-for-beginners-build-a-universal-react-and-node-app)
[![React on the Server for Beginners: Build a Universal React and Node App Article Banner](./scotch-featured-image-react-on-the-server.png)](https://scotch.io/tutorials/react-on-the-server-for-beginners-build-a-universal-react-and-node-app)

In this article we are going to learn how to build a simple "Universal JavaScript" application (a.k.a. "Isomorphic") using **React**, **React Router** and **Express**. We will also use some **Webpack** and **Babel** to leverage the latest **ES2015** Syntax.

Enjoy it and feel free to leave your comments here or on the original article.

Cheers!


text:
---
layout: default
---

# 1996-01-06 - http://www.rsa.com/rsalabs/cryptobytes/

## Header Data

From: Rich Salz<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: f05dc2f52aa3781324a780a353f9ae732ce9e522552905386917a6619b5ea166

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-01-06 00:57:38 UTC

Raw Date: Sat, 6 Jan 1996 08:57:38 +0800

## Raw message

```
{% raw  %}From: Rich Salz<EMAIL_ADDRESS>Date: Sat, 6 Jan 1996 08:57:38 +0800
To<EMAIL_ADDRESS>Subject: http://www.rsa.com/rsalabs/cryptobytes/
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

FYI.

---------- Begin Forwarded Message ----------
From<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>Date: Fri, 05 Jan 1996 12:31:08 EST
Subject: Recent cryptographic findings
To<EMAIL_ADDRESS>
For those who may not have seen it, the most recent issue of CryptoBytes (Vol1,
No. 3) put out by RSA Laboratories has a wealth of information in it.  I have
not had the time to fully digest the importance of all of the articles, but in
the first one Adi Shamir has proposed an "unbalanced RSA" variant of RSA which
"makes it possible to increase the modulus size from 500 bits to 5,000 bits
without any speed penalty."

Another article discusses means of deliberately constructing collisions (due to
Hans Dobbertin of the German Information Security Agency) when using MD4, and
concludes that "where MD4 is in use, it should be replaced." So far, at least,
it appears that MD5, RIPEMD, and SHA-1 would resist this kind of attack, but a
certain amount of nervousness might be in order.

(Hugo Krawczyk of IBM Research and I considered some of these possibilities in
conjunction with work we did on the SEPP protocol, which uses a salted hash
function  as a means of confirming the knowledge of a secret to a third party
without having to use encryption. We were concerned that collisions might be
possible, and also that it might be possible to partially reverse a hash
function and glean at least information about the message that was being
hashed, (the credit card number) in the case of a very short message. We ended
up proposing a combination 140-bit hash function which includes both MD5 and
SHA-1, assuming that it would be much more difficult to break both algorithms
than just one. I will post the analysis to this list in a subsequent message.)

Finally, Burt Kalisky provides a compendium of some of the possible attacks
against RSA, and discusses simple and practical countermeasures.

It seems to me that the most important of the various attacks involve the
encryption and decryption of small messages. Since small messages are
frequently generated for key exchange and for signature purposes, it is
important that we consider these issues carefully. In particular, the use of
pseudo-random padding for both encryption (a la the Bellare-Rogaway Optimal
Asymmetric Encryption Padding) seems very beneficial, and padding is also
important in the signature block.

This group certainly ought to examine these issues very carefully, and we
should probably give serious consideration to adopting OAEP for message
encryption and key exchange. I believe we should also give serious
consideration to a increased length message digest function such as SHA-1, and
perhaps incorporate the use of multiple message digest algorithms for
particularly important signatures , e.g., CA certificates.

The back issues of CryptoBytes are available at
http://www.rsa.com/rsalabs/cryptobytes/.

Bob

----------------------------
Robert R. Jueneman
GTE Laboratories
1-617-466-2820 Office

"The opinions expressed are my own, and may or may not
reflect the official position of GTE, if any."

----------- End Forwarded Message -----------

{% endraw %}
```

## Thread

+ Return to [January 1996](/archive/1996/01)

+ Return to<EMAIL_ADDRESS>(Harry Bartholomew)](/authors/bart_at_netcom_com_harry_bartholomew_)"
+ Return to "[Rich Salz <rsalz@osf.org>](/authors/rich_salz_rsalz_at_osf_org_)"

+ 1996-01-06 (Sat, 6 Jan 1996 08:57:38 +0800) - http://www.rsa.com/rsalabs/cryptobytes/ - _Rich Salz<EMAIL_ADDRESS>  + 1996-01-06 (Sun, 7 Jan 1996 02:55:35 +0800) - [Re: http://www.rsa.com/rsalabs/cryptobytes/](/archive/1996/01/77485a74f0441355c1e75bc5d2403424b8b6d65f32a8f7f4c44b61656f93aba3) -<EMAIL_ADDRESS>(Harry Bartholomew)_


text:
---
title: 'Why My Summer Vacation Was a Total Failure – and Why it Really Wasn’t'
author: Sugar
layout: post
category: blog
redirect_from: "/archives/life/why-my-summer-vacation-was-a-total-failure-and-why-it-really-wasnt"
---
This month, I officially celebrate my first 6 months as a freelancer. Surprisingly enough, one of the reasons I quit my day job and went the self-employed route was because I wanted to work *less*, not more. I don’t want to get rich sacrificing my personal life. I just want to achieve a balance.

So this year, I’ve done the unthinkable: I gave myself a *full month* of vacation time. August is a (really) slow month in Greece anyway, since temperatures have the bad habit of raising to and beyond 30C (~90F). Surely not an appropriate environment for slaving in front of a text editor.

The moment my vacation started, I thought I was in heaven – one full month without commitments, apart from a 9-day trip to UK? You’re kidding me, right? I felt like a schoolgirl again.

However, these idyllic days now belong to the past. As any good thing (insert horrible cliché here), they’re history. And I find myself struggling to get back to work, starting one of my favourite months of the year.

So what have I learnt from this one-month sabbatical? I keep reminding myself these three things:

*   When you’re busy making plans, life is busy passing by. Stop making plans. Never stop doing things and having fun.
*   There’s never enough procrastination. You’ll never bore yourself surfing the shiny ‘nets. It’s in your hands to put an end to your ever-worsening ADHD.
*   Don’t leave any “someday/maybe” plans for your vacation. Vacation time should strictly be time off. Your body won’t let you work anyway.

I was planning to finish my portfolio page this month. Liven up my blog. Work on various personal projects. Improve my web design knowledge and practice.

Instead, what have I done? Nothing really. Read about 9 fiction books, walked around most of London, got a slight tan, went to a kickass beach party and visited relatives & family. Also started a [tiny vidcast][1]. And that’s it.

Will I try this prolonged vacation again? Most probably, yes. Maybe even more. But I’ll start my future vacation thinking about what I won’t do and not about what I’ll do.

That’s always a more realistic point of view, I think.

 [1]: http://sugsays.tumblr.com