text:
---
title: ActionSettingsLocks
---

By default, all the action settings specified are used as the new defaults to the Take
Action Dialog. Certain settings might be locked so that the user cannot change
them through the dialog. If a setting in ActionSettingsLocks is set to true, then the
corresponding group of settings in ActionSettings is locked.

For example, if the TimeRange element of ActionSettingsLocks is true, then the
values specified in ActionSettings for HasTimeRange, StartTime, and EndTime
cannot be changed in the Take Action Dialog.

This is the schema:

```xml
<...>
	<ActionUITitle> xs:boolean </ActionUITitle> [0..1]
	<PreActionShowUI> xs:boolean </PreActionShowUI> [0..1]
	<PreAction>
		<MessageTitle> xs:boolean </MessageTitle> [0..1]
		<MessageText> xs:boolean </MessageText> [0..1]
		<AskToSaveWork> xs:boolean </AskToSaveWork> [0..1]
		<ShowActionButton> xs:boolean </ShowActionButton > [0..1]
		<ShowCancelButton> xs:boolean </ShowCancelButton > [0..1]
		<DeadlineBehavior> xs:boolean </DeadlineBehavior > [0..1]
		<ShowConfirmation> xs:boolean </ShowConfirmation> [0..1]
	</PreAction>
	<HasRunningMessage> xs:boolean </HasRunningMessage> [0..1]
	<RunningMessage> [0..1]
		<Title> xs:boolean </Title> [0..1]
		<Text> xs:boolean </Text> [0..1]
	</RunningMessage>
	<TimeRange> xs:boolean </TimeRange> [0..1]
	<StartDateTimeOffset> xs:boolean </StartDateTimeOffset> [0..1]
	<EndDateTimeOffset> xs:boolean </EndDateTimeOffset> [0..1]
	<DayOfWeekConstraint> xs:boolean </DayOfWeekConstraint> [0..1]
	<ActiveUserRequirement> xs:boolean </ActiveUserRequirement> [0..1]
	<Whose> xs:boolean </Whose> [0..1]
	<Reapply> xs:boolean </Reapply> [0..1]
	<ReapplyLimit> xs:boolean </ReapplyLimit> [0..1]
	<ReapplyInterval> xs:boolean </ReapplyInterval> [0..1]
	<RetryCount> xs:boolean </RetryCount> [0..1]
	<RetryWait> xs:boolean </RetryWait> [0..1]
	<TemporalDistribution> xs:boolean </TemporalDistribution> [0..1]
	<PostActionBehavior> [0..1]
		<Behavior> xs:boolean </Behavior> [0..1]
		<AllowCancel> xs:boolean </AllowCancel> [0..1]
		<Deadline> xs:boolean </Deadline> [0..1]
		<Title> xs:boolean </Title> [0..1]
		<Text> xs:boolean </Text> [0..1]
	</PostActionBehavior>
</...>
```

gha_language: JavaScript


text:
# Classify MNIST dataset using TensorFlow

This sample uses the popular [TensorFlow](https://www.tensorflow.org/) machine learning library from Google to classify the ageless [MNIST dataset](http://yann.lecun.com/exdb/mnist/) of handwritten digits.

## Logging code
This sample code is directly copied from TensorFlow sample code collections on GitHub. The only change we make is to add some logging code into the experiment.

Here are some relevant code snippets:
```python
# reference the Azure ML logging library
from azureml.logging import get_azureml_logger
...
# initialize the logger
run_logger = get_azureml_logger()
...
# declare empty lists
metrics = []
losses = []
# during the training session
while step * batch_size < training_iters:
    ...
    # record accuracy and loss into a list
    metrics.append(float(acc))
    losses.append(float(loss))
    ...

# log the list of accuracies and losses
run_logger.log("Accuracy", metrics)
run_logger.log("Loss", losses)
```

By adding the above logging code, when the run finishes, you can find a graph plotted for you in the run history detail page.

![cover](./docs/cover.png)

## Instructions for running scripts from CLI window
You can run the scripts from the Workbench app, but it is more interesting to run it from the command-line window so you can watch the feedback in real-time.

Open the command-line window by clicking on **File** --> **Open Command Prompt**, then run `tf_mnist.py` in local Python environment installed by Azure ML Workbench by typing in the following command.
```
# first install tensorflow library using pip
$ pip install tensorflow

# submit the experiment to local execution environment
$ az ml experiment submit -c local tf_mnist.py
```

If you have Docker engine running locally, you can run `tf_mnist.py` in a Docker container.

>Note: this command automatically pulls down a base Docker image so it can take a few minutes before the job is started. But this only happens if you are running it for the first time. The subsequent runs will be much faster.

```
# submit the experiment to local Docker container for execution
$ az ml experiment submit -c docker tf_mnist.py
```

Run tf_mnist.py in a Docker container in a remote machine. Note you need to create/configure myvm.compute.
```
$ az ml experiment submit -c myvm tf_mnist.py
```

## Running it on a VM with GPU
With computationally expensive tasks like training a neural network, you can get a huge performance boost by running it on a GPU-equipped machine.

>Note, if your local machine already has NVidia GPU chips, and you have installed the CUDA libraries and toolkits, you can skip step 1 and step 2.

### Step 1. Provision a GPU Linux VM
Creatie a DSVM in Azure portal using one of the NC-series VM templates.

### Step 2. Attach the compute context
Run following command to add the GPU VM as a compute target in your current project:
```
$ az ml computetarget attach --name myvm --address <ip address or FQDN> --username <username> --password <pwd> --type remotedocker
```
The above command creates a `myvm.compute` and `myvm.runconfig` file under the `aml_config` folder.

### Step 3. Modify the configuration files under _aml_config_ folder
You need the TensorFlow library built for GPU:
- In `conda_dependencies.yml` file, replace `tensorflow` with `tensorflow-gpu`.

You need a different base image with CUDA drivers and libraries preinstalled:
- In `myvm.compute` file, replace `microsoft/mmlspark:plus-0.7.91` with `microsoft/mmlspark:gpu-plus-0.7.91`

You need to use _NvidiaDocker_ command to start the Docker container as opposed to the regular _docker_ command.
- In `myvm.compute`* file, add a line: `nvidiaDocker: true`

You need to specify the run time framework as _Python_ as opposed to _PySpark_:
- In `myvm.runconfig` file,  change the value of `Framework` from `PySpark` to `Python`.

### Step 4. Run the script.
Now you are ready to run the script.
```
$ az ml experiment submit -c gpu tf_mnist.py
```
You should notice the script finishes significantly faster than than if you use CPU.

license: MIT

repository: amlsamples/tf

branch_name: refs/heads/master

extension: md

gha_language: Python

license_type: permissive

repo_name: amlsamples/tf


text:
# ct-boundaries
Connecticut and Hartford-area boundaries in GeoJSON format

See both full-size originals and simplified versions (created with https://Mapshaper.org) with smaller file sizes for use in small-scale interactive maps

View in GitHub, or open in https://mapshaper.org or https://geojson.io to inspect features or edit properties

Read more in https://handsondataviz.org

## Connecticut
- CT Towns 2021 https://data.ct.gov/Government/Town-Boundary-Index-Map/evyv-fqzg
- CT House Districts 2020 https://ct-deep-gis-open-data-website-ctdeep.hub.arcgis.com/datasets/64464e6e13f34c2badfe1e4950d6e7fe_0/explore
- CT Senate Districts 2020

## Hartford
- Hartford Neighborhoods 2021 https://openhartford-hartfordgis.opendata.arcgis.com/datasets/neighborhood-district/explore

branch_name: refs/heads/main


text:
<h2 align="center">
   Laravel Accessory
</h2>

## Introduction
Laravel Accessory provides a collection of helper methods and traits for supercharging your Laravel Applications.

## License
Laravel Accessory is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)

### Installation
This packages works for Laravel versions 5.* only.

Install Laravel Accessory as you would with any other dependency managed by Composer:

 ```bash
 $ composer require percymamedy/laravel-accessory
 ```

### Configuration
> If you are using Laravel >= 5.5, you can skip service registration
> and aliases registration thanks to Laravel auto package discovery
> feature.

### Usage

Let's take a look at the available features and helpers provided by Laravel Accessory.

### Available Traits

Laravel Accessory provides you with useful traits that can be easily applied to your classes.

#### ```Makable```

The ```Makable``` trait simply adds a ```static make()``` method to your classes. This allows you to fluently create new
instances of a class without using the ```new``` keyword everytime. This is simply sugar coating for newing up objects.

Consider the following Mail class with the ```Makable``` trait applied to it :

```php
<?php

namespace App\Mail;

use App\Order;
use Illuminate\Bus\Queueable;
use Illuminate\Mail\Mailable;
use Accessory\Support\Makable;
use Illuminate\Queue\SerializesModels;

class OrderShipped extends Mailable
{
    use Makable, Queueable, SerializesModels;

    /**
     * The order instance.
     *
     * @var Order
     */
    protected $order;

    /**
     * Create a new message instance.
     *
     * @return void
     */
    public function __construct(Order $order)
    {
        $this->order = $order;
    }

    /**
     * Build the message.
     *
     * @return $this
     */
    public function build()
    {
        //
    }
}
```

You may now new up the Mail class using the ```static make()``` method directly on the class like so :

```php
<?php

namespace App\Http\Controllers;

use App\Order;
use App\Mail\OrderShipped;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;
use App\Http\Controllers\Controller;

class OrderController extends Controller
{
    /**
     * Ship the given order.
     *
     * @param  Request  $request
     * @param  int  $orderId
     * @return Response
     */
    public function ship(Request $request, $orderId)
    {
        $order = Order::findOrFail($orderId);

        // Ship order...

        $message = OrderShipped::make($order);

        Mail::to($request->user())->send($message);
    }
}
```

Good use for the ```Makable``` trait is within ```Jobs```, ```Mailables```, ```Events``` and ```Notifications```. You can of course use it on any class that you desire.

#### ```Dispatchable```

The ```Dispatchable``` trait extends the ```Illuminate\Foundation\Bus\Dispatchable``` but adds a ```static dispatchNow()``` method which  allows you to dispatch ```Jobs``` to its appropriate handler in the current process.

Consider the following Job class with the ```Dispatchable``` trait applied to it :

```php
<?php

namespace App\Jobs;

use App\Podcast;
use App\AudioProcessor;
use Illuminate\Bus\Queueable;
use Accessory\Bus\Dispatchable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;

class ProcessPodcast implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $podcast;

    /**
     * Create a new job instance.
     *
     * @param  Podcast  $podcast
     * @return void
     */
    public function __construct(Podcast $podcast)
    {
        $this->podcast = $podcast;
    }

    /**
     * Execute the job.
     *
     * @param  AudioProcessor  $processor
     * @return void
     */
    public function handle(AudioProcessor $processor)
    {
        // Process uploaded podcast...
    }
}
```

You may now dispatch the Job immediately using the ```static dispatchNow()``` method directly on the class like so :

```php
<?php

namespace App\Http\Controllers;

use App\Jobs\ProcessPodcast;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PodcastController extends Controller
{
    /**
     * Store a new podcast.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request)
    {
        // Create podcast...

        ProcessPodcast::dispatchNow($podcast);
    }
}
```

The ```Dispatchable``` trait also adds a ```when()``` method which will allow you to dispatch Jobs depending on the condition passed to this method.

You may now dispatch the Job depending on the condition passed to the ```when()``` method.

```php
<?php

namespace App\Http\Controllers;

use App\Jobs\ProcessPodcast;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PodcastController extends Controller
{
    /**
     * Store a new podcast.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request)
    {
        // Create podcast...

        ProcessPodcast::when($request->has('process_podcast'))->dispatch($podcast);
    }
}
```

You can also pass a closure to the ```when()``` method. The closure should return a boolean either which will in turn decide if the Job should be dispatched or not.

```php
<?php

namespace App\Http\Controllers;

use App\Jobs\ProcessPodcast;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PodcastController extends Controller
{
    /**
     * Store a new podcast.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request)
    {
        // Create podcast...

        ProcessPodcast::when(function() use($request) {
            return $request->has('process_podcast') && $request->process_podcast === 1;
        })->dispatch($podcast);
    }
}
```

repository: percymamedy/laravel-accessory

repo_name: percymamedy/laravel-accessory


text:
---
date: 2018-09-17T15:21:22+02:00
title: Introduction
description: Introduction to the notifcations extension.
weight: 1
---

The notification extension is used to manage notifications to managers, admins and users. It allows companies to setup custom notifications for specific events in Rehive (eg. Verification emails, password resets, welcome emails etc.).

The full API specification can be found here

The Swagger specification can be found here

The extension allows you to:

1. Configure notifications
2. Send email notifications
3. Send SMS notifications
4. Send Push notifications in android/iOS applications (chat to support about getting this enabled)

repository: rehive/docs-portal

gha_language: Dockerfile

gha_license_id: MIT

repo_name: rehive/docs-portal


text:
---
layout: post
title: "Handwritten Chinese Character Recognition by Convolutional Neural Network and Similarity Ranking"
date: 2019-08-30 06:21:52
categories: arXiv_CV
tags: arXiv_CV Review CNN Recognition
author: Junyi Zou, Jinliang Zhang, Ludi Wang
mathjax: true
---

* content
{:toc}

##### Abstract
Convolution Neural Networks (CNN) have recently achieved state-of-the art performance on handwritten Chinese character recognition (HCCR). However, most of CNN models employ the SoftMax activation function and minimize cross entropy loss, which may cause loss of inter-class information. To cope with this problem, we propose to combine cross entropy with similarity ranking function and use it as loss function. The experiments results show that the combination loss functions produce higher accuracy in HCCR. This report briefly reviews cross entropy loss function, a typical similarity ranking function: Euclidean distance, and also propose a new similarity ranking function: Average variance similarity. Experiments are done to compare the performances of a CNN model with three different loss functions. In the end, SoftMax cross entropy with Average variance similarity produce the highest accuracy on handwritten Chinese characters recognition.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1908.11550](http://arxiv.org/abs/1908.11550)

##### PDF
[http://arxiv.org/pdf/1908.11550](http://arxiv.org/pdf/1908.11550)


text:
# `no-var-keyword`

Disallows usage of the `var` keyword.

## Rationale

Use `let` or `const` instead,
because they are more suitable and are block scoped.

## Implementation

```json
{
  "rules": {
    "no-var-keyword": true
  }
}
```

See: https://palantir.github.io/tslint/rules/no-var-keyword/


text:
In this challenge, establish which type of constrained writing is applied to a sentence. There are four possible types to detect:

Pangram: the sentence contains all the 26 letters of the English alphabet.
Heterogram: the sentence doesn't have multiple instances of its letters (as to say that every letter is unique).
Tautogram: every word of the sentence starts with the same letter.
Transgram: all words of the sentence share at least a common letter.
Given a string txt being a sentence, implement a function that returns the strings "Pangram", "Heterogram", "Tautogram" or "Transgram" accordingly to the above definitions and following the same given order to establish the result. If no constrained writing is detected, return the string "Sentence".

Examples

constraint("The quick brown fox jumps over the lazy dog.") ➞ "Pangram"
// The sentence contains every letter of the alphabet.
// Repetitions are not considered.

constraint("The big dwarf only jumps.") ➞ "Heterogram"
// The sentence has only unique characters.

constraint("Todd told Tom to take the tiny turtles.") ➞ "Tautogram"
// Every word starts with the letter "t".

constraint("A cannibal alligator has attacked an unaware vegan alligator.") ➞ "Transgram"
// Every word contains the letter "a".

constraint("The unbearable lightness of coding...") ➞ "Sentence"
// No constraint is applied to the sentence.

Notes
Output: Pangram: true, Heterogram: false, Tautogram: true, Transgram: false; (the values may be either true or false)

Sentences will contain letters (either uppercase or lowercase) and punctuation. Your function must be case-insensitive.

repository: redbearin/skill-work

repo_name: redbearin/skill-work


text:
# container-proxy
Tool for running programs outside of a the invoking container

## Motivation
When running GUI programs inside a container, it is useful to be able to open
hyperlinks from within that program with a program external to the container.

This can be achieved by creating a symbolic link to `client.py` called
`xdg-open` inside the container, running `server.py`, and mounting the socket
into the container.

## Use with Vagga
[Vagga](https://github.com/talihook/vagga) is a container-runtime that unlike
Docker, does not require running a daemon as root. Configuration would like like
so:

```yaml
containers:
  test:
    setup:
      - !Ubuntu xenial
      - !UbuntuUniverse
      - !Install [python3]
      - !Copy
        source: /work/container_proxy
        path: /usr/lib/python3/dist-packages/container_proxy
      - !Copy
        source: /work/client.py
        path: /usr/bin/xdg-open
    volumes:
      /tmp: !Tmpfs
        size: 100Mi
        mode: 0o1777
        subdirs:
          .X11-unix: #
        files:
          container_proxy.sock: ""
      /tmp/.X11-unix: !BindRW /volumes/X11
      /tmp/container_proxy.sock: !BindRW /volumes/container_proxy_sock
commands:
  run: !Command
    description: "Run program"
    container: test
    work-dir: /work
    run: [bash]
```

Where `X11` and `container_proxy_sock` are
[external volumes](http://vagga.readthedocs.io/en/latest/settings.html#opt-external-volumes)
defined as follows:

```yaml
external-volumes:
  X11: /tmp/.X11-unix
  container_proxy_sock: /tmp/container_proxy.sock
```

When the container launches `xdg-open` due to clicking a hyperlink, the
container will actually run our proxy script that requests the server to launch
the browser for us.

repository: matthiasvegh/container-proxy

repo_name: matthiasvegh/container-proxy


text:
## **1.0.2** 2022-09-26 ([d4627c5...e670157](https://github.com/bastidest/vue-step-progress/compare/d4627c5...e670157?diff=split))

### Bug Fixes
*  lowercase external Vue import in UMD webpack build ([d4627c5](https://github.com/bastidest/vue-step-progress/commit/d4627c5))

## **1.0.2-rc1** 2022-09-26 ([d4627c5...6f2b1f4](https://github.com/bastidest/vue-step-progress/compare/d4627c5...6f2b1f4?diff=split))

### Bug Fixes
*  lowercase external Vue import in UMD webpack build ([d4627c5](https://github.com/bastidest/vue-step-progress/commit/d4627c5))

## **1.0.1** 2022-07-28 ([8ea63f2...1f8f3e2](https://github.com/bastidest/vue-step-progress/compare/8ea63f2...1f8f3e2?diff=split))

### Bug Fixes
*  resolve vue as external library in prod build ([8ea63f2](https://github.com/bastidest/vue-step-progress/commit/8ea63f2))

## **1.0.0** 2022-07-28 ([97b9f4d...4a7d486](https://github.com/bastidest/vue-step-progress/compare/97b9f4d...4a7d486?diff=split))

### Features
*  add Vue 3 support (thanks @romanmartushev !) ([69bacbf](https://github.com/bastidest/vue-step-progress/commit/69bacbf))

### BREAKING CHANGES
*  drop Vue 2 support ([69bacbf](https://github.com/bastidest/vue-step-progress/commit/69bacbf))

## **0.3.8** 2022-07-13 ([b6aa69c...b230632](https://github.com/bastidest/vue-step-progress/compare/b6aa69c...b230632?diff=split))

### Security
*  update outdated dev\-dependencies ([a3e6625](https://github.com/bastidest/vue-step-progress/commit/a3e6625))

## [0.3.7] - 2021-08-15
### Added
- Build scripts for developing inside docker containers
### Security
- Update dependencies

## [0.3.6] - 2020-12-11
### Security
- Update dependencies (webpack 5)

## [0.3.5] - 2020-08-26
### Security
- Update vue dependency
- Update dev dependencies

## [0.3.4] - 2020-07-18
### Security
- Update dev dependencies

## [0.3.3] - 2020-03-19
### Added
- Add description of additional props (#5)
### Security
- Update dependencies

## [0.3.2] - 2020-02-24
### Security
- Update dependencies
- Replace UglifyJSPlugin by TerserPlugin

## [0.3.1] - 2019-08-27
### Security
- Updated dependencies

## [0.3.0] - 2019-08-05
### Added
- Custom CSS variables
### Security
- Updated dependencies

## [0.2.0] - 2018-10-20
### Fixed
- Rename and fix css classes

## [0.1.0] - 2018-03-01
### Added
- Initial Release

repository: bastidest/vue-step-progress

gha_language: Vue

repo_name: bastidest/vue-step-progress


text:
# Netflix-Data-Analysis

## Table of Contents
1. [Installation](#installation)
2. [Project Motivation](#project-motivation)
3. [File Description](#file-description)
4. [Results](#results)
5. [Licensing, Authors, and Acknowledgements](#licensing-authors-and-acknowledgements)

## Installation
### Dependencies
* Python >=3.7
* matplotlib >= 3.4.2
* numpy >= 1.21.1
* pandas >= 1.3.1
* seaborn >= 0.11.1

### User Installation
Assuming you already have Python>3.7 up and running, the easiest way to install
the requirements is using **pip** or **conda**. This tutorial assumes using _pip_
for the installation purposes.

Create a virtual environment to set up the project. (Optional Step)

``
python3 -m venv <my_env>
``

cd to the root directory of the code and install the requirements using

``
pip install -r requirements.txt
``

## Project Motivation
For this project, I was interested in Netflix data available as of 2021. The
questions of interest that we will be exploring are:
* In what month of the year, does the most new content gets added to netflix?
* What is the average delay between release of a show and its arrival on netflix.
* How does the different genres relate to the target audience belonging to different age groups?
* Which Country has most content available on netflix?

## File Description
For the purpose of answering above questions, this project contains a single notebook
that addresses the questions. The data under consideration is available as a csv
file which is also publicly available as [Netflix Movies and TV Shows on Kaggle.](https://www.kaggle.com/shivamb/netflix-shows)

## Results
The findings of the analysis are discussed in the jupyter notebook as well as in
a blog post [here](https://medium.com/@RamshahJahangir/understanding-content-arrival-trend-on-netflix-9497ecf01290).

## Licensing, Authors, and Acknowledgements
All data credit to Netflix for data. You can find the Licensing for the data and
other descriptive information on Kaggle at [Netflix Movies and TV Shows](https://www.kaggle.com/shivamb/netflix-shows).

gha_language: Jupyter Notebook


text:
---
templateKey: about-page
title: About Us
quotes:
  - name: 'Joshua Morris, Founder'
    quote: >-
      Some problems in life appear too complex to attempt and the cube has
      become the very image of this fear. We are here to show you that your
      brain can break down almost any problem - and this is just the
      beginning.....
    quoteImage: /img/joshua.webp
  - name: 'David Plews, Founder'
    quote: >-
      We aim to not only teach you to solve a cube - but to expand your
      abilities for problem solving. Once you have the skills to unpick a
      problem - that's when you can construct a solution.
    quoteImage: /img/dsc_1031.jpg
---
### Joshua Morris, Co-founder

Find me on LinkedIn:\
<https://www.linkedin.com/in/joshua-morris-0a5145135/>\
<https://www.linkedin.com/company/the-silent-cow>

Find me on Instagram:\
<https://www.instagram.com/joshua_cubed/>\
<https://www.instagram.com/thesilentcow/>

###

### David Plews, Co-founder

Find me LinkedIn:\
<https://www.linkedin.com/company/the-silent-cow>\
<https://www.linkedin.com/in/cleargif/>

Find me on Instagram:\
<https://www.instagram.com/thesilentcow/>\
<https://www.instagram.com/icubeinpublic/>

repository: Plathond-com-Organization/silentcow

repo_name: Plathond-com-Organization/silentcow


text:
# Hypochnicium gomezii S.E. López & J.E. Wright, 1985 SPECIES

#### Status
SYNONYM

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

#### Published in
Mycotaxon 23: 439 (1985)

#### Original name
Hypochnicium gomezii S.E. López & J.E. Wright, 1985

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Polyporales/Meruliaceae/Nodotia/Nodotia gomezii/ Syn. Hypochnicium gomezii/README.md

repo_name: mdoering/backbone


text:
## Deposit (DEPRECATED)

**Category:** System
**Permission:** SUPERUSER
**Call Type:** Synchronous

Deposits funds into an account. This call is no longer used and is documented here only for completeness. This call has been replaced by **CreateDepositTicket.**

### Request

```json
{
    "omsId": 0,
    "accountId": 0,
    "instrumentId": 0,
    "amount": 0.0,
    "depositInfo": null
}
```

| Key          | Value                                                        |
| ------------ | ------------------------------------------------------------ |
| omsId        | **integer.** The ID of the Order Management System into which the deposit is being made. |
| accountId    | **integer.** The ID of the account receiving the deposit.    |
| instrumentId | **integer.** The ID of the product (not instrument) being deposited. The AlphaPoint exchange differentiates between products and instruments (two products comprise an instrument, BitCoin and dollars, for example).      |
| amount       | **real.** The unit and fractional amount of the deposit. For example, 2.5 BitCoin or 201.85 dollars. |
| depositInfo  | **JSON string object.** A JSON object describing a deposit form template. The template may vary from Account Provider to Account Provider. You can obtain a list of templates available to you (and their contents) by calling **GetDepositRequestInfoTemplate** (you must have Operator or Trading permissions). |

### Response

```json
{
    "result": true,
    "errormsg": "",
    "errorcode": 0,
    "detail": ""
}
```
| Key       | Value                                                        |
| --------- | ------------------------------------------------------------ |
| result    | **Boolean.** If the call has been successfully received by the Order Management System, *result* is *true;* otherwise it is *false.* |
| errormsg  | **string.** A successful receipt of the call returns *null.* The *errormsg* key for an unsuccessful call returns one of the following messages:
Not Authorized (errorcode 20)
Invalid Response (errorcode 100)
Operation Failed (errorcode 101)
Server Error (errorcode 102)
Resource Not Found (errorcode 104)
Operation Not Supported (errorcode 106) |
| errorcode | **integer.** A successful receipt of the call returns 0. An unsuccessful receipt of the call returns one of the *errorcodes* shown in the *errormsg* list. |
| detail    | **string.** Message text that the system may send.           |

repository: alphapoint/slate

gha_license_id: NOASSERTION

repo_name: alphapoint/slate


text:
### Section 2.5 Endowment Giving.

1. Unrestricted endowment.  Gifts, not designated for other specific
   purposes, shall be added to an IFI Unrestricted Endowment; income and
   other returns from which shall cover IFI operations and periodic
   distributions to IFI for
   programs and services, capital improvements, and special projects.

2. Named Funds.  Named Funds (donations at or exceeding $15,000) may be
   established by donors within IFI’s funds.  All named funds shall be
   created by a written gift agreement.  The written agreement should
   include language to permit IFI to assign an
   alternative, related use of such funds if it becomes necessary, i.e. due
   to the elimination of a program supported by the fund.

    1. Any other gifts made to a named fund by any donor will be subject to
       the provisions of the fund.

    2. If the Named Fund is not fully funded by the donor, IFI
       has the discretion (subject to the terms of the gift
       agreement) to shift the funds to IFI’s Unrestricted Endowment,
       effectively dissolving the named fund.


text:
## aescrypt

#### A Python 2 script to encrypt/decrypt files with symmetric AES cipher-block chaining (CBC) mode.

```
usage: aescrypt.py [-h] [-e] [-d] [-f] in_file

positional arguments:
  in_file        Input file

optional arguments:
  -h, --help     show this help message and exit
  -e, --encrypt  Encrypt file
  -d, --decrypt  Decrypt file
  -f, --force    Overwrite output file if it exists

Examples:

Encrypt file:

./aescrypt.py -e <file name>

Decrypt file:

./aescrypt.py -d <file name>.enc
```

#### Acknowledgements

This script is derived from an answer to this StackOverflow question:

http://stackoverflow.com/questions/16761458/

#### License

MIT License © 2015 Christopher Arndt

repository: icakir/aescrypt

repo_name: icakir/aescrypt


text:
---
title: Kuhscheibe
date: 2010-2-26
blurb: with Christian
category: skiing
layout: post
location: Kuhscheibe
guests: Christian
elevation: 1650
---

Also posted on Summitpost.org [here](https://www.summitpost.org/ski-tour-on-the-kuhscheibe/600904)

Just a nice ski tour
---

{% image /cmaimages/2010/on-the-approach_4392626693_o.jpg %}

_On the approach_.

It had been almost 2 years since I got to do a climb with Christian. We were
actually excited to do an ice climb, but the really warm weather in the last
week had a devastating impact on the ice. So, what to do? Go hiking! Which means
skiing this time of year.

Christian suggested skiing up the Kuhscheibe or one of the other peaks around
the Amberger Hut in the Stubai Range. I'd never been over there, so it sounded
like a great plan. The drive was pretty long, factoring in two stops it took 3
hours from Munich. I was surprised because most of the time my visits to the
Stubai Range are in the big Stubai Valley or the Sellrain Valley, each of which
is just 2 hours from home. But this location on the west and south of the range
is quite far, basically near the big Sölden resort skiing area. Oh well, we were
skinning up the closed road at 9 am on a great blue sky day.

There had been rain and snow the day before, and Sunday was predicted to be
unsettled as well. Score one for us in the eternal battle with the weather gods!

An hour and a half up the road, through pretty open country of the lower
Sulztal, and we reached the Amberger Hütte. "How about some Apfelstrüdel,
Christian?" Never pass up a chance for sugary fuel, I thought. "Sure!" he said.

As we ate we talked about peaks we wanted to climb. "Charles and I are planning
for the Pallavicini Rinne on the Grossglockner in April or May, want to come?"
Three people for that trip would be better than two. We could share one rope and
one stove for the bivouac hut. We made rough plans and slowly the process of
generating excitement for the summer season begins.

{% image /cmaimages/2010/in-the-rosskar_4392628033_o.jpg %}

_In the Rosskar_

{% image /cmaimages/2010/above-the-rosskar_4393400578_o.jpg %}

_Above the Rosskar_

{% image /cmaimages/2010/small-scale_4393398652_o.jpg %}

_Small scale_

Back out in the sun we crossed part of the long flat Sulztal meadow, then
followed a trail made that morning by some skiers (and a dog). It took us
steeply up the west valley wall and ultimately into a side valley called the
Roßkar. Already the hut looked far away. We continued in here for a while, then
the track branched again. Going left and south, we climbed into a basin below
the Kuhscheibenspitze glacier. For a moment I thought we made a wrong turn, as
it looked like our side valley ended in a rugged crest. But it was an
illusion. A look at the map made clear a narrow gap that allowed us to climb
onto the small (pocket) glacier. Up there we could see climbers on the summit
ridge, blowing spindrift all around them. "Windy up there!" We put on jackets
and made the last switchbacks to the ski depot as the first descenders started
making tracks down. A few minutes of climbing awkwardly in ski boots and we were
on the satisfyingly narrow summit.

{% image /cmaimages/2010/the-schrankogel_4393395880_o.jpg %}

_The Schrankogel_

The Schrankogel was the dominating peak, off to our east, but many others vied
for attention, including those on the other side of the Ötz valley where we
drove in. We noticed that those peaks don't seem to get a lot of skiers
attention, seeming quite rugged with steep valley flanks.

Down we went, Christian making beautiful turns and me muddling along as best I
could. Later, I became unbalanced in the powdery snow and fell, losing a ski. I
grew alarmed as I combed the area, unable to find it! "Oh man!" I
thought. Eventually it appeared, trampled beneath my steps in a particularly
deep area.

Back to the hut for some coffee, then a rapid ski down to Christian's car in
Gries. Really nice day!

Elevation gain/loss: 1650 meters (~5400 feet)
Time: 5 hours to summit, 7 hours total (1 hour hanging around the hut)

{% image /cmaimages/2010/christian-on-the-summit_4393401814_o.jpg %}

_Christian on the summit_

{% image /cmaimages/2010/on-the-summit-of-kuhscheibenspitze_4393394900_o.jpg %}

_On the summit of Kuhscheibenspitze_

{% image /cmaimages/2010/looking-down_4392632803_o.jpg %}

_Looking down..._

{% image /cmaimages/2010/mountains-to-the-west_4392633717_o.jpg %}

_To the west_

repository: ripsawridge/site

repo_name: ripsawridge/site


text:
# Putting Web Workers to Work

HTML5 supports [Web Workers](http://www.w3.org/TR/workers/),
which are execution processes that allow JavaScript code to run
independently of the main event loop. This means we can move
some of the more intensive calculations, that would
otherwise lock up the browser, into a separate
process—keeping the user interface responsive while
continuing to crunch numbers in the background. Check this
[compatibility table](http://caniuse.com/webworkers) to see
which browsers support web workers.

To create a new worker, in the main script, instantiate a
`Worker` object by passing the location of a JavaScript file to run:

    var worker = new Worker('./task.js');

Communication with a worker and the main script is done by
passing messages, which are just event handlers on a [Worker](https://developer.mozilla.org/En/DOM/Worker)
object. Data can be sent through the event's `data` property
and is passed to a worker as an argument to its `postMessage` method:

    worker.postMessage({message:"Message from main script!", x:1, y:2});

This sends a *copy* of the data and not a reference, which
is usually the case when passing objects to JavaScript
functions. This is because objects are serialized and
de-serialized when passed back and forth as
messages. And something else to keep in mind, since workers
are unable to access the DOM or the variable scope of the
main script, any initialization of a worker will have to be
done by passing a message to it.

To receive a message from the worker, add an event handler
for type `message`:

    worker.addEventListener('message', function (event) {
      console.log(event.data);
    }, false);

Sending and handling data from within a worker script is
done in the same manner as above, however, the event handler
and methods are on the `self` object—the global space of the worker:

    self.postMessage("Message from the worker!");

    self.addEventListener('message', function (event) {
      //redirect a message back to main, since a worker can't access console.log
      self.postMessage("Send back: " + event.data);
    }, false);

To immediately kill a web worker, call its `terminate` method:

    worker.terminate();

For further details on how to use web workers, see
[Using Web Workers](https://developer.mozilla.org/En/Using_web_workers).

# Offloading Physics Calculations to a Web Worker

In this example we'll build off exercise
[06-multi-billiard-2.html](https://github.com/lamberta/html5-animation/blob/master/examples/ch11/06-multi-billiard-2.html)
from chapter 11, but take all the collision detection
calculations and move them into a separate web worker
process.

In previous examples, each collision detection step is run
on every frame of the animation loop. This works fine for the
examples in this book, because the amount of calculations
can be done speedily enough as to not hold up the next
animation frame request significantly. This would decrease our
framerate which is typically 60 fps using
`window.requestAnimationFrame` on a fast computer. However,
if we add more and more calculations to process on each
frame, then the browser will in effect “lock up” before
moving on to the next frame, slowing the animation playback
and making the user interaction feel sluggish as the browser
waits to respond.

A solution to this is to create a separate web worker
process that runs a loop with all our collision detection
calculations; we will step its frequency up or down as
needed. In this example we'll run it at 30 fps which is half
the rate of the animation loop (in file
[collision-worker.js](https://github.com/lamberta/html5-animation/blob/master/xtras/web-workers/collision-worker.js)):

    self.setInterval(processFrame, 1000/30);

After the collision detection is calculated, the updated values are
sent to the main script where the balls are updated before being
rendered to the canvas (in document
[web-worker-billiards.html](https://github.com/lamberta/html5-animation/blob/master/xtras/web-workers/web-worker-billiards.html)):

    worker.addEventListener('message', function (event) {
      for (var i = 0, balls_copy = event.data, len = balls_copy.length; i < len; i++) {
        balls[i].x = balls_copy[i].x;
        balls[i].y = balls_copy[i].y;
      }
      renderFrame = true; //used to avoid excessive repaints
    }, false);

Since the physics code is executed at half the frequency as
the animation loop, the canvas only needs to be redrawn
every other frame (ideally). To control this we check the
`renderFrame` flag in our animation loop:

    (function drawFrame () {
      window.requestAnimationFrame(drawFrame, canvas);

      if (renderFrame) {
        context.clearRect(0, 0, canvas.width, canvas.height);
        balls.forEach(draw);
        renderFrame = false;
      }
    }());

The code in this example is basically all the same from the
example in chapter 11, just structured differently. The
trickiest part is initializing variables across the main
script and the worker, and making sure to update values
using the passed object copies. The example code has been
commented thoroughly, so make sure you take a look at it.


text:
[![Build Status](https://travis-ci.org/Hoxtygen/Politico.svg?branch=develop)](https://travis-ci.org/Hoxtygen/Politico)

[![Maintainability](https://api.codeclimate.com/v1/badges/d4a696665404417d1c2d/maintainability)](https://codeclimate.com/github/Hoxtygen/Politico/maintainability)
[![Coverage Status](https://coveralls.io/repos/github/Hoxtygen/Politico/badge.svg?branch=develop)](https://coveralls.io/github/Hoxtygen/Politico?branch=develop)

# Politico
Politico enables citizens give their mandate to politicians running for different government offices while building trust in the process through transparency.

# Getting Started and Installing
Download or clone a copy of this repository to your local machine and do `npm install`. After that, do `npm run dev` to get the repo running.

# Pre-requisites
You must have a recent version of node on your local machine, and have babel as one of your dependencies to transpile to ES5 as codes are written with ES6

# Coding style
Conforms with Airbnb style guide

# Author
Idowu Wasiu

# License
This project is licensed under the MIT License

# Acknowledgement
Shoutout to Andela Nigeria for this glorious opportunity.

Big thumbs up for my LFA for his availability and feedback

repository: Hoxtygen/Politico

branch_name: refs/heads/develop

gha_language: HTML

repo_name: Hoxtygen/Politico


text:
# README
## Descritpion
Tortoise SVN is a simple extension for TortoiseSVN binding.

[https://tortoisesvn.net/](https://tortoisesvn.net/)

TortoiseSVN is only available on Windows.
Therefore this extension will NOT WORK on linux and MacOS.

This extension provides commands for various Tortoise SVN actions (see list below) for the
current active file or a folder in the explorer by right-clicking on it.

## Available Commands

* vstortoise.svnLog : Open __log__ for the current active file
* vstortoise.svnDiff : Open __diff__ for the current active file
* vstortoise.svnRevert : Open __revert__ for the current active file
* vstortoise.svnBlame : Open __blame__ for the current active file
* vstortoise.svnCommit : Open __commit__ for the current active file
* vstortoise.svnUpdate : Open __update__ for the current active file

## Default Keybindings

* alt + shift + l : Log
* alt + shift + c : Commit
* alt + shift + d : Diff
* alt + shift + r : Revert
* alt + shift + u : Update

## Requirements

Tortoise-Proc.exe must be accessible. This can be done by putting TortoiseSVN/bin directory in your system or user %PATH% or
by specifying the directory in extension settings.

## Changelog

### 1.2.0
- Add configuration to set TortoiseSVN path
- minor refactoring
- minor bugfixes

### 1.1.0
- Change keybindings value du tu conflict with default keybindings

### 1.0.0

- Add context and explorer menu for all commands (works with insiders build !)
- Fix generated TortoiseSVN command

repository: florentulve/vstortoise

gha_language: TypeScript

repo_name: florentulve/vstortoise


text:
scale-ssh
=========

SSH Container to emulate many hosts for basic scale testing

Usage
-----

```bash
# build the container
./build-container.sh

# copy public key for access
cp ~/.ssh/id_rsa.pub authorized_keys

# start up containers (100 by default)
./run-containers.sh

# run tests
ansible-playbook -i inventory.ini your-magical-playbook.yaml

# cleanup containers
./stop-containers.sh
```

repository: mwhahaha/scale-ssh

repo_name: mwhahaha/scale-ssh


text:
---
title: TiDB Cloud Billing
summary: Learn about TiDB Cloud billing.
---

# TiDB Cloud Billing

You need to pay for the cluster nodes you use. In addition, the storage resources occupied by the backup data, and data transfers "in" and "out" of TiDB Cluster are charged separately.

## Node cost

TiDB Cloud lets you pay for your database by the hour, which is ideal for development, testing, and other short-lived workloads. TiDB cloud offers multiple cluster tiers that are equipped with fixed TiDB and TiKV instances. The unit prices of TiDB and TiKV nodes vary in different tiers, and the unit price of TiDB differs from that of TiKV nodes in the same tier.

The pricing formula is as follows:

Cluster tier price per hour = TiDB unit price per hour × TiDB node number + TiKV unit price per hour × TiKV node number

For TiDB / TiKV unit price in different cloud service providers, and different regional node price, refer to <https://pingcap.com/products/tidbcloud>.

## Backup storage cost

TiDB Cloud provides automatic backup and ad-hoc backup, both backups consume the storage. We will charge you based on the maximum capacity of total backups per month.

The storage prices for different cloud providers are as follows:

- AWS

    All backups will be saved in Amazon Simple Storage Service (Amazon S3). You only need to pay the S3 fee and we will not charge you an additional fee. For details, see [Amazon S3 pricing](https://aws.amazon.com/s3/pricing/).

- GCP

    All backups will be saved in GCP cloud storage. You only need to pay the Cloud Storage fee and we will not charge you an additional fee. For details, see [GCP Cloud Storage pricing](https://cloud.google.com/storage/pricing).

## Data Transfer cost

Data transfer costs depend on the cloud service provider where you deployed the cluster.

- AWS

    TiDB Cloud charges for data transfer between the TiDB cluster load balancer and your server, and the fixed cost of the load balancer. We will charge this fee according to the exact AWS bill, without additional fees. For details, see [AWS Network Load Balancer pricing](https://aws.amazon.com/elasticloadbalancing/pricing/?nc1=h_ls).

- GCP

    TiDB Cloud charges for data transfer between the TiDB cluster load balancer and your server, and the fixed cost of the load balancer. We will charge this fee according to the exact GCP bill, without additional fees.

## Invoices

At the beginning of each month, we will send you the invoice for the previous month’s usage, and deduct the fees from your remaining credits.

The invoice cost includes the node cost, backup storage cost, and data transfer cost of all clusters under your current organization.

Invoice amount = Node cost + Backup storage cost + Data transfer cost - remaining credit

- If the amount of the invoice is greater than credits, we will deduct your credits first, and then deduct the remaining amount from your credit card.
- If the amount of the invoice is less than credits, we will only deduct your credits.

> **Note:**
>
> All billing deductions will be completed through the third-party platform Stripe.

You can view the current usage of this month in the billing console, but only for reference. The final invoice amount still needs to be finalized through the monthly invoice determined in the next month.

To view the invoices list, click **Billing** in the top menu bar. The billing console displays, and the **Invoices** tab displays by default.

## Credits

TiDB Cloud credits can be used to pay monthly bills. If your credits are not used up, they will be used in the next month automatically, until the credits are used up.

> **Note:**
>
> - In the billing deduction, one dollar credit is equivalent to one dollar.
> - Credits can only be used for clusters within the organization. It cannot be transferred to other organizations and cannot be exchanged.

To apply for TiDB Cloud credits, contact the sales for you.

To view your credit details, perform the following steps:

1. Click **Billing** in the top menu bar. The billing console displays.
2. Click the **Credits** tab.

## Payment method setting

Before creating a cluster, or in the billing console, you can bind a valid credit card. We will deduct the fee from the bound credit card according to your cluster usage.

When binding your credit card, you must provide the cardholder's name, email, phone, country/region, card number, valid year and month, and CVC (Card Verification Code).

To add a credit card, perform the following steps:

1. Click **Billing** in the top menu bar. The billing console displays.

2. Click the **Payment Method** tab.

3. Click **Add Credit Card**. The **Add a Card** dialog window displays.

4. Enter the cardholder's name, email, phone, country/region, card number, valid year and month, and CVC (Card Verification Code).

5. Click **Submit**.

> **Note:**
>
> To ensure the security of credit card sensitive data, TiDB Cloud does not save any customer credit card information and save them in the third-party payment platform Stripe. All billing deductions are completed through Stripe.

You can bind multiple credit cards, and set one of them as the default credit card in the payment method of the billing console. After setting, subsequent billings will be automatically deducted from the default credit card.

To set the default credit card:

1. Click **Billing** in the top menu bar. The billing console displays.
2. Click the **Payment Method** tab.
3. Select a credit card in the credit card list, and click **Set as default**.

repository: handlerww/dbaas-docs

repo_name: handlerww/dbaas-docs


text:
---
layout: post
title: "ChefConf 2012 in Summary"
date: 2012-06-03 21:07
comments: true
categories:
---
This is a little late coming but figured I should post anyways. [ChefConf 2012](http://chefconf.opscode.com/)
was an amazing event and absolutely surprising considering it's the first
conference [Opscode](http://www.opscode.com/) has put on. Here are a few things that I noticed:

## Culture

The attitude and culture around the people there was incredible. Everyone was
focused on the needs of the business that they worked for. Sometimes it meant
making developers more productive by being to provide consistent environments
or by lessening the pain operations have to go through in order to release
software created by development teams.

It inspired me to see so many people in the business to help others. There was
not a lot of ego, but there was definitely a sense of pride in the work that
many of the people did there.

## Demand

I was hoping to find some excited chefs out there that would love to work for
[ThoughtWorks](http://join.thoughtworks.com/) but it seemed everyone was doing the same. Attempts to recruit me
occurred as I was trying to recruit them! This is definitely a hot part of the
software industry.

 Pretty hard to recruit people that are quite comfortable with their
positions and projects.

## Orchestration

Configuration management of a single node seems to nearly be a solved issue.
A running theme amongst many of the sessions was that orchesration. There were
many discussions but it didn't sound like it's been solved in a uniform way.
Maybe orchestration is something that has to be done custom depending on your
environment. While listening to the conversations it appeared that many
had different requirements for how they do the orchestration. I've written
plenty of orchestration code and was relieved that I wasn't the only person
that found it hard to do. This subject will my "next level" in understanding
infrastructure automation processes.

## Sessions of Note

### Transformation to Continuous Delivery at Ancestry

Since I have a lot Windows background, I was really interested in the
two talks given by the folks from [Ancestry.com](http://www.ancestry.com/). The first one was a high level
summary of Ancenstry's path to Continuous Delivery. *John Esser* articulated the
principles well and was pleasantly surprised to see him promote [ThoughtWorks Studios' product Go](http://www.thoughtworks-studios.com/go-agile-release-management).

The main takeaway I got from the talk that the transformation seemed to be
more of a culture shift, rather than a technical one.

{% youtube J6g10f83yVE %}

### DevOps + Chef + Windows at Ancestry.com

Next was a more technical discussion by *Dan Gilmer* which reminded me of all
the lessons I've learned in the Windows automation world. I had an excellent
chat with him and shared war stories that were all to familiar to him. I also
got a kick out of his pride in working for days without ever having to
Remote Desktop into a machine.

This is a problem domain that seems to be repeatably solved. Hopefully some
OSS will come out of this. I would like to dive deeper into how they are
driving out infrastructure using data_bags rather than roles.

{% youtube pF5ya0q53kk %}

### Opscode Chef State of the Union

*Adam Jacobs* keynote was a good reminder that Chef is about providing us with
infrastructure primitives. As much as we like to standardize, the real world
isn't ever going to reach a global convergence. Every site is different and
they decided they didn't want to be the dictators on how you setup your
infrastructure. I think this is great because it allows Chef users to define
the opinionated stacks that they require. It's a good separation of concerns
in my opinion and a concept that I will try to pull into future projects.

{% youtube bAWjqE5FCxI %}

### Test-Driven Development for Chef Practitioners

*Jim Hopp* from [Lookout](https://www.mylookout.com/) had an awesome slide deck (hand drawn with paper and
crayola markers) that discussed Test Driven Development of cookbooks. I look
forward to trying out the concepts he discussed in my next project. For
developers the concepts might seem pretty standard but the ideas are very
new for operations minded folk.

{% youtube o2e0aZUAVGw %}

### CycleCloud + Chef = 50,000-core Utility Supercomputer for Science

Lastly, [CycleCloud's](http://cyclecomputing.com/) *Jason Stowe* impressed everyone by discussing how they were
able to spin up $20 million dollars worth of infrastructure using AWS and only
paid $5k/hr for 3 hours use. Not only did the massive infrastructure speed
things up for them, it actually produced better results when performing protein
analysis. It begs the question of what other things are we missing because we
are yet to through large enough computing systems at them.

{% youtube cEaQB6e7G0Q %}

## Summary

The couple days were inspiring by I had to keep my energy in check because
I learned that certain things are not necessary for small projects with just
a handful of servers. I've been using chef-solo for all my machines because
the size of the environments I'm dealing with can easily be tracked in simpler
ways. I do look forward to the day when a chef server is necessary to deal
with all the infrastructure. That's where metrics like 1 engineer per 1000
machines is possible.

branch_name: refs/heads/source

extension: markdown


text:
---
# Display name
title: Zhaoyang Wang

# Is this the primary user of the site?
superuser: true

# Role/position/tagline
role: Undergraduate Student of ShanDong University

# Organizations/Affiliations to show in About widget
organizations:
- name: ShanDong University
  url: https://www.sdu.edu.cn/

# Short bio (displayed in user profile at end of posts)
bio: My technology interests include backend development, Web Developing and all kinds of technology of computer and Internet.

# Interests to show in About widget
interests:
- Coding
- Focus on details
- sing

# Education to show in About widget
education:
  courses:
  - course: bachelor in Computer Science and Technology
    institution: ShanDong University
    year: 2018-present

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/page-builder/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "/#contact" for contact widget.
social:
- icon: envelope
  icon_pack: fas
  link<EMAIL_ADDRESS>- icon: github
  icon_pack: fab
  link: 'https://github.com/superzhaoyang'
- icon: weibo
  icon_pack: fab
  link: 'https://weibo.com/p/1005056667626436/home?from=page_100505&mod=TAB&is_all=1#place'

# Link to a PDF of your resume/CV.
# To use: copy your resume to `static/media/resume.pdf`, enable `ai` icons in `params.toml`,
# and uncomment the lines below.
# - icon: cv
#   icon_pack: ai
#   link: media/resume.pdf

# Enter email to display Gravatar (if Gravatar enabled in Config)
email<EMAIL_ADDRESS>
# Highlight the author in author lists? (true/false)
highlight_name: false
---
I am an undergraduate student in ShanDong Univesity. I hava a great passion for web development, backend development and all kinds of technologh of computer and Internet. I am now working on National College Student Software Innovation Competition and Looking for an internship.

{{< icon name="download" pack="fas" >}} Download my {{< staticref "media/resume.pdf" "newtab" >}}resume{{< /staticref >}}.


text:
---
layout: post
title: "Code Highlighting Examples"
tagline: "for personal reference"
description: ""
category: programming
tags: [code highlighting, syntax highlighting]
---
{% include JB/setup %}

I decided to try to set up code highlighting for this blog using the inbuilt functionality and the monokai theme borrowed from [this repository](https://github.com/richleland/pygments-css).

#### PHP

{% highlight php %}
<?php
$animals = array( 'cat', 'dog', 'mouse' );
foreach( $animals as $animal )
{
     echo "Look, a {$animal}!";
}
?>
{% endhighlight %}

#### HTML

{% highlight html %}
<!doctype html>
<html lang="en">
<head>
     <meta charset="UTF-8">
     <title></title>
</head>
<body>
</body>
</html>
{% endhighlight %}

#### Javascript

{% highlight javascript %}
function redirect( url )
{
     document.location = url;
}
{% endhighlight %}

#### Python

{% highlight python %}
#!/usr/bin/env python
for i in range( 100 ):
     print i
{% endhighlight %}

Works like a charm, just be sure to include

{% highlight html %}
<link href="{{ BASE_PATH }}/stylesheets/stylesheet_of_choice.css" rel="stylesheet">
{% endhighlight %}

in your default.html, and GitHub pages will do the rest.


text:
# s3copy
A lambda function to copy objects from n to m S3 Buckets
 where n, m >= 1

## Deployment
- Download the deployment file from
https://github.com/maknahar/s3copy/releases
- Upload the deployment file to lambda
- Set the configuration

or

- Checkout the latest release code
`go get github.com/maknahar/copys3`
- Build and generate the deployment file
`GOOS=linux go build -o main main.go && zip deployment.zip main`
- Upload the deployment file to lambda
- Set the configuration

**Handler function name:** `main`

## Config
This Lambda Function expect the list of source and
destination buckets in a JSON file.

### Config File Format

Config File is a map of input s3 bucket and detail to copy
changes to destination.

The function can take events from an SQS as well if
source bucket put all event to an SQS.

The function can take events from an SQS where SQS is
subscribed to an SNS and source bucket publish a message
to an SNS on every change.

To Support SQS processing add SQS URL `sqs` and
SQS region `sqsRegion` in the config file. Otherwise,
Leave them empty `""` or remove the keys.

```
{
  "source-bucket": {
    "region": "us-east-1",
    "sqs": "URL of SQS where all S3 change events are stored",
    "sqsRegion": "us-east-1",
    "destinations": [
      "destination-bucket-1",
      "destination-bucket-2"
    ]
  },
  "another-source-bucket": {
    "region": "us-east-1",
    "sqs": "SQS URL",
    "sqsRegion": "us-east-1",
    "destinations": [
      "destination-bucket-1",
      "destination-bucket-3"
    ]
  }
}
```

With above configuration, any object put in `source-bucket`
will be copied to `destination-bucket-1` & `destination-bucket-2`
and any object put in `another-source-bucket` will be
copied to `destination-bucket-1` & `destination-bucket-3`.

### Env Var
This Lambda function can be configured in two ways.
- Either give a public url of config file via CONFIG_FILE
- or provide base64 encoded value of configuration via
CONFIG. You can online tools like www.base64encode.org
to encode config content.

If both are provided CONFIG_FILE value will take precedence.

- CONFIG_FILE : URL of configuration file

- CONFIG : Base64 Encoded string of content of CONFIG_FILE

## NOTE:
Make sure Lambda function have required access to source
and destination bucket.

## Contribution
All contributions are welcome. Either via PR or Issue.


text:
# Never - Functional Programming Language
[![Build Status](https://travis-ci.org/never-lang/never.svg?branch=master)](https://travis-ci.org/never-lang/never)
[![Version](https://img.shields.io/github/release/never-lang/never.svg)](https://github.com/never-lang/never/releases)
[![Codecov](https://codecov.io/gh/never-lang/never/branch/master/graph/badge.svg)](https://codecov.io/gh/never-lang/never)

[Never](https://never-lang.readthedocs.io/en/latest/) is a simple functional
programming language. Technically it may be classified as syntactically scoped,
strongly typed, call by value, functional programming language.

In practise Never offers basic data types, assignment, control flow, arrays,
first order functions and some mathematical functions to make it useful
to calculate expressions. Also it demonstrates how functions can be compiled,
invoked and passed as parameters or results between other functions.

## Getting Started
It is easy to download and compile Never language. Just clone repository
and make the compiler in a few basic steps. To read more visit
[readthedocs.io](https://never-lang.readthedocs.io/en/latest/) site.

### Prerequisites

Never requires basic Linux installation to be built. The following tools and
libraries are needed:
* gcc
* glibc
* bison / flex
* libmath, libdl and libffi

### Installing

Never can be installed in steps:
* clone repository
* ```cd never```
* ```mkdir build; cd build```
* ```cmake ..; make```

## Contributing
All help is welcome! Using it, reporting bugs, spreading the word, writing
code samples, blogs, submitting ideas, documentation, new features. Everyone
is invited to contribute.

## License
This project is licensed under the MIT License.

repository: never-lang/never-docs

repo_name: never-lang/never-docs


text:
# Towhee Developers' Guidance

## **Coding Style**
Towhee's coding style is based on PEP8 and PEP257.

### **Maximum Line Length**
- The limit for docstring is 88 characters for each line.
- The limit for code and comment is 150 characters for each line.

### **Indentation and Split**
Use 4 whitespaces per indentation level.
```python
def foo(
	arg_1,
	arg_2,
	arg_3,
	arg_4,
	...
):
	...

bar = (
    part_1
    + part_2
    + (part_3 - part4)
    - part_5
    - part_6
)
```
*Notes*:
- Add a level of indent to clearly distinguish hanging indents.
- Split before the first arguemnt in hanging indents.
- Start a new line for the closing parenthesis, brackets, braces.
- Dedent the closing parenthesis, brackets, braces.
- Split a long line before operators and after commas.

### **Blank Lines**
- Leave two blank lines between:
	- top-level functions and classes.
- Leave One blank line between
	- functions defined inside classes.
	- logical sections inside a function.
- Leave one blank line at the end of a python file
```python
class Foo():
    def foo_1():
        ...

    def foo_2():
        ...

def foo():
    # This is the first logical part.
    ...

    # This is the second logical part.
    ...

def bar():
    ...

```

### **Imports**
Place Imports at the top of the file, right after module comments and docstrings, before globals and constants.
```python
import std_lib_A
import std_lib_B

import third_party_lib_A
import third_party_lib_B

from std_lib_C import object_a, object_b
from std_lib_D import (
    object_c,
	object_d,
	object_e,
	object_f,
    object_g,
	object_h,
	object_i,
	object_j
)
```
*Notes*:
- Organize the imports in following order:
	1. Standard library imports
	2. Related third party imports
	3. Local application/library specific imports
- Import one library in per line.
- It's ok to import several objects from one library in one line, but when the number of objects is more the 7, use hanging indents.
- Leave one blank line between different groups.
- Use absolute imports, avoid wildcard imports:
```python
# It's best to use absolute imports.
import some_module.some_object
from some_module import some_object

# Avoid explicit relative imports if possible.
from . import sibling_module
from .sibling_module import sibling_obejct

# Avoid using wildcard imports.
from some_module import *
```

### **Whitespace**
#### **Avoid unnecessary whitespace in the following cases:**
- Immediately after or before parentheses, brackets or braces:
```python
# Correct:
example(list[1], {key: 2})
dct['key'] = lst[index]

# Wrong:
example ( list[ 1 ], { key: 2 } )
dct [ 'key' ] = lst [ index ]
```
- Between a trailing comma and a following close parenthesis:
```python
# Correct:
foo = (0,)

# Wrong:
bar = (0, )
```
- Immediately before a comma, semicolon, or colon, but leave a space after them unless followed by parentheses, brackets or braces:
```python
# Correct:
if x == 4:
    print x, y; x, y = y, x

# Wrong:
if x == 4 :
    print x , y ;x , y = y , x
```
- The end of a line.

#### **Do use whitespace in following cases:**
- Surround following operators with a single space on either side:
	- assignment (=),
	- augmented assignment (+=, -=, etc.)
	- comparisons (==, <, >, !=, <>, <=, >=, in, not in, is, is not)
	- booleans (and, or, not).
- Surround operators with lowest priority with a single space on either side:
```python
# Correct:
i = i + 1

i += 1

x = x*2 - 1

hypot2 = x*x + y*y

c = (a+b) * (a-b)

if a and b:
    ...

if a == b:
    ...

for i in range(10):
    ...
```
- Function annotations, after : and surround -> :
```python
# Correct:
def foo(bar: str) -> int:
    ...
```

### **Annotation**
Add annotation for all functions.
```python
from Typing import Set, Dict, List, Tuple, Any

def foo(a: Set(str), b: List[int], c: Dict[str, Any]) -> Tuple(int, str):
    ...
    return return_int, return_str
```
*Notes*:
- Use Set, Dict, List, Tuple instead of set, dict, list, tuple in annotation, also specify the data type inside.

*Special case*:
- If we want to return a Foo object inside of the Foo class, use string to annotate the return type:
```python
Class Foo():
	...

    @classmethod
    def initializera(args) -> 'Foo':
        ...
        return Foo_instance
```

### **Comments and Docstring**
#### **Comments**
- All comments and docstrings should be composed of sentences, not phrases:
```python
# Correct:
# My code does this.

# Wrong:
# my code does this
```
- Use block comments rather than inline comments. Block comments should apply to some (or all) code that follows them, and are supposed to indented to the same level as the code they are applied.
```python
# Correct:
# The Following code does this.
...

#Worng:
... # The code does this
```
**Docstring**
- Write dostring for every function and class according to the following template, unless the function or the class is:
	- Externally invisible
	- Very short
	- Obvious

Template：
```python
"""
Brief introduction within one line.

Detailed description, paragraph 1...

Detailed description, paragraph 2 ...

Args:
    arg0 (`int`):
        arg0 description.
    arg1 (`Union[float, str]`):
        arg1 description.

Returns:
    (`Tuple[bool, int]`)
        Return value description.

Raises:
    (`xxxError`)
        Raise xxxError when ....
"""
```
*Notes*:
- Start a new line for a brief introduction, do not add an introduction right after the opening """.
- Use `` (the symbol in the left of 1), not '' when declare the types.
- If needed, add some detailed description after the introduction separated by one blank line.
- If there is more than one paragraph in the detailed description, separate them with one blank line.
- If a function does not have Args, Returns or Raises, do not add them in the docstring.
- In Args, add a colon (':') after (\`type\`), leave whitespace before (\`type\`) .
- In Returns, Raises, only list the return type and error types, as (\`return/error type\`), no colon(':') needed.
- Put the docstrings for a class's `__init__` function at the beginning of the class definition:
```python
class Foo():
    """
    Introduction to the Foo class...

	Detailed description...

    Args:
        args_0 (`type`):
        ...
    """
    def __init__(args):
        ...
```

A detailed exmaple:
```python
def __init__(
    arg_1: int, arg_2: list, arg_3: dict,
    arg_4: float, arg_5: bool, arg_6: tuple
) -> Tuple[int, float, str]:
"""
A one line summary.

This is a complicated function so we need multi-line docstring, this function does something.

Functions that do not have return values, raise errors, or need examples can omit the sections below.

Args:
    arg_1 (`str`):
        ...
    arg_2 (`List[float]`):
        ...
    arg_3 (`Dict[int, str]`):
        ...
    ...

Returns:
    (`Tuple[int, float, str]`)
        A tuple with three values, first being int...

Raises:
    (`IOError`)
        Throw an IOError when...
"""
```

*Special case*：
- Return a Foo object inside Foo class:
```python
Class Foo():
    @classmethod
    def generate(args) -> 'Foo':
        """
        Short intro.

        Detailed Description.

        Args:
            ...

        Returns:
            (`path/to/Foo`)
                Returns a Foo instance.
        """
        return Foo_instance
```

### **Naming Conventions**
- Variable and function names should be lowercase and connected with underscore if necessary:
```python
foo = 1
def foo_bar() -> None:
	...
```
- Uppercase for Constants:
```python
MY_CONSTANT
```
- CapWords for class name:
```python
class MyClass(object):
	...
```
- Use one leading underscore only for non-public methods and instance variables:
```python
def _private_function() -> None:
	...
```

repository: NbnbZero/towhee

repo_name: NbnbZero/towhee


text:
---
name: 'Issue: Bug report' about: Create a report to help us improve ZeloEngine

---

#### Describe the bug

A clear and concise description of what the bug is. A screenshot or copy of the error could be helpful as well.

Make sure your bug can be reproduced with the ZeloEngine Engine and not by your own engine that you're creating
alongside with ZeloEngine. For issues with your own engine, we're happy to help you
in [TheCherno Discord server](https://thecherno.com/discord). Thanks for your understanding.

#### To Reproduce

Steps to reproduce the behavior:

1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error above

#### Expected behavior

A clear and concise description of what you expected to happen.

#### Screenshots

If applicable, add extra screenshots to help explain your problem.

#### Operating system: (please complete the following information)

- OS: [e.g. win-64]
- Version: [e.g. Windows 10 home]

#### Additional context

Add any other context about the problem here.

repository: zoloypzuo/ZeloEngine

repo_name: zoloypzuo/ZeloEngine


text:
## Azure-Information-Protection-PowerShell-Samples Changelog

# 0.0.1 (2018-10-23)

*Features*
* Authentication folder added:: Two sample snippets for connecting to EXO and SCC;
* EXO and SCC Folders added: Initial EXO and SCC (O365 DLP) samples uploaded; and
* Quick Win Examples folder added: Initial sample on combining snippets for something easy and actionable.

*Bug Fixes*
* Not Applicable

*Breaking Changes*
* Not Applicable

gha_language: PowerShell


text:
[![Python package](https://github.com/dm-bell-networking/net_define/actions/workflows/python-package.yml/badge.svg)](https://github.com/dm-bell-networking/net_define/actions/workflows/python-package.yml)
# net_define
A declarative framework for building CLI-based network configurations

## About
Netdefine attempts to address pain points found when moving from hand-crafted CLI files to CLI templates and abstracted variable data.

Using Netdefine, engineers can build device templates from a self-service repository of shared components.
These components are referenced by Features, which contain the required data for each template. Each device template then becomes a list of Features that describes the configuration of the device.

Netdefine tracks the state of each file in your configuration repository by computing a hash of the file bytes, when a file is changed, `netdefine plan` can be ran to track which devices require updates due to a change in an underlying feature or component.

## Directory Structure
This is an example of a basic directory structure for a Netdefine project.

The components directory stores all resubale CLI templates as J2 files.
The Features directory contains the features written per-device, each feature references a component and provides the required data to produce the template.

The templates directory contains template files which link features together to produce a device configuration.

```
├── components
│   ├── example-cisco_ios_baseline.j2
│   ├── example-cisco_ios_bgp.j2
│   ├── example-cisco_ios_l3_interfaces.j2
│   ├── example-cisco_ios_ospf.j2
│   └── example-cisco_ios_static_routes.j2
├── configs
│   └── first_change-config-example-cisco_ios_router_1.yml.txt
├── features
│   ├── example_router_1_baseline.yml
│   ├── example_router_1_bgp.yml
│   ├── example_router_1_interfaces.yml
│   ├── example_router_1_ospf.yml
│   └── example_router_1_static_routes.yml
├── state.json
└── templates
    └── example-cisco_ios_router_1.yml
```
By default Netdefine will create a state.json file in your project root directory and output configutation files to the configs directory.

## Using Netdefine
This package is in its very early stages and is not pushed to PyPi, to install netdefine, clone this repository and run the setup file after creating a virtual environment.

`python netdefine/src/setup.py develop`

From there, you will have access to the netdefine command. Change into the examples/globomantics directory and run `netdefine plan`

Netdefine will then create a state file to track the project folder.
```
(venv) daltonbell@Daltons-MacBook-Pro globomantics % netdefine plan
State file not found, building state...
state built successfully
The state has not changed since the last apply
```

to generate configurations, use the apply command and specify a change
```
(venv) daltonbell@Daltons-MacBook-Pro globomantics % netdefine apply first_change
apply success for change first_change
```

to validate a change without updating state (check j2 and yaml syntax and references) use the dry_run flag
```commandline
(venv) daltonbell@Daltons-MacBook-Pro globomantics % netdefine apply first_change --dry_run
apply success for change first_change

```

to view the templates produced by change in the console, utilize the --display flag
```commandline
(venv) daltonbell@Daltons-MacBook-Pro globomantics % netdefine apply first_change \
> --dry_run \
> --display
apply success for change first_change

Template:
 example-cisco_ios_router_1.yml

Config:

hostname example-router-1
ip domain-name globomantics.net
ip name-server <IP_ADDRESS>
ip ssh version 2
username cisco secret cisco
line vty 0 15
 login local
banner motd ^
******************************************
       THIS IS A TEST CONFIGURATION
******************************************
!
router ospf 100
  passive-interface loop0
!
router bgp 65000
 neighbor <IP_ADDRESS> remote-as 65000
 network <IP_ADDRESS> mask <IP_ADDRESS>
!
ip route <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS>
!
interface loop0
 ip address <IP_ADDRESS> <IP_ADDRESS>
 ip ospf 100 area 0
 no shutdown
!
interface G0
 ip address <IP_ADDRESS> <IP_ADDRESS>
 ip ospf 100 area 0
 no shutdown
!
interface G1
 ip address <IP_ADDRESS> <IP_ADDRESS>
 ip ospf 100 area 0
 no shutdown
!
```

To target a specific template utilize the --target flag
```commandline
(venv) daltonbell@Daltons-MacBook-Pro globomantics % netdefine apply first_change \
--dry_run \
--display \
--target=example-cisco_ios_router_1.yml
apply success for change first_change

Template:
 example-cisco_ios_router_1.yml

Config:

hostname example-router-1
ip domain-name globomantics.net
ip name-server <IP_ADDRESS>
ip ssh version 2
username cisco secret cisco
line vty 0 15
 login local
banner motd ^
******************************************
       THIS IS A TEST CONFIGURATION
******************************************
!
router ospf 100
  passive-interface loop0
!
router bgp 65000
 neighbor <IP_ADDRESS> remote-as 65000
 network <IP_ADDRESS> mask <IP_ADDRESS>
!
ip route <IP_ADDRESS> <IP_ADDRESS> <IP_ADDRESS>
!
interface loop0
 ip address <IP_ADDRESS> <IP_ADDRESS>
 ip ospf 100 area 0
 no shutdown
!
interface G0
 ip address <IP_ADDRESS> <IP_ADDRESS>
 ip ospf 100 area 0
 no shutdown
!
interface G1
 ip address <IP_ADDRESS> <IP_ADDRESS>
 ip ospf 100 area 0
 no shutdown
!
```

## Contributing to Netdefine

Install dev requirements using `pip install - requirements.dev.txt`

Run the test suite with `pytest`

```commandline
(venv) daltonbell@Daltons-MacBook-Pro net_define % pytest
====================================================================== test session starts ======================================================================
platform darwin -- Python 3.9.5, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
rootdir: /Users/daltonbell/github-repos/net_define
plugins: cov-2.12.1
collected 12 items

netdefine/tests/test_config_template.py .                                                                                [  8%]
netdefine/tests/test_netdefine.py ...........                                                                                [100%]

====================================================================== 12 passed in 0.22s =======================================================================
(venv) daltonbell@Daltons-MacBook-Pro net_define %

```


text:
---
name: 2. Feature Request
about: Suggest an idea for a new function in c:geo directly to our GitHub tracker
title: ''
labels: Feature Request, Unverified
assignees: ''
---
<!-- Fill in the following form by adding your text below the explanation comments. -->
<!-- You can use the preview tab above to review your issue before submitting it. -->

## What function are you missing
<!-- A clear and detailed description of the function you are missing. -->
<!-- Examples: There is no possibility to [...], I'm always frustrated when [...], It would be easier to use if [...] -->

## Suggested solution
<!-- Describe your sugggested solution and the way it should be implemented. -->
<!-- Examples: There should be a new menu item xyz in menu abc, which performs [...], Change the existing function to include [...] -->

## Alternatives/workarounds
<!-- Describe alternative solutions and/or workarounds you have considered already or are already available. -->

## Additional context
<!-- (optional, remove if not applicable) Add any other context, screenshots, sketches, process flows, links and other references related to your feature request here (if applicable). -->

gha_language: Java


text:
# Messaging systems

<!-- Re-generate TOC with `markdown-toc --no-first-h1 -i` -->

<!-- toc -->

- [Definitions](#definitions)
  * [Destinations](#destinations)
  * [Message consumption](#message-consumption)
  * [Conversations](#conversations)
  * [Temporary destinations](#temporary-destinations)
- [Conventions](#conventions)
  * [Span name](#span-name)
  * [Span kind](#span-kind)
  * [Operation names](#operation-names)
- [Messaging attributes](#messaging-attributes)
  * [Attributes specific to certain messaging systems](#attributes-specific-to-certain-messaging-systems)
    + [RabbitMQ](#rabbitmq)
- [Examples](#examples)
  * [Topic with multiple consumers](#topic-with-multiple-consumers)
  * [Batch receiving](#batch-receiving)
  * [Batch processing](#batch-processing)

<!-- tocstop -->

## Definitions

Although messaging systems are not as standardized as, e.g., HTTP, it is assumed that the following definitions are applicable to most of them that have similar concepts at all (names borrowed mostly from JMS):

A *message* usually consists of headers (or properties, or meta information) and an optional body. It is sent by a single message *producer* to:

* Physically: some message *broker* (which can be e.g., a single server, or a cluster, or a local process reached via IPC). The broker handles the actual routing, delivery, re-delivery, persistence, etc. In some messaging systems the broker may be identical or co-located with (some) message consumers.
* Logically: some particular message *destination*.

### Destinations

A destination is usually identified by some name unique within the messaging system instance, which might look like an URL or a simple one-word identifier.
Two kinds of destinations are distinguished: *topic*s and *queue*s.
A message that is sent (the send-operation is often called "*publish*" in this context) to a *topic* is broadcasted to all *subscribers* of the topic.
A message submitted to a queue is processed by a message *consumer* (usually exactly once although some message systems support a more performant at-least-once mode for messages with [idempotent][] processing).

[idempotent]: https://en.wikipedia.org/wiki/Idempotence

### Message consumption

The consumption of a message can happen in multiple steps.
First, the lower-level receiving of a message at a consumer, and then the logical processing of the message.
Often, the waiting for a message is not particularly interesting and hidden away in a framework that only invokes some handler function to process a message once one is received
(in the same way that the listening on a TCP port for an incoming HTTP message is not particularly interesting).
However, in a synchronous conversation, the wait time for a message is important.

### Conversations

In some messaging systems, a message can receive a reply message that answers a particular other message that was sent earlier. All messages that are grouped together by such a reply-relationship are called a *conversation*.
The grouping usually happens through some sort of "In-Reply-To:" meta information or an explicit *conversation ID* (sometimes called *correlation ID*).
Sometimes a conversation can span multiple message destinations (e.g. initiated via a topic, continued on a temporary one-to-one queue).

### Temporary destinations

Some messaging systems support the concept of *temporary destination* (often only temporary queues) that are established just for a particular set of communication partners (often one to one) or conversation.
Often such destinations are unnamed or have an auto-generated name.

## Conventions

Given these definitions, the remainder of this section describes the semantic conventions that shall be followed for Spans describing interactions with messaging systems.

### Span name

The span name SHOULD be set to the message destination name and the operation being performed in the following format:

```
<destination name> <operation name>
```

The destination name SHOULD only be used for the span name if it is known to be of low cardinality (cf. [general span name guidelines](../api.md#span)).
This can be assumed if it is statically derived from application code or configuration.
If the destination name is dynamic, such as a [conversation ID](#conversations) or a value obtained from a `Reply-To` header, it SHOULD NOT be used for the span name.
In these cases, an artificial destination name that best expresses the destination, or a generic, static fallback like `"(temporary)"` for [temporary destinations](#temporary-destinations) SHOULD be used instead.

The values allowed for `<operation name>` are defined in the section [Operation names](#operation-names) below.
If the format above is used, the operation name MUST match the `messaging.operation` attribute defined for message consumer spans below.

Examples:

* `shop.orders send`
* `shop.orders receive`
* `shop.orders process`
* `print_jobs send`
* `topic with spaces process`
* `AuthenticationRequest-Conversations process`
* `(temporary) send` (`(temporary)` being a stable identifier for randomly generated, temporary destination names)

### Span kind

A producer of a message should set the span kind to `PRODUCER` unless it synchronously waits for a response: then it should use `CLIENT`.
The processor of the message should set the kind to `CONSUMER`, unless it always sends back a reply that is directed to the producer of the message
(as opposed to e.g., a queue on which the producer happens to listen): then it should use `SERVER`.

### Operation names

The following operations related to messages are defined for these semantic conventions:

| Operation name | Description |
| -------------- | ----------- |
| `send`         | A message is sent to a destination by a message producer/client.       |
| `receive`      | A message is received from a destination by a message consumer/server. |
| `process`      | A message that was previously received from a destination is processed by a message consumer/server. |

## Messaging attributes

| Attribute name |                          Notes and examples                            | Required? |
| -------------- | ---------------------------------------------------------------------- | --------- |
| `messaging.system` | A string identifying the messaging system such as `kafka`, `rabbitmq` or `activemq`. | Yes |
| `messaging.destination` | The message destination name, e.g. `MyQueue` or `MyTopic`. This might be equal to the span name but is required nevertheless. | Yes |
| `messaging.destination_kind` | The kind of message destination: Either `queue` or `topic`. | Yes, if either of them applies. |
| `messaging.temp_destination` | A boolean that is `true` if the message destination is [temporary](#temporary-destinations). | If temporary (assumed to be `false` if missing). |
| `messaging.protocol` | The name of the transport protocol such as `AMQP` or `MQTT`. | No |
| `messaging.protocol_version` | The version of the transport protocol such as `0.9.1`. | No |
| `messaging.url` | Connection string such as `tibjmsnaming://localhost:7222` or `https://queue.amazonaws.com/80398EXAMPLE/MyQueue`. | No |
| `messaging.message_id` | A value used by the messaging system as an identifier for the message, represented as a string. | No |
| `messaging.conversation_id` | The [conversation ID](#conversations) identifying the conversation to which the message belongs, represented as a string. Sometimes called "Correlation ID". | No |
| `messaging.message_payload_size_bytes` | The (uncompressed) size of the message payload in bytes. Also use this attribute if it is unknown whether the compressed or uncompressed payload size is reported. | No |
| `messaging.message_payload_compressed_size_bytes` | The compressed size of the message payload in bytes. | No |

Additionally at least one of `net.peer.name` or `net.peer.ip` from the [network attributes][] is required and `net.peer.port` is recommended.
Furthermore, it is strongly recommended to add the [`net.transport`][] attribute and follow its guidelines, especially for in-process queueing systems (like [Hangfire][], for example).
These attributes should be set to the broker to which the message is sent/from which it is received.

[network attributes]: span-general.md#general-network-connection-attributes
[`net.transport`]: span-general.md#nettransport-attribute
[Hangfire]: https://www.hangfire.io/

For message consumers, the following additional attributes may be set:

| Attribute name |                          Notes and examples                            | Required? |
| -------------- | ---------------------------------------------------------------------- | --------- |
| `messaging.operation` | A string identifying the kind of message consumption as defined in the [Operation names](#operation-names) section above. Only `"receive"` and `"process"` are used for this attribute. If the operation is `"send"`, this attribute MUST NOT be set, since the operation can be inferred from the span kind in that case. | No |

The _receive_ span is be used to track the time used for receiving the message(s), whereas the _process_ span(s) track the time for processing the message(s).
Note that one or multiple Spans with `messaging.operation` = `process` may often be the children of a Span with `messaging.operation` = `receive`.
The distinction between receiving and processing of messages is not always of particular interest or sometimes hidden away in a framework (see the [Message consumption](#message-consumption) section above) and therefore the attribute can be left out.
For batch receiving and processing (see the [Batch receiving](#batch-receiving) and [Batch processing](#batch-processing) examples below) in particular, the attribute SHOULD be set.
Even though in that case one might think that the processing span's kind should be `INTERNAL`, that kind MUST NOT be used.
Instead span kind should be set to either `CONSUMER` or `SERVER` according to the rules defined above.

### Attributes specific to certain messaging systems

#### RabbitMQ

In RabbitMQ, the destination is defined by an _exchange_ and a _routing key_.
`messaging.destination` MUST be set to the name of the exchange. This will be an empty string if the default exchange is used.
The routing key MUST be provided to the attribute `messaging.rabbitmq.routing_key`, unless it is empty.

## Examples

### Topic with multiple consumers

Given is a process P, that publishes a message to a topic T on messaging system MS, and two processes CA and CB, which both receive the message and process it.

```
Process P:  | Span Prod1 |
--
Process CA:              | Span CA1 |
--
Process CB:                 | Span CB1 |
```

| Field or Attribute | Span Prod1 | Span CA1 | Span CB1 |
|-|-|-|-|
| Span name | `"T send"` | `"T process"` | `"T process"` |
| Parent |  | Span Prod1 | Span Prod1 |
| Links |  |  |  |
| SpanKind | `PRODUCER` | `CONSUMER` | `CONSUMER` |
| Status | `Ok` | `Ok` | `Ok` |
| `net.peer.name` | `"ms"` | `"ms"` | `"ms"` |
| `net.peer.port` | `1234` | `1234` | `1234` |
| `messaging.system` | `"kafka"` | `"kafka"` | `"kafka"` |
| `messaging.destination` | `"T"` | `"T"` | `"T"` |
| `messaging.destination_kind` | `"topic"` | `"topic"` | `"topic"` |
| `messaging.operation` |  | `"process"` | `"process"` |
| `messaging.message_id` | `"a1"` | `"a1"`| `"a1"` |

### Batch receiving

Given is a process P, that sends two messages to a queue Q on messaging system MS, and a process C, which receives both of them in one batch (Span Recv1) and processes each message separately (Spans Proc1 and Proc2).

Since a span can only have one parent and the propagated trace and span IDs are not known when the receiving span is started, the receiving span will have no parent and the processing spans are correlated with the producing spans using links.

```
Process P: | Span Prod1 | Span Prod2 |
--
Process C:                      | Span Recv1 |
                                        | Span Proc1 |
                                               | Span Proc2 |
```

| Field or Attribute | Span Prod1 | Span Prod2 | Span Recv1 | Span Proc1 | Span Proc2 |
|-|-|-|-|-|-|
| Span name | `"Q send"` | `"Q send"` | `"Q receive"` | `"Q process"` | `"Q process"` |
| Parent |  |  |  | Span Recv1 | Span Recv1 |
| Links |  |  |  | Span Prod1 | Span Prod2 |
| SpanKind | `PRODUCER` | `PRODUCER` | `CONSUMER` | `CONSUMER` | `CONSUMER` |
| Status | `Ok` | `Ok` | `Ok` | `Ok` | `Ok` |
| `net.peer.name` | `"ms"` | `"ms"` | `"ms"` | `"ms"` | `"ms"` |
| `net.peer.port` | `1234` | `1234` | `1234` | `1234` | `1234` |
| `messaging.system` | `"kafka"` | `"kafka"` | `"kafka"` | `"kafka"` | `"kafka"` |
| `messaging.destination` | `"Q"` | `"Q"` | `"Q"` | `"Q"` | `"Q"` |
| `messaging.destination_kind` | `"queue"` | `"queue"` | `"queue"` | `"queue"` | `"queue"` |
| `messaging.operation` |  |  | `"receive"` | `"process"` | `"process"` |
| `messaging.message_id` | `"a1"` | `"a2"` | | `"a1"` | `"a2"` |

### Batch processing

Given is a process P, that sends two messages to a queue Q on messaging system MS, and a process C, which receives both of them separately (Span Recv1 and Recv2) and processes both messages in one batch (Span Proc1).

Since each span can only have one parent, C3 should not choose a random parent out of C1 and C2, but rather rely on the implicitly selected parent as defined by the [tracing API spec](../api.md).
Similarly, only one value can be set as `message_id`, so C3 cannot report both `a1` and `a2` and therefore attribute is left out.
Depending on the implementation, the producing spans might still be available in the meta data of the messages and should be added to C3 as links.
The client library or application could also add the receiver span's span context to the data structure it returns for each message. In this case, C3 could also add links to the receiver spans C1 and C2.

The status of the batch processing span is selected by the application. Depending on the semantics of the operation. A span status `Ok` could, for example, be set only if all messages or if just at least one were properly processed.

```
Process P: | Span Prod1 | Span Prod2 |
--
Process C:                              | Span Recv1 | Span Recv2 |
                                                                   | Span Proc1 |
```

| Field or Attribute | Span Prod1 | Span Prod2 | Span Recv1 | Span Recv2 | Span Proc1 |
|-|-|-|-|-|-|
| Span name | `"Q send"` | `"Q send"` | `"Q receive"` | `"Q receive"` | `"Q process"` |
| Parent |  |  | Span Prod1 | Span Prod2 |  |
| Links |  |  |  |  | Span Prod1 + Prod2 |
| SpanKind | `PRODUCER` | `PRODUCER` | `CONSUMER` | `CONSUMER` | `CONSUMER` |
| Status | `Ok` | `Ok` | `Ok` | `Ok` | `Ok` |
| `net.peer.name` | `"ms"` | `"ms"` | `"ms"` | `"ms"` | `"ms"` |
| `net.peer.port` | `1234` | `1234` | `1234` | `1234` | `1234` |
| `messaging.system` | `"kafka"` | `"kafka"` | `"kafka"` | `"kafka"` | `"kafka"` |
| `messaging.destination` | `"Q"` | `"Q"` | `"Q"` | `"Q"` | `"Q"` |
| `messaging.destination_kind` | `"queue"` | `"queue"` | `"queue"` | `"queue"` | `"queue"` |
| `messaging.operation` |  |  | `"receive"` | `"receive"` | `"process"` |
| `messaging.message_id` | `"a1"` | `"a2"` | `"a1"` | `"a2"` | |


text:
#Isilon

Scale-Out NAS is my fame.

---

## Overview
The Isilon driver registers a storage driver named `isilon` with the `REX-Ray`
driver manager and is used to connect and manage Isilon NAS storage.

## Configuration
The following is an example configuration of the Isilon driver.

```yaml
isilon:
  endpoint: https://endpoint:8080
  insecure: true
  username: username
  password: password
  volumePath: /rexray
  nfsHost: nfsHost
```

For information on the equivalent environment variable and CLI flag names
please see the section on how non top-level configuration properties are
[transformed](./config/#all-other-properties).

## Extra Paramters
The following items are configurable specific to this driver.

 - `volumePath` represents the location under `/ifs/volumes` to allow volumes to be created and removed.
 - `nfsHost` is the configurable host used when mounting exports

## Activating the Driver
To activate the Isilon driver please follow the instructions for
[activating storage drivers](/user-guide/config#activating-storage-drivers),
using `isilon` as the driver name.

## Examples
Below is a full `rexray.yml` file that works with Isilon.

```yaml
rexray:
  storageDrivers:
  - isilon
isilon:
  endpoint: https://endpoint:8080
  insecure: true
  username: username
  password: password
  volumePath: /rexray
  nfsHost: nfsHost
```

## Instructions
It is expected that the `volumePath` exists already within the Isilon system.  This would reflect a directory create under `/ifs/volumes/rexray`.  It is not necessary to export this volume.

## Caveats

- This driver currently ignores the `--size` and `--volumeType` flags.
- This driver does not support pre-emption currently.  Requests from alternate hosts can have bad results.

repository: clintkitson/rexray

repo_name: clintkitson/rexray


text:
---
name: Report a bug
about: Create a report to help us improve
labels: bug

---

<!--

This form is for bug reports and feature requests ONLY!
For general questions and troubleshooting, please ask/look for answers here:
- Documentation: https://docs.microsoft.com/aspnet/core/grpc
- Troubleshooting: https://docs.microsoft.com/aspnet/core/grpc/troubleshoot
- StackOverflow, with "grpc" tag: https://stackoverflow.com/questions/tagged/grpc

Issues specific to Grpc.Core (C-core server and client), or code generation with Grpc.Tools should be created at https://github.com/grpc/grpc/issues/new
-->

### What version of gRPC and what language are you using?

### What operating system (Linux, Windows,...) and version?

### What runtime / compiler are you using (e.g. .NET Core SDK version `dotnet --info`)

### What did you do?
If possible, provide a recipe for reproducing the error. Try being specific and include code snippets if helpful.

### What did you expect to see?

### What did you see instead?

Make sure you include information that can help us debug (full error message, exception listing, stack trace, logs).

See [TROUBLESHOOTING.md](https://github.com/grpc/grpc-dotnet/blob/master/TROUBLESHOOTING.md) for how to diagnose problems better.

### Anything else we should know about your project / environment?

repository: grpc/grpc-dotnet

gha_language: C#

repo_name: grpc/grpc-dotnet