text:
# monitoring-stack

Monitoring stack containing ELK + Grafana + Prometheus (with multiple exporters) and authentication through a reverse proxy (Caddy)

## Overview

This repository is inteended to assist implementing a set of tools for Log Consolidation and monitoring.

This monitoring stack is composed by the following tools:

- [Elastic stack (formerly known as ELK):](https://www.elastic.co/webinars/introduction-elk-stack) Consists of Elasticsearch, Logstash, Kibana and Beats. Although they've all been built to work exceptionally well together, each one is a separate project that is driven by the open-source vendor Elastic -- which itself began as an enterprise search platform vendor.

  - [Elasticsearch:](https://www.elastic.co/products/elasticsearch) is a search engine based on Lucene. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents. Elasticsearch is developed in Java and is released as open source under the terms of the Apache License.

  - [Logstash:](https://www.elastic.co/products/logstash) Is an open source tool for collecting, parsing, and storing logs for future use. Kibana 3 is a web interface that can be used to search and view the logs that Logstash has indexed. Both of these tools are based on Elasticsearch. Elasticsearch, Logstash, and Kibana, when used together is known as an ELK stack.

  - [Kibana:](https://www.elastic.co/products/kibana) Is an open source data visualization plugin for Elasticsearch. It provides visualization capabilities on top of the content indexed on an Elasticsearch cluster. Users can create bar, line and scatter plots, or pie charts and maps on top of large volumes of data.

  - [Beats](https://www.elastic.co/products/beats): Is a lightweight agent from Elastic, which is great for gathering data. They sit on your servers and centralize data in Elasticsearch. Idea is that we use it to increase the the processing muscle, Beats can also ship to Logstash for transformation and parsing.

- [Prometheus](https://github.com/prometheus): Prometheus, a Cloud Native Computing Foundation project, is a systems and service monitoring system. It collects metrics from configured targets at given intervals, evaluates rule expressions, displays the results, and can trigger alerts if some condition is observed to be true.

- [Node_Exporter:](https://github.com/prometheus/node_exporter) Prometheus exporter for hardware and OS metrics exposed by \*NIX kernels, written in Go with pluggable metric collectors.

- [Elasticsearch_Exporter:](https://github.com/justwatchcom/elasticsearch_exporter) Prometheus exporter for various metrics about ElasticSearch, written in Go.

- [CAdvisor:](https://github.com/google/cadvisor) (Container Advisor) provides container users an understanding of the resource usage and performance characteristics of their running containers. It is a running daemon that collects, aggregates, processes, and exports information about running containers. Specifically, for each container it keeps resource isolation parameters, historical resource usage, histograms of complete historical resource usage and network statistics. This data is exported by container and machine-wide.

- [Grafana:](https://github.com/grafana/grafana) is an open source metric analytics & visualization suite. It is most commonly used for visualizing time series data for infrastructure and application analytics but many use it in other domains including industrial sensors, home automation, weather, and process control.

- [Caddy:](https://github.com/stefanprodan/caddy-builder) Caddy is the HTTP/2 web server with automatic HTTPS, including additional plugins to make it act in a similar way as an Ingress/Proxy.

## Requirements

- [Docker](https://docs.docker.com/engine/installation/)
- [Docker Compose](https://docs.docker.com/compose/install/)

## Architecture

The following is a visual representation of how the different tools will be integrated together:

![diagram](docs/architecture_diagram.png)

## Deployment steps on Docker Swarm Cluster

**1.** After installing `docker` and `docker-compose`, as described in the requirements session, initialize the swarm, as shown right below:

```shell
docker swarm init
```

A similar output should be displayed if the command was successfull:

```shell
Swarm initialized: current node (a8pml3unconooa7t7qnsw7knp) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-5jk292hj9b12by0byz4xfnntq07nd58ozrqxxyjx91kx03oqhw-8pl8cm17pj1lam8lq10gmuih0 <IP_ADDRESS>:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
```

**2.** Clone this repository to the target machine where the monitoring stack will be deployed:

```shell
git clone git@github.com:fsilveir/monitoring-stack.git
```

**3.** From the repository base directory, go into the `docker` directory and execute the following command on your target machine:

```shell
cd monitoring-stack/docker
docker stack deploy monitoring --compose-file docker-compose.yml
```

A similar output should be displayed if the applications were successfully deployed:

```shell
docker stack deploy monitoring --compose-file docker-compose.yml
Creating network monitoring_net
Creating service monitoring_pushgateway
Creating service monitoring_prometheus
Creating service monitoring_kibana
Creating service monitoring_elasticsearch_exporter
Creating service monitoring_caddy
Creating service monitoring_cadvisor
Creating service monitoring_elasticsearch
Creating service monitoring_logstash
Creating service monitoring_nodeexporter
Creating service monitoring_grafana
Creating service monitoring_filebeat
Creating service monitoring_alertmanager
```

You can also confirm if all the required services were successfully started by executing `docker ps`, as shown below:

```shell
$ docker ps
CONTAINER ID        IMAGE                                                 COMMAND                  CREATED              STATUS                    PORTS                NAMES
186f2cb28c7e        prom/alertmanager:v0.19.0                             "/bin/alertmanager -…"   7 seconds ago        Up 4 seconds              9093/tcp             monitoring_alertmanager.1.ktll54qa0ttk9ljr1bpba6f04
cedda4dd3185        docker.elastic.co/beats/filebeat:7.3.2                "/usr/local/bin/dock…"   11 seconds ago       Up 8 seconds                                   monitoring_filebeat.1.apc6mygodsypsdvyb84zfcgpa
3910e960856a        grafana/grafana:6.3.5                                 "/setup.sh"              18 seconds ago       Up 14 seconds             3000/tcp             monitoring_grafana.1.lslqeve2o95djzx24ji3ltqjy
755c577b9f9a        prom/node-exporter:v0.18.1                            "/bin/node_exporter …"   22 seconds ago       Up 18 seconds             9100/tcp             monitoring_nodeexporter.1.tet69f5xrdantjc5omuqfyy6s
5fdb167dcae0        docker.elastic.co/logstash/logstash:7.3.2             "/usr/local/bin/dock…"   26 seconds ago       Up 22 seconds             5044/tcp, 9600/tcp   monitoring_logstash.1.ou571n1now2c9go6o21gkpbt2
945f02693a24        docker.elastic.co/elasticsearch/elasticsearch:7.3.2   "/usr/local/bin/dock…"   33 seconds ago       Up 31 seconds             9200/tcp, 9300/tcp   monitoring_elasticsearch.1.fa1a2dn9wt6027qfzqpfavsn5
8be996662db6        google/cadvisor:v0.33.0                               "/usr/bin/cadvisor -…"   40 seconds ago       Up 38 seconds (healthy)   8080/tcp             monitoring_cadvisor.1.65i1noof89ca1wzcq4dynet11
3d7b098d445d        stefanprodan/caddy:latest                             "/sbin/tini -- caddy…"   46 seconds ago       Up 42 seconds                                  monitoring_caddy.1.yje4slt3myl0w1btlofyf69hg
d05e14053300        justwatch/elasticsearch_exporter:1.1.0                "/bin/elasticsearch_…"   51 seconds ago       Up 49 seconds             9114/tcp             monitoring_elasticsearch_exporter.1.ph0aea6j5dxtmuwg2fy105jh9
ba7a199a8a86        docker.elastic.co/kibana/kibana:7.3.2                 "/usr/local/bin/dumb…"   57 seconds ago       Up 55 seconds             5601/tcp             monitoring_kibana.1.sd0kawrjy12btkrr1yge97m0t
41773e80e777        prom/prometheus:v2.12.0                               "/bin/prometheus --c…"   About a minute ago   Up About a minute         9090/tcp             monitoring_prometheus.1.gpmeg1bgp3dywsmbp23pndil3
d79840c54b78        prom/pushgateway:v0.9.1                               "/bin/pushgateway"       About a minute ago   Up About a minute         9091/tcp             monitoring_pushgateway.1.7rzking41qjisqcglh52qeo04
```

## Accessing the Tools

**Caddy** will work as a reverse proxy and provide basic authentication for accessing the different UI's. The default password is defined during the deployment, default values can be found inside the `docker-compose` fle -- we strongly recommend changing the default passwords before deploying the stack.

To access the different UI's click at the following URL's:

| Tool         | URL                   |
| ------------ | --------------------- |
| Grafana      | http://localhost:3000 |
| Prometheus   | http://localhost:9090 |
| Alertmanager | http://localhost:9093 |
| Pushgateway  | http://localhost:9091 |
| Kibana       | http://localhost:5601 |

## Testing Data Injection to Logstash

After confirming that the monitoring stack is running, you can inject some log entries for testing purposes. The shipped Logstash configuration allows you to send content via TCP, as shown in the example below:

```shell
$ nc localhost 5000 < /path/to/logfile.log
```

You should be able to confirm through Kibana that the entry you've injected is shown as a new document.

## Common Issues

### Logstash / Filebeat index pattern not displayed in Kibana

By default, the index pattern should be automatically detected the first time you access the Kibana dashboard, however if that does not happen, you can manually create the index patterns with the following `curl` command from within the Kibana container.

#### Manually creating Logstash index pattern on Kibana

```shell
curl -v -XPOST -D- 'http://kibana:5601/api/saved_objects/index-pattern' \
    -H 'Content-Type: application/json' \
    -H 'kbn-version: 7.3.2' \
    -d '{"attributes":{"title":"logstash-*","timeFieldName":"@timestamp"}}'
```

#### Manually creating Filebeat index pattern on Kibana

```shell
curl -v -XPOST -D- 'http://kibana:5601/api/saved_objects/index-pattern' \
    -H 'Content-Type: application/json' \
    -H 'kbn-version: 7.3.2' \
    -d '{"attributes":{"title":"filebeat-*","timeFieldName":"@timestamp"}}'
```

**4.** To fully stop the monitoring stack, execute the following command on your target machine:

```shell
docker stack rm monitoring
```

A similar output should be displayed if all the applications was successfully removed:

```shell
Removing service monitoring_alertmanager
Removing service monitoring_caddy
Removing service monitoring_cadvisor
Removing service monitoring_elasticsearch
Removing service monitoring_elasticsearch_exporter
Removing service monitoring_filebeat
Removing service monitoring_grafana
Removing service monitoring_kibana
Removing service monitoring_logstash
Removing service monitoring_nodeexporter
Removing service monitoring_prometheus
Removing service monitoring_pushgateway
Removing network monitoring_net
```

You can confirm if all the required services were successfully removed by executing `docker ps`, a similar output should be displayed:

```shell
docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
```

## Get support

Create an [issue](https://github.com/fsilveir/docker-monitoring-stack/issues) if you want to report a problem or ask for a new functionality any feedback is highly appreciated!

repository: elpensadorluis/monitoring-stack

repo_name: elpensadorluis/monitoring-stack


text:
### Lambda8

Lambda8 is a Fantasy computer that uses Lisp as its system language.

It's implemented in C using SDL 2.0.

A demo "game" is included.

This software is alpha state. In particular, loading files from disk is mostly a developing stage functionality.

### The machine
The screen has a resolution of 256x128, with 4 bits of depth, rendered at 768x384 (3x). Colours are chosen from a 16-colour palette.

These are the available primitives in Lisp:

- (pix x y c)

  Renders a pixel at coordinates x,y in color c

- (define-sprite filename)

  Loads a sprite into memory from a file on disk. Returns a number which identifies the texture.

- (spr id x y w h)

  Renders the sprite identified by id at coordinates x,y with a size of w,h

- (line x y x2 y2 c)

  Draws a line from x,y to x2,y2 using color c

- (rect x y x2 y2 c)

  Draws a filled rectangle from x,y to x2,y2 using color c

- (rectb x y x2 y2 c)

  Draws a rectangle from x,y to x2,y2 using color c

- (circ x y r c)

  Draws a filled circle centered on x,y with radius r using color c

- (circb x y r c)

  Draws a circle centered on x,y with radius r using color c

- (cls n)

  Clears the screen using color n

- (define-sfx filename)

  Loads a sound effect into memory from a file on disk. Returns a number which identifies the sfx.

- (sfx id)

  Plays the sound effect identified by id.

- (printxy text x y c)

  Prints the text at x,y in color c

## Core library
Lambda8 packs a core library with the following functions (defined in Lisp):

- (btn n)

  Returns #t if button n is pressed

- (btnp n)

  Returns #t if button n is pressed but wasn't pressed the previous
  frame (prevents repetition)

- (filter p ls)

  Returns a new list with the elements that satisfy predicate p, in
  the same order

- (collideAABB a b)

  Returns #t if the bounding boxes of sprites a and b are overlapping

- (make-sprite filename-or-id x y w h)

  Creates a new sprite object. It can either load a new texture from a
  file, or use the ID of an already loaded texture.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# README.md

Convert this to a Mind Map

* Getting Started
* Interacting with the DOM
  - String interpolation
  - Accessing Date in the Vue Instance
  - Attribute Biding
  - Event Biding
    - Plus keyboard events syntax sugar

  - Two Way Biding
  - Computed Properties
  - Styling with styles/classes
    - Using objects
    - Using names
    - Array syntax
  - Shorthand syntax ('@' and ':')
  - Conditionals v-if, v-else, v-else-if
  - Hide with v-show
  - Loop with v-for
    - index for loop
    - loop through numbers
* The Vue Instance
* Vue CLI
  - Creating projects
  - Project structure
  - Project features
  - Vue files
  - Building for production
  - Debugging
* Components
  - Introduction
  - Data is a function
  - Registering
    - Locally
    - Globally
  - Creating
  - Using

repository: hbobenicio/vue-examples

repo_name: hbobenicio/vue-examples


text:
# Santander

https://www.kaggle.com/c/santander-customer-transaction-prediction

# Prepare enviroment

1. Install latest TF, TFX

To get a pretty clean enviroment, please use virtualenv

```
virtualenv -p python3 ~/envtfx
source ~/envtfx/bin/activate
pip install tensorflow
pip install tfx
pip install tensorflow-model-analysis
pip install kaggle
pip install keras-tuner
```

2. Download data

```
mkdir -p /var/tmp/santander/data/train
mkdir -p /var/tmp/santander/data/test
cd /var/tmp/santander/data
kaggle competitions download -c santander-customer-transaction-prediction
unzip santander-customer-transaction-prediction.zip
rm santander-customer-transaction-prediction.zip
mv train.csv train/
mv test.csv test/
cd <this_folder>
```

3. Create pusher folder

Pusher can't create folder for you.

```
mkdir -p /var/tmp/santander/pusher
```

# Estimator-based

```
cd estimator
python tfxbeam.py
```

# Keras without TFT

```
cd keras
python tfxbream.py
```

# Keras with TFT

## Run locally via Beam local runner

```
cd keras-tft
python tfxbeam.py --runner local
```

## Run in Kubeflow Pipelines

Install KFP & Skaffold
```
pip install kfp

# Install Skaffold
# https://skaffold.dev/docs/install/
```

```
cd keras-tft
tfx pipeline create --engine kubeflow \
    --build_target_image gcr.io/renming-mlpipeline/santander-custom \
    --pipeline_path tfxbeam.py \
    --endpoint 1c4774e7d442cc4c-dot-us-central2.pipelines.googleusercontent.com
```

It may takes a while in the phase of using skaffold to compile container image.
It will compile and upgrade to KFP.


text:
# DNS Configuration

If we are going to add new organizations dynamically their IP addresses have to be provided for all existing containers
in the blockchain network.

In order to pass the information about IPs we can use a internal DNS service (serving only for the blockchain network being deployed)
and configure Docker to use this internal DNS.

There are two options for configuring DNS service:
- Using host system DNS service
- Using DNS-in-docker solution (TBD)

## Using system DNS service (Dnsmasq).

[Dnsmasq](https://en.wikipedia.org/wiki/Dnsmasq) is famous Linux DNS forwarder used by default in many Linux distributions.
But in Ubuntu 18.04 the other name resolver is used by default `systemd-resolved`.

`Systemd-resolved` doesn't allow Docker to use the host's DNS. So the solution is to install `Dnsmasq` along with the default resolver
and use `Dnsmasq` only for the blockchain network domain.

## Install Dnsmasq

For Ubuntu:
```bash
sudo apt install dnsmasq
```

After installing  it tries to start `dnsmasq`.

In Ubuntu 18.04 `dnsmasq` fails to start because of conflict on port 53 (dns-resolve port):

```
nov 14 19:16:06 ubuntubcs systemd[1]: Starting dnsmasq - A lightweight DHCP and caching DNS server...
nov 14 19:16:06 ubuntubcs dnsmasq[16226]: dnsmasq: syntax check OK.
nov 14 19:16:06 ubuntubcs dnsmasq[16235]: dnsmasq: failed to create listening socket for port 53: Адрес уже используется
nov 14 19:16:06 ubuntubcs systemd[1]: dnsmasq.service: Control process exited, code=exited status=2
nov 14 19:16:06 ubuntubcs dnsmasq[16235]: failed to create listening socket for port 53: Address already in use
nov 14 19:16:06 ubuntubcs systemd[1]: dnsmasq.service: Failed with result 'exit-code'.
nov 14 19:16:06 ubuntubcs dnsmasq[16235]: FAILED to start up
nov 14 19:16:06 ubuntubcs systemd[1]: Failed to start dnsmasq - A lightweight DHCP and caching DNS server.
Processing triggers for systemd (237-3ubuntu10.6) ...
Processing triggers for ureadahead (0.100.0-20) ...
```

To fix this edit the `dnsmasq` configuration and activate bind-interfaces parameter:

sudo nano /etc/dnsmasq.conf

Uncomment line with option *bind-interfaces*:
```
...
# On systems which support it, dnsmasq binds the wildcard address,
# even when it is listening on only some interfaces. It then discards
# requests that it shouldn't reply to. This has the advantage of
# working even when interfaces come and go and change address. If you
# want dnsmasq to really bind only the interfaces it is listening on,
# uncomment this option. About the only time you may need this is when
# running another nameserver on the same machine.
bind-interfaces
...
```

and restart `dnsmasq`:
```
sudo systemctl restart dnsmasq.service
```

Now it starts without errors.

## Configure Docker to use host's dnsmasq service:
Create file /etc/docker/daemon.json and add **dns** configuration:

Find out the gateway address used in docker sub-network:
```
ip addr | grep docker0
```

*Result*:
  **docker0**: <BROADCAST,MULTICAST,UP,LOWER_UP>
  ...
    inet **`<IP_ADDRESS>`**/16

The address should be added to the following configuration files:

```
sudo nano /etc/docker/daemon.json
```

Add configuration (use the address reported above):

```
{
    "dns": ["<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>"]
}
```

After starting blockchain network docker can create extra bridge networks:

**br-4d38cc4d0184**: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
    link/ether 02:42:66:1d:95:b5 brd ff:ff:ff:ff:ff:ff
    inet **`<IP_ADDRESS>`**/16 brd <IP_ADDRESS> scope global br-4d38cc4d0184
       valid_lft forever preferred_lft forever

They all should be added to the docker configuration file:
```
{
    "dns": ["<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>", "<IP_ADDRESS>"]
}
```

Then restart Docker engine and restart containers if networ had already been started:
```
sudo service docker restart

docker start $(docker ps -aq)
```

## Configure dnsmasq to accept requests from docker sub-network

By default `dnsmasq` accepts dns-requests only from localhost (<IP_ADDRESS>) clients.
To allow it accepting requests from docker containers adjust `docker-bridge.conf` file:

```
sudo mkdir -p /etc/NetworkManager/dnsmasq.d
sudo nano /etc/NetworkManager/dnsmasq.d/docker-bridge.conf
```

Add the same addresses found out in previous section:

```
listen-address=<IP_ADDRESS>
listen-address=<IP_ADDRESS>
```

Restart network manager:
```
sudo service dnsmasq restart
```

## Configure host addresses of other organizations

Adjust /etc/hosts file on the host.
```
sudo nano /etc/hosts
```

Add:
```
<IP_ADDRESS> orderer.example.com www.example.com

<IP_ADDRESS> peer0.org1.example.com peer1.org1.example.com www.org1.example.com
```

The IP addresses of the host names will be immediately resolvable in containers:
```
docker run --rm hyperledger/fabric-tools bash -c "wget peer0.org1.example.com"
```

--2018-11-14 16:47:40--  `http://peer0.org1.example.com/`
Resolving peer0.org1.example.com (peer0.org1.example.com)... `<IP_ADDRESS>`

# Deploying network along with DNS service

If you use DNS service (not Swarm) then nodes must be started exposing
Fabric related ports in order to make them accessible through external network (Internet):

Orderer:
```bash
docker-compose -f docker-compose-orderer.yaml -f docker-compose-orderer-ports.yaml up
```

Nodes:
```bash
docker-compose -f docker-compose.yaml -f docker-compose-ports.yaml up
```

# Configuration with master DNS server

A central or master DNS server can be configured for a particular blockchain network.
This allows all organizations to avoid reconfiguration of their `/etc/hosts` file individually and use the central server DNS configuration automatically.

To configure organizations' (child) DNS services (after performing the previous configuration steps) adjust the `/etc/dnsmasq.conf` and specify the DNS server address:

```
server=x.x.x.x
```

The master server DNS server doesn't need an additional configuring except of the steps described in the previous sections.
Now IP addresses of newly added organizations have to be specified only in master's `/etc/hosts` file. Restart of `dnsmasq` is required after that.

repository: olegabu/fabric-starter

branch_name: refs/heads/stable

gha_language: Shell

repo_name: olegabu/fabric-starter


text:
---
sidebar_position: 3
---

import { PropTable } from '@site/src/components/PropTable';

# Props

## StarPicker

`react-star-picker` accepts the following props:

<PropTable name="StarPicker" />

The `starRenderer` prop is an optional prop for a custom star renderer. It can be used to further customize the content of each star button.

## StarRenderer

The `StarPicker` component renders a button (`StarPickerButton`) for each star, or half star, element. It is the `starRenderer` function that then renders the content inside these individual `StarPickerButton`s. It gets called with the following parameters:

```jsx static
{
  /** the zero based index of the star being rendered */
  index: number;
  /** index of the star matching the current rating  */
  selectedIndex: number;
  /** index of the star currently hovered on */
  hoverIndex: number | null;
}
```

:::note

`starRenderer` is an optional prop useful for changing the rendered star icon. For simply changing the styles of the default star, see [this section on styling](styling).

:::

<!-- <PropTable name="defaultStarRenderer" /> -->

repository: mmkari/react-star-picker

gha_language: TypeScript

gha_license_id: MIT

repo_name: mmkari/react-star-picker


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## [2.0.4](https://github.com/netlify/netlify-cms/tree/master/packages/netlify-cms-core/compare/netlify-cms-core<EMAIL_ADDRESS>(2018-07-28)

**Note:** Version bump only for package netlify-cms-core

## [2.0.3](https://github.com/netlify/netlify-cms/compare/netlify-cms-core<EMAIL_ADDRESS>(2018-07-27)

### Bug Fixes

* log accurate version by distribution ([#1531](https://github.com/netlify/netlify-cms/issues/1531)) ([95a76ad](https://github.com/netlify/netlify-cms/commit/95a76ad))

## 2.0.2 (2018-07-27)

### Bug Fixes

* bug fixes from linters ([#1524](https://github.com/netlify/netlify-cms/issues/1524)) ([6632e5d](https://github.com/netlify/netlify-cms/commit/6632e5d))
* fix version console log ([#1528](https://github.com/netlify/netlify-cms/issues/1528)) ([e82289b](https://github.com/netlify/netlify-cms/commit/e82289b))

## 2.0.1 (2018-07-26)

# 2.0.0 (2018-07-26)

**Note:** Version bump only for package netlify-cms-core

repository: ascorbic/netlify-cms

repo_name: ascorbic/netlify-cms


text:
---
layout: post
title: "OsNLA2"
description: ""
category: genes
tags:
---

* **Information**
    + Symbol: OsNLA2
    + MSU: [LOC_Os03g44810](http://rice.uga.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os03g44810)
    + RAPdb: [Os03g0650900](https://rapdb.dna.affrc.go.jp/locus/?name=Os03g0650900)

* **Publication**
    + [OsNLA1, a RING-type ubiquitin ligase, maintains phosphate homeostasis in Oryza sativa via degradation of phosphate transporters.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsNLA1, a RING-type ubiquitin ligase, maintains phosphate homeostasis in Oryza sativa via degradation of phosphate transporters.%5BTitle%5D), 2017, Plant J.

* **Genbank accession number**

* **Key message**

* **Connection**
    + __OsNLA1__, __OsNLA2__, [Characterization of the rice NLA family reveals a key role for OsNLA1 in phosphate homeostasis.](http://www.ncbi.nlm.nih.gov/pubmed?term=Characterization of the rice NLA family reveals a key role for OsNLA1 in phosphate homeostasis.%5BTitle%5D), ) were identified by bioinformatics and phylogenetic analysis and designated OsNLA1 and OsNLA2
    + __OsNLA1__, __OsNLA2__, [Characterization of the rice NLA family reveals a key role for OsNLA1 in phosphate homeostasis.](http://www.ncbi.nlm.nih.gov/pubmed?term=Characterization of the rice NLA family reveals a key role for OsNLA1 in phosphate homeostasis.%5BTitle%5D),  The OsNLA1 clustered with Arabidopsis AtNLA1, was expressed higher than OsNLA2 and was transcriptionally repressed under Pi-deficient condition

[//]: # * **Key figures**


text:
---
layout: default_docs
title: Data Sources and JNDI
header: Chapter 11. Connection Pools and Data Sources
resource: media
previoustitle: Tomcat setup
previous: tomcat.html
nexttitle: Chapter 12. Further Reading
next: reading.html
---

All the `ConnectionPoolDataSource` and `DataSource` implementations can be stored
in JNDI. In the case of the nonpooling implementations, a new instance will be
created every time the object is retrieved from JNDI, with the same settings as
the instance that was stored. For the pooling implementations, the same instance
will be retrieved as long as it is available (e.g., not a different JVM retrieving
the pool from JNDI), or a new instance with the same settings created otherwise.

In the application server environment, typically the application server's
`DataSource` instance will be stored in JNDI, instead of the PostgreSQL™
`ConnectionPoolDataSource` implementation.

In an application environment, the application may store the `DataSource` in JNDI
so that it doesn't have to make a reference to the `DataSource` available to all
application components that may need to use it. An example of this is shown in
[Example 11.2, “`DataSource` JNDI Code Example”](jndi.html#ds-jndi).

**Example 11.2. `DataSource` JNDI Code Example**

Application code to initialize a pooling `DataSource` and add it to JNDI might
look like this:

`PGPoolingDataSource source = new PGPoolingDataSource();`
`source.setDataSourceName("A Data Source");`
`source.setServerName("localhost");`
`source.setDatabaseName("test");`
`source.setUser("testuser");`
`source.setPassword("testpassword");`
`source.setMaxConnections(10);`
`new InitialContext().rebind("DataSource", source);`

Then code to use a connection from the pool might look like this:

Connection conn = null;
try
{
    DataSource source = (DataSource)new InitialContext().lookup("DataSource");
    conn = source.getConnection();
    // use connection
}
catch (SQLException e)
{
    // log error
}
catch (NamingException e)
{
    // DataSource wasn't found in JNDI
}
finally
{
    if (con != null)
    {
        try { conn.close(); } catch (SQLException e) {}
    }
}

repository: yugabyte/jdbc-yugabytedb

gha_language: Java

repo_name: yugabyte/jdbc-yugabytedb


text:
---
layout: post
title: "android 打包warnning "
modified:
categories: blog
excerpt:
tags: []
image:
  feature: so-simple-sample-image-7.jpg
  credit: WeGraphics
  creditlink: http://wegraphics.net/downloads/free-ultimate-blurred-background-pack/

date: 2014-08-08T15:39:55-04:00
modified: 2016-06-01T14:19:19-04:00
---

	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] Proguard returned with error code 1. See console
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] Note: there were 372 duplicate class definitions.
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] Warning: com.alipay.android.phone.mrpc.core.d: can't find referenced method 'org.apache.http.auth.AuthSchemeRegistry getAuthSchemes()' in class com.alipay.android.phone.mrpc.core.d
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] Warning: com.alipay.android.phone.mrpc.core.d: can't find referenced method 'org.apache.http.cookie.CookieSpecRegistry getCookieSpecs()' in class com.alipay.android.phone.mrpc.core.d
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] Warning: com.alipay.android.phone.mrpc.core.d: can't find referenced method 'org.apache.http.client.CredentialsProvider getCredentialsProvider()' in class com.alipay.android.phone.mrpc.core.d
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1]       You should check if you need to specify additional program jars.
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] Warning: there were 3 unresolved references to program class members.
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1]          Your input classes appear to be inconsistent.
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1]          You may need to recompile them and try again.
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1]          Alternatively, you may have to specify the option
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1]          '-dontskipnonpubliclibraryclassmembers'.
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] java.io.IOException: Please correct the above warnings first.
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] 	at proguard.Initializer.execute(Initializer.java:321)
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] 	at proguard.ProGuard.initialize(ProGuard.java:211)
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] 	at proguard.ProGuard.execute(ProGuard.java:86)
	[2017-04-17 13:44:44 - vivo_3.0.1_plug1] 	at proguard.ProGuard.main(ProGuard.java:492)

解决方法：
在proguard里面，设置：

	-ignorewarnings

Check out on the github [Fork me on github][Tomas' Yu] for more info on how to get the most out of Jekyll. That's all,thanks !

[Tomas' Yu]: https://github.com/TomasYu/blogs
[Tomas' Yu]: https://github.com/TomasYu/blogs

repository: TomasYu/blogs

path: /_posts/articles/android 打包warnning.md

filename: android 打包warnning.md

repo_name: TomasYu/blogs


text:
# Table of contents

* [Introduction](README.md)

## Developing ligatures

* [Setting up your development environment](developing-ligatures/setting-up-your-development-environment.md)
* [Designing your first ligature](developing-ligatures/designing-your-first-ligature.md)
* [Committing your Glyphs file](developing-ligatures/committing-your-glyphs-file.md)

repository: jolbax/operator-mono-lig

repo_name: jolbax/operator-mono-lig


text:
# JSonoff

Simple MQTT relay dashboard for CloudMQTT broker with one button. :)

  - Add username
  - Add password
  - Magic

[Go to dashboard](https://settenke.github.io/jsonoff/dashboard)

# How to work

It is simple:
  - Buy a [Sonoff Basic](https://www.banggood.com/DIY-Wi-Fi-Wireless-Switch-For-Smart-Home-With-ABS-Shell-p-1019971.html?p=B801051570862201505F&cur_warehouse=CN) or other ESP8266 based wifi relay
  - Register account on [CloudMQTT](https://www.cloudmqtt.com/)
  - Download [Espruino](http://www.espruino.com/) JavaScript interpreter
  - Write a code (Example: [Espruino MQTT relay firmware for Sonoff Basic](https://gist.github.com/settenke/f64bf077b18886c3a910026f7deaec67))
  - Build firmware and upload
  - Done

repository: settenke/jsonoff

repo_name: settenke/jsonoff


text:
---
layout: page
title: About me
subtitle: Resume
---

Mohd Nazar Mubeen<PHONE_NUMBER>
<EMAIL_ADDRESS>https://github.com/nazarmubeen
https://www.linkedin.com/in/mohdnazarmubeen/

CAREER OBJECTIVE
I would like to pursue my interest in Computer Science and to test and expand my knowledge in this field, to the best of my ability. The bliss of working in a team, with challenging problems and acute deadlines is an area I would certainly like to explore.

 Experience Summary:

•	5 + year of experience in building complex and challenging projects.
•	Exposure to Database designs, workflows, architectural /system designs and coding patterns.
•	Good experience in refactoring code, designing API, Java & J2ee frameworks, Data Structures and Algorithms.
•	Worked on various java frameworks, Adobe Analytics tool and Interwoven/ HP Team site (6.7.2 and 6.5).
•	Possess good communication, Client handling and Problem-solving skills.

 Professional Experience:

•	Worked as Java Developer in Tata Consultancy Services, Hyderabad from 03 Nov 2014– 17 Feb 2017.
•	Worked as Application Engineer in Oracle India Pvt. Ltd. Hyderabad from 27 Feb 2017- 31st Aug 2017.
•	Working as Specialist Application Developer in DBS Bank, Hyderabad from 03 Sep 2019.

 Educational Qualification:

•	B. Tech in Computer Science & Engineering from Integral University, Lucknow with 81.81%, 2014 batch.

Technical Skills:

•	Programming Languages: java, j2ee.
•	Scripting Languages: HTML, CSS, JAVASCRIPT, XML
•	CMS: Blogger, WordPress, Interwoven.
•	IDE: JDeveloper, Eclipse, NetBeans, IntelliJ
•	Databases: MySQL, Oracle, Microsoft SQL Server, MariaDB.
•	Environment: Windows, Linux
•	Servers: Apache Tomcat, IBM web sphere.
•	Frameworks: ADF, Hibernate, Struts, Spring, Spring boot, JPA.
•	Other Technologies: - Microservices, Swagger, ELK stack, Maria DB, Kafka, OpenShift, Docker, Jenkins, git, Junit

PROJECT SUMMARY

Company:     DBS Bank Singapore
Role:        Specialist Application Developer
Location:    Hyderabad

Project Name: Treasury API

•	The Scope of the project is to work closely with Product Owner and BA’s in implementing new features across the application in Agile Way to develop multiple Customer facing and internal APIs for doing day to day operation on Currency transactions. The Architecture is built in multiple microservices with Spring Boot framework. My Role involved designing and development of features from scratch to full-fledged working solution. The Role also expects to brainstorm new ideas and system design patterns from time to time using automation.

•	The experience was on refactoring code to reduce latency and increase performance for high load, designing and implementing new features, developing code for integrating with external systems using REST API, building new APIs and exposing them to external systems using swagger. Implementing Event driven architecture across the application using Kafka, multi-threading code and various caching techniques for fast processing and handling of complex scenarios. Also worked on complex mathematical operations to calculate business logics, created library for reporting services, scheduling APIs and Billing APIs.

Technologies and tools: Java 8, spring boot, MariaDB, REST, Kafka, elastic search, Kibana, OpenShift, spring cloud, Jenkins, Jira, maven, spring cloud, swagger , Docker.

Company:     Oracle India Pvt. Ltd.
Role:        Application Engineer
Location:    Hyderabad

Project Name: Oracle HCM Risk Cloud

•	The scope of the project is to design multiple new requirements, refactor old code, removal of dead code and redesign dependent code, Continuous improvement of performance across the application and applying technical expertise to increase speed of the day-to-day operations. It also includes designing of User interfaces, automation of repetitive tasks, applying techniques with latest framework and technology, Migration of legacy code to new technology, writing integration tests, unit tests and exposing new API, changing structure, design patterns etc.

Project Name: Security Console

•	The scope of the project is to redesign analytics with performance improvement for high availability environment across application, written all Code using ADF frameworks and involved in the project until its stability in the customer environment.

Project Name: JOB AUTOMATION

•	The scope of the project is to redesign various jobs, their respective Excel reports, and its format with performance improvement and time constraint metrics, written all Code using ADF/ESS frameworks and involved in the project until its stability in the customer environment.

Company:    Tata Consultancy Services
Client:     Western Union Financial Services (U.S)
Role:       Java Developer
Location:   Hyderabad

•	Studied requirement and did complete analysis of the project while designing multiple modules.
•	Implemented complete workflow development activities.
•	Removed existing bugs and improved application by identifying weak areas.
•	Build require set of projects, provided solutions to existing problems.
•	Implemented Database replication between two server instances.
•	Designed front-end pages using JSP and JavaScript.
•	Implemented multiple risk handling features across the application.


text:
# Change Log

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

## [0.2.4](https://github.com/knownasilya/ember-addon-viewer/compare/v0.2.3...v0.2.4) (2018-12-14)

### Bug Fixes

* use correct addon author name value ([189f065](https://github.com/knownasilya/ember-addon-viewer/commit/189f065))

## [0.2.3](https://github.com/knownasilya/ember-addon-viewer/compare/v0.2.2...v0.2.3) (2018-12-14)

### Bug Fixes

* **build:** filter out default addons before doing expensive fs and json parsing work ([bbb71b8](https://github.com/knownasilya/ember-addon-viewer/commit/bbb71b8))

## [0.2.2](https://github.com/knownasilya/ember-addon-viewer/compare/v0.2.1...v0.2.2) (2018-12-12)

## [0.2.1](https://github.com/knownasilya/ember-addon-viewer/compare/v0.2.0...v0.2.1) (2018-12-11)

### Bug Fixes

* try/catch the addon resolve code ([b4a9558](https://github.com/knownasilya/ember-addon-viewer/commit/b4a9558))

# 0.2.0 (2018-12-11)

### Bug Fixes

* add ember jquery to excluded ([176df67](https://github.com/knownasilya/ember-addon-viewer/commit/176df67))
* add example addon ([0aa521a](https://github.com/knownasilya/ember-addon-viewer/commit/0aa521a))
* add redirects for netlify ([4f84fff](https://github.com/knownasilya/ember-addon-viewer/commit/4f84fff))
* ignore self ([308cf8f](https://github.com/knownasilya/ember-addon-viewer/commit/308cf8f))
* keep bottom row at the bottom of card ([37cb32e](https://github.com/knownasilya/ember-addon-viewer/commit/37cb32e))
* responsive grid ([9760af9](https://github.com/knownasilya/ember-addon-viewer/commit/9760af9))
* sort addons and style container ([de5d915](https://github.com/knownasilya/ember-addon-viewer/commit/de5d915))
* viewer not being added when it should be ([6481dc6](https://github.com/knownasilya/ember-addon-viewer/commit/6481dc6))

### Features

* add search ([0e14169](https://github.com/knownasilya/ember-addon-viewer/commit/0e14169))
* get addons displaying in the app ([57ef66b](https://github.com/knownasilya/ember-addon-viewer/commit/57ef66b))
* more data for addon cards, fix what is included in builds ([58a6c01](https://github.com/knownasilya/ember-addon-viewer/commit/58a6c01))

repository: knownasilya/ember-addon-viewer

gha_language: JavaScript

repo_name: knownasilya/ember-addon-viewer


text:
# Android-ImageResizer
Class allowing to reduce a high-resolution image or drawable for a smaller resolution component without quality loss.

## How to use

```
ImageView.setImageBitmap(ImageResizer.decodeSampledBitmapFromResource(Resources res, int resId, int reqWidth, int reqHeight))
```

repository: llastkrakw/Android-ImageResizer

repo_name: llastkrakw/Android-ImageResizer


text:
# Twister2

[![Build Status](https://travis-ci.org/DSC-SPIDAL/twister2.svg?branch=master)](https://travis-ci.org/DSC-SPIDAL/twister2)

Twister2 is a composable big data environment supporting streaming, data pipelines and analytics. Our
vision is to build robust, simple to use data analytics solutions that can leverage both clouds and
high performance computing infrastructure.

We started the project with the vision described in the paper [Twister2 Design of a Big Data Toolkit](http://dsc.soic.indiana.edu/publications/twister2_design_big_data_toolkit.pdf).

The documentation is found at [https://twister2.org/](https://twister2.org)

## Contact

We are a global open community welcoming contributions to the project in any form.

### Mailing List

Twister2 Google Groups: [twister2@googlegroups.com](https://groups.google.com/forum/#!forum/twister2)

### Slack Channel

Twister2 Slack Channel: [https://dsc-twister.slack.com](https://dsc-twister.slack.com)

## License

Licensed under the Apache License, Version 2.0: [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)


text:
# Azure API Management feature
[![Changelog](https://img.shields.io/badge/changelog-release-green.svg)](CHANGELOG.md) [![Notice](https://img.shields.io/badge/notice-copyright-yellow.svg)](NOTICE) [![Apache V2 License](https://img.shields.io/badge/license-Apache%20V2-orange.svg)](LICENSE) [![TF Registry](https://img.shields.io/badge/terraform-registry-blue.svg)](https://registry.terraform.io/modules/claranet/api-management/azurerm/)

This Terraform module creates an [Azure API Management](https://docs.microsoft.com/en-us/azure/api-management/).

## Requirements

* [AzureRM Terraform provider](https://www.terraform.io/docs/providers/azurerm/) >= 1.32

## Version compatibility

| Module version | Terraform version | AzureRM version |
| -------------- | ----------------- | --------------- |
| >= 5.x.x       | 0.15.x & 1.0.x    | >= 2.0          |
| >= 4.x.x       | 0.13.x            | >= 2.0          |
| >= 3.x.x       | 0.12.x            | >= 2.0          |
| >= 2.x.x       | 0.12.x            | < 2.0           |
| <  2.x.x       | 0.11.x            | < 2.0           |

## Usage

This module is optimized to work with the [Claranet terraform-wrapper](https://github.com/claranet/terraform-wrapper) tool
which set some terraform variables in the environment needed by this module.
More details about variables set by the `terraform-wrapper` available in the [documentation](https://github.com/claranet/terraform-wrapper#environment).

You can use this module by including it this way:

```hcl
module "azure-region" {
  source  = "claranet/regions/azurerm"
  version = "x.x.x"

  azure_region = var.azure_region
}

module "rg" {
  source  = "claranet/rg/azurerm"
  version = "x.x.x"

  location    = module.azure-region.location
  client_name = var.client_name
  environment = var.environment
  stack       = var.stack
}

module "apim" {
  source  = "claranet/rg/api-management"
  version = "x.x.x"

  location       = module.azure-region.location
  location_short = module.azure-region.location_short
  client_name    = var.client_name
  environment    = var.environment
  stack          = var.stack

  sku_name        = "Standard_1"
  publisher_name  = "Contoso ApiManager"
  publisher_email =<EMAIL_ADDRESS>
  named_values = [
    {
      name   = "my_named_value"
      value  = "my_secret_value"
      secret = true
    },
    {
      display_name = "My second value explained"
      name         = "my_second_value"
      value        = "my_not_secret_value"
    }
  ]

  additional_location = [
    {
      location  = "eastus2"
      subnet_id = data.terraform_remote_state.global-infra.outputs.subnet_api_management_east_us_prd_id
    },
  ]
}
```

<!-- BEGIN_TF_DOCS -->
## Providers

| Name | Version |
|------|---------|
| azurerm | ~> 2.29 |

## Modules

| Name | Source | Version |
|------|--------|---------|
| logging | claranet/diagnostic-settings/azurerm | 4.0.2 |

## Resources

| Name | Type |
|------|------|
| [azurerm_api_management.apim](https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/resources/api_management) | resource |
| [azurerm_api_management_group.group](https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/resources/api_management_group) | resource |
| [azurerm_api_management_named_value.named_values](https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/resources/api_management_named_value) | resource |
| [azurerm_api_management_product.product](https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/resources/api_management_product) | resource |
| [azurerm_api_management_product_group.product_group](https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/resources/api_management_product_group) | resource |
| [azurerm_network_security_rule.management_apim](https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/resources/network_security_rule) | resource |

## Inputs

| Name | Description | Type | Default | Required |
|------|-------------|------|---------|:--------:|
| additional\_location | List of the name of the Azure Region in which the API Management Service should be expanded to. | `list(map(string))` | `[]` | no |
| certificate\_configuration | List of certificate configurations | `list(map(string))` | `[]` | no |
| client\_name | Client name/account used in naming | `string` | n/a | yes |
| create\_management\_rule | Whether to create the NSG rule for the management port of the APIM. If true, nsg\_name variable must be set | `bool` | `false` | no |
| create\_product\_group\_and\_relationships | Create local APIM groups with name identical to products and create a relationship between groups and products | `bool` | `false` | no |
| custom\_name | Custom API Management name, generated if not set | `string` | `""` | no |
| developer\_portal\_hostname\_configuration | Developer portal hostname configurations | `list(map(string))` | `[]` | no |
| diag\_settings\_name | Custom name for the diagnostic settings of Application Gateway. | `string` | `""` | no |
| enable\_http2 | Should HTTP/2 be supported by the API Management Service? | `bool` | `false` | no |
| enable\_sign\_in | Should anonymous users be redirected to the sign in page? | `bool` | `false` | no |
| enable\_sign\_up | Can users sign up on the development portal? | `bool` | `false` | no |
| environment | Project environment | `string` | n/a | yes |
| extra\_tags | Extra tags to add | `map(string)` | `{}` | no |
| identity\_ids | A list of IDs for User Assigned Managed Identity resources to be assigned. This is required when type is set to UserAssigned or SystemAssigned, UserAssigned. | `list(string)` | `[]` | no |
| identity\_type | Type of Managed Service Identity that should be configured on this API Management Service | `string` | `"SystemAssigned"` | no |
| location | Azure location for Eventhub. | `string` | n/a | yes |
| location\_short | Short string for Azure location. | `string` | n/a | yes |
| log\_categories | List of log categories to send | `list(string)` | `null` | no |
| log\_destination\_type | Log sent to Log Analytics can be sent to 'Dedicated' log tables or the legacy 'AzureDiagnostics' | `string` | `"Dedicated"` | no |
| logs\_destinations\_ids | List of destination resources IDs for logs diagnostic destination. Can be Storage Account, Log Analytics Workspace and Event Hub. No more than one of each can be set. | `list(string)` | `[]` | no |
| logs\_storage\_retention | Retention in days for logs on Storage Account | `number` | `30` | no |
| management\_hostname\_configuration | List of management hostname configurations | `list(map(string))` | `[]` | no |
| management\_nsg\_rule\_priority | Priority of the NSG rule created for the management port of the APIM | `number` | `101` | no |
| metric\_categories | List of metric categories to send | `list(string)` | `null` | no |
| name\_prefix | Optional prefix for Network Security Group name | `string` | `""` | no |
| named\_values | Map containing the name of the named values as key and value as values | `list(map(string))` | `[]` | no |
| notification\_sender\_email | Email address from which the notification will be sent | `string` | `null` | no |
| nsg\_name | NSG name of the subnet hosting the APIM to add the rule to allow management if the APIM is private | `string` | `null` | no |
| nsg\_rg\_name | Name of the RG hosting the NSG if it's different from the one hosting the APIM | `string` | `null` | no |
| policy\_configuration | Map of policy configuration | `map(string)` | `{}` | no |
| portal\_hostname\_configuration | Legacy portal hostname configurations | `list(map(string))` | `[]` | no |
| products | List of products to create | `list(string)` | `[]` | no |
| proxy\_hostname\_configuration | List of proxy hostname configurations | `list(map(string))` | `[]` | no |
| publisher\_email | The email of publisher/company. | `string` | n/a | yes |
| publisher\_name | The name of publisher/company. | `string` | n/a | yes |
| resource\_group\_name | Name of the resource group | `string` | n/a | yes |
| scm\_hostname\_configuration | List of scm hostname configurations | `list(map(string))` | `[]` | no |
| security\_configuration | Map of security configuration | `map(string)` | `{}` | no |
| sku\_name | String consisting of two parts separated by an underscore. The fist part is the name, valid values include: Developer, Basic, Standard and Premium. The second part is the capacity | `string` | `"Basic_1"` | no |
| stack | Project stack name | `string` | n/a | yes |
| terms\_of\_service\_configuration | Map of terms of service configuration | `list(map(string))` | `[]` | no |
| virtual\_network\_configuration | The id(s) of the subnet(s) that will be used for the API Management. Required when virtual\_network\_type is External or Internal | `list(string)` | `[]` | no |
| virtual\_network\_type | The type of virtual network you want to use, valid values include: None, External, Internal. | `string` | `null` | no |

## Outputs

| Name | Description |
|------|-------------|
| api\_management\_additional\_location | Map listing gateway\_regional\_url and public\_ip\_addresses associated |
| api\_management\_gateway\_regional\_url | The Region URL for the Gateway of the API Management Service |
| api\_management\_gateway\_url | The URL of the Gateway for the API Management Service |
| api\_management\_id | The ID of the API Management Service |
| api\_management\_identity | The identity of the API Management |
| api\_management\_management\_api\_url | The URL for the Management API associated with this API Management service |
| api\_management\_name | The name of the API Management Service |
| api\_management\_portal\_url | The URL for the Publisher Portal associated with this API Management service |
| api\_management\_private\_ip\_addresses | The Private IP addresses of the API Management Service |
| api\_management\_public\_ip\_addresses | The Public IP addresses of the API Management Service |
| api\_management\_scm\_url | The URL for the SCM Endpoint associated with this API Management service |
<!-- END_TF_DOCS -->
## Related documentation

Microsoft Azure documentation: [https://docs.microsoft.com/en-us/azure/api-management/](https://docs.microsoft.com/en-us/azure/api-management/)


text:
# The Offbeat Appetite [![Build Status](https://travis-ci.org/ciampo/offbeat-appetite.svg?branch=master)](https://travis-ci.org/ciampo/offbeat-appetite) [![codecov](https://codecov.io/gh/ciampo/offbeat-appetite/branch/master/graph/badge.svg)](https://codecov.io/gh/ciampo/offbeat-appetite) [![Netlify Status](https://api.netlify.com/api/v1/badges/8a466cb6-4eef-463d-81be-18240576884d/deploy-status)](https://app.netlify.com/sites/offbeatappetite/deploys)

Tech stack overview:

- [Sanity](https://sanity.io) as Headless CMS
  ([Studio repo](https://github.com/ciampo/offbeat-appetite-sanity))
- [Next.js](https://nextjs.org/) as Static Site Generator
- [Netlify](https://www.netlify.com/) as Static Site Hosting

## 🛠 Setup

- install `node` glolbally
- install `yarn` glolbally
- set up Sanity, Netlify and Google Analytics
- copy `.env.example` and rename it to `env`. Add the correct values for the env variables.
- add the same env variables to Netlify and Travis
- `yarn install`

## 📝 Main scripts

### `yarn dev`

Starts the application in development mode (hot-code reloading, error reporting, etc)

### `yarn data`

Pulls data from Sanity (make sure you added env variables both into a `.env` and into your Netlify
project)

### `yarn static`

Builds the app in production mode and exports it as static site ready to be hosted on Netlify.

### `yarn serve:static`

Serves the static site. The application should be compiled with `yarn static` first.

### `yarn test`

Runs Jest (eslint, unit, intergration). If executed by CI, it will track code coverage. Otherwise,
it will start in watch mode.

### `yarn validate`

Performs all types of tests (including static testing) and finally attempts to build the project.
Useful for CI

### `yarn analyze`

Builds the app and opens 2 graphs in the browser showing the app's bundle composition.

## ⚖ Staging vs Production deploys

The [`staging`](https://app.netlify.com/sites/offbeatappetite-staging) and
[`production`](https://app.netlify.com/sites/offbeatappetite) sites **are hosted on Netlify and are
both _static sites_**. Both projects are deployed via a CI/CD pipeline triggered by new commits to
the master branch on this repo.

There are a few differences between the staging and production site environments:

| Feature (via env variables) | Dev (local) | Staging  | Production |
| :-------------------------: | :---------: | :------: | :--------: |
|      Google Analytics       |   staging   | staging  |    prod    |
|       Subscribe Form        |   enabled   | disabled |  enabled   |
|   Sanity Token for drafts   |     Yes     |   Yes    |     No     |
|        Canonical URL        |    prod     | staging  |    prod    |
|          Recaptcha          | always pass | staging  |    prod    |

Furthermore, the staging site is preventing robots from indexing its contents.

## 👻 Contributors

- [Marco Ciampini](https://github.com/ciampo), developer
- [Marie Claire Tonna](https://github.com/mctonna), site owner

repository: ciampo/offbeat-appetite

repo_name: ciampo/offbeat-appetite


text:
Nottui is a toolkit for making terminal user-interfaces.
It builds upon [Notty](https://github.com/pqwy/notty/), adding a layout DSL and support for event dispatch. It uses [Lwd](https://github.com/let-def/lwd) for interactivity.

# Getting started

The package is distributed through opam:

```ocaml
$ opam install nottui
```

Here are a few examples to being using Nottui.
Let's start with Hello world.

#### Hello world

```ocaml
#require "nottui";;
open Nottui;;
module W = Nottui_widgets;;

Ui_loop.run (Lwd.pure (W.printf "Hello world"));;
```

Running the application is just a matter of calling `Ui_loop.run` with a ui
value.

**Note:** Press Ctrl-Q to return to the top-level (or shell).

#### Counting clicks

Now we will count the number of clicks on a button.

```ocaml
let vcount = Lwd.var 0;;

let button count =
  W.button (Printf.sprintf "Clicked %d times!" count)
           (fun () -> Lwd.set vcount (count + 1));;

Ui_loop.run (Lwd.map button (Lwd.get vcount));;
```

We reserve state for holding the number of clicks, we render a button and
increment the state when clicked.

#### Displaying a tree

```ocaml
type tree = Tree of string * (unit -> tree list)

let rec tree_ui (Tree (label, child)) =
  let opened = Lwd.var false in
  let render is_opened =
    let btn_text = if is_opened then "[-] " else "[+] " in
    let btn_action () = Lwd.set opened (not is_opened) in
    let btn = W.button (btn_text ^ label) btn_action in
    let layout node forest =
      Ui.join_y node (Ui.join_x (Ui.space 2 0) forest)
    in
    if is_opened
    then Lwd.map (layout btn) (forest_ui (child ()))
    else Lwd.pure btn
  in
  Lwd.join (Lwd.map render (Lwd.get opened))

and forest_ui nodes =
  Lwd_utils.pack Ui.pack_y
    (List.map tree_ui nodes)
;;

let rec fake_fs () = [
  Tree ("bin", fake_fs);
  Tree ("home", fake_fs);
  Tree ("usr", fake_fs);
] in
Ui_loop.run (forest_ui (fake_fs ()));;
```

# Layout DSL

TODO: give intuition on Layout DSL

repository: let-def/lwd

gha_language: OCaml

repo_name: let-def/lwd


text:
---
title: "Transaction Pool"
---

# Transaction Pool

## Installation

```bash
yarn add @arkecosystem/core-transaction-pool
```

## Alias

`transactionPool`

## Interface

[core-transaction-pool](https://github.com/ArkEcosystem/core/tree/develop/packages/core-transaction-pool)

## Implementation

[core-transaction-pool-mem](https://github.com/ArkEcosystem/core/tree/develop/packages/core-transaction-pool-mem)

## Notable Dependencies

- [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3)

## Summary

The transaction pool package is responsible for verifying, validating and sorting valid transactions within the Ark Core node prior to their inclusion in a block and the blockchain history.

Within the lifecycle of a transaction as it goes from request to blockchain entry, `core-transaction-pool` represents the intermediate step: after a transaction is submitted to the network, before it is included on the blockchain.

## Usage

As `core-transaction-pool` is primarily an internal tool, all Ark Core nodes that utilize this package (all nodes except dedicated forgers) don't need to do anything to set up their pools. The pool will load and begin working by default upon node startup.

If you are a forging delegate running a full node, customizing the transaction pool limit is one way to affect the economics behind running your node. Increasing the pool limit can increase your node's capacity to process transactions during times of increased blockchain activity.

Conversely, decreasing your pool's capacity could have the effect of increasing your node's average fee per transaction. When your pool fills up it compares incoming transactions against the transactions currently in the pool, picking the higher-fee and discarding the lower-fee transaction. Because of this, while your node's transaction count per block might go down, the average fee per transaction will rise as higher fees enter the pool and lower fees are rejected.

It is up to each forging delegate to determine what balance between transaction quantity and transaction profitability will work best for their particular situation and setup.

Typically, plugin developers should have no reason to access the transaction pool directly. As the transaction pool is only a temporary stopping point for transactions en route to blockchain history, customizing the transaction pool too much as an individual node runs the risk of bringing your node out of sync with the network.

Bridgechain developers looking to alter their chain's consensus rules could benefit from a custom implementation of `core-transaction-pool`, as the pool's Guard class bears the primary responsibility for determining which transactions are valid under the rules of the network. Changing the Guard's verification rules, therefore, is a logical first step towards modifying consensus protocols to better match your custom network objectives.

## Behind the Scenes

All transactions must be confirmed as valid prior to being added to the transaction pool. This ensures that when `core-blockchain` decides which transactions to include in the next forging block, it can be sure that all transactions in the pool are valid.

The package contains two primary submodules worth inspecting in detail: the Guard and the Pool.

The Guard makes sure that a given transaction can be safely added to the blockchain before passing it to the Pool, which determines what transactions should be included in a block and in what order.

As of the time of writing, the Guard filters out the following types of transaction requests:

- Transactions already in the pool (to prevent [replay attacks](https://en.wikipedia.org/wiki/Replay_attack))
- Transactions from blocked senders (senders who send invalid transactions/blocks)
- Transactions from the future
- Transactions with fees to low to accept/broadcast
- Transactions that fail to verify when cast into a Transaction model

Transactions that pass the Guard are added to the Pool, assuming that the Pool has enough room and that the sending account has enough balance to complete the transaction.

The Pool deducts the outstanding balance from the sending wallet **before** the transaction is included in a block to prevent this balance from being double spent.

It is important to note that this deduction is not final, and that the balance is returned if the transaction drops out of the Pool before inclusion in a block.

## Default Settings:
```js
{
  enabled: !process.env.ARK_TRANSACTION_POOL_DISABLED,
  syncInterval: 512,
  storage: `${process.env.ARK_PATH_DATA}/database/transaction-pool-${
    process.env.ARK_NETWORK_NAME
  }.sqlite`,
  // When the pool contains that many transactions, then a new transaction is
  // only accepted if its fee is higher than the transaction with the lowest
  // fee in the pool. In this case the transaction with the lowest fee is removed
  // from the pool in order to accommodate the new one.
  maxTransactionsInPool: process.env.ARK_MAX_TRANSACTIONS_IN_POOL || 100000,
  maxTransactionsPerSender:
    process.env.ARK_TRANSACTION_POOL_MAX_PER_SENDER || 300,
  allowedSenders: [],
  maxTransactionsPerRequest:
    process.env.ARK_TRANSACTION_POOL_MAX_PER_REQUEST || 40,
  maxTransactionAge: 2700,
}
```


text:
# ![Triangle logo](https://user-images.githubusercontent.com/883386/32769128-4d9625c6-c923-11e7-9a96-030f2f0efff3.png)

[![build](https://github.com/esimov/triangle/actions/workflows/build.yml/badge.svg)](https://github.com/esimov/triangle/actions/workflows/build.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/esimov/triangle)](https://goreportcard.com/report/github.com/esimov/triangle)
[![Go Reference](https://pkg.go.dev/badge/github.com/esimov/triangle.svg)](https://pkg.go.dev/github.com/esimov/triangle)
[![license](https://img.shields.io/github/license/esimov/triangle)](./LICENSE)
[![release](https://img.shields.io/badge/release-v2.0.0-blue.svg)](https://github.com/esimov/triangle/releases/tag/v2.0.0)
[![homebrew](https://img.shields.io/badge/homebrew-v2.0.0-orange.svg)](https://formulae.brew.sh/formula/triangle)

**▲ Triangle** is a tool for generating triangulated image using [delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation). It takes a source image and converts it to an abstract image composed of tiles of triangles.

![Sample image](https://github.com/esimov/triangle/blob/master/output/sample_3.png)

### The process
* First the image is blured out to smoth out the sharp pixel edges. The more blured an image is the more diffused the generated output will be.
* Second the resulted image is converted to grayscale mode.
* Then a [sobel](https://en.wikipedia.org/wiki/Sobel_operator) filter operator is applied on the grayscaled image to obtain the image edges. An optional threshold value is applied to filter out the representative pixels of the resulted image.
* A convolution filter operator is applied over the image data in order to adjust its final aspect prior running the delaunay triangulation process.
* Lastly the delaunay algorithm is applied on the pixels obtained from the previous step.

### Features

- [x] Can process recursively whole directories and subdirectories concurrently.
- [x] Supports various image types.
- [x] There is no need to specify the file type, the CLI tool can recognize automatically the input and output file type.
- [x] Can accept image URL as parameter for the `-in` flag.
- [x] Possibility to save the generated image as an **SVG** file.
- [x] The generated SVG file can be accessed from the Web browser directly.
- [x] Clean and intuitive API. The API not only that accepts image files but can also work with image data. This means that the [`Draw`](https://github.com/esimov/triangle/blob/65672f53a60a6a35f5e85bed69e46e97fe2d2def/process.go#L82) method can be invoked even on data streams. Check this [demo](https://github.com/esimov/pigo-wasm-demos#face-triangulator) for reference.
- [x] Support for pipe names (possibility to pipe in and pipe out the source and destination image).

#### TODO
- [ ] Standalone and native GUI application

Head over to this [subtopic](#key-features) to get a better understanding of the supported features.

## Installation and usage
```bash
$ go install<EMAIL_ADDRESS>```
You can also download the binary file from the [releases](https://github.com/esimov/triangle/releases) folder.

## MacOS (Brew) install
The library can be installed via Homebrew too.

```bash
$ brew install triangle
```

## API usage
```go
proc := &triangle.Processor{
	MaxPoints:  2500,
	BlurRadius: 2,
	PointRate:  0.75,
	BlurFactor: 1,
	EdgeFactor: 6,
}

img := &triangle.Image{
	Processor: *proc,
}

input, err := os.Open("input.jpg")
if err != nil {
	log.Fatalf("error opening the source file: %v", err)
}

// decode image
src, err := img.DecodeImage(input)
if err != nil {
	log.Fatalf("error decoding the image: %v", err)
}
res, _, _, err := img.Draw(src, *proc, func() {})
if err != nil {
	log.Fatalf("error generating the triangles: %v", err)
}

output, err := os.Create("output.png")
if err != nil {
	log.Fatalf("error opening the destination file: %v", err)
}

// encode image
png.Encode(output, res)

```

## Supported commands

```bash
$ triangle --help
```
The following flags are supported:

| Flag | Default | Description |
| --- | --- | --- |
| `in` | n/a | Source image |
| `out` | n/a | Destination image |
| `bl` | 2 | Blur radius |
| `nf` | 0 | Noise factor |
| `bf` | 1 | Blur factor |
| `ef` | 6 | Edge factor |
| `pr` | 0.075 | Point rate |
| `pth` | 10 | Points threshold |
| `pts` | 2500 | Maximum number of points |
| `so` | 10 | Sobel filter threshold |
| `sl` | false | Use solid stroke color (yes/no) |
| `wf` | 0 | Wireframe mode (0: without stroke, 1: with stroke, 2: stroke only) |
| `st` | 1 | Stroke width |
| `gr` | false | Output in grayscale mode |
| `web` | false | Open the SVG file in the web browser |
| `bg` | ' ' | Background color (specified as hex value) |
| `cw` | system spec. | Number of files to process concurrently

## Key features

#### Process multiple images from a directory concurrently
The CLI tool also let you process multiple images from a directory **concurrently**. You only need to provide the source and the destination folder by using the `-in` and `-out` flags.

```bash
$ triangle -in <input_folder> -out <output-folder>
```

You can provide also an image file URL for the `-in` flag.
```bash
$ triangle -in <image_url> -out <output-folder>
```

#### Pipe names
The CLI tool accepts also pipe names, which means you can use `stdin` and `stdout` without the need of providing a value for the `-in` and `-out` flag directly since these defaults to `-`. For this reason it's possible to use `curl` for example for downloading an image from the internet and invoke the triangulation process over it directly without the need of getting the image first and calling **▲ Triangle** afterwards.

Here are some examples using pipe names:
```bash
$ curl -s <image_url> | triangle > out.jpg
$ cat input/source.jpg | triangle > out.jpg
$ triangle -in input/source.jpg > out.jpg
$ cat input/source.jpg | triangle -out out.jpg
$ triangle -out out.jpg < input/source.jpg
```

#### Background color
You can specify a background color in case of transparent background images (`.png`) by using the `-bg` flag. This flag accepts a hexadecimal string value. For example setting the flag to `-bg=#ffffff00` will set the alpha channel of the resulted image transparent.

#### Output as image or SVG
By default the output is saved to an image file, but you can export the resulted vertices even to an SVG file. The CLI tool can recognize the output type directly from the file extension. This is a handy addition for those who wish to generate large images without guality loss.

```bash
$ triangle -in samples/input.jpg -out output.svg
```

Using with `-web` flag you can access the generated svg file directly on the web browser.

```bash
$ triangle -in samples/input.jpg -out output.svg -web=true
```

#### Supported output types
The following output file types are supported: `.jpg`, `.jpeg`, `.png`, `.bmp`, `.svg`.

### Tweaks
Setting a lower points threshold, the resulted image will be more like a cubic painting. You can even add a noise factor, generating a more artistic, grainy image.

Here are some examples you can experiment with:
```bash
$ triangle -in samples/input.jpg -out output.png -wf=0 -pts=3500 -st=2 -bl=2
$ triangle -in samples/input.jpg -out output.png -wf=2 -pts=5500 -st=1 -bl=10
```

## Examples

![Triangle1](https://github.com/esimov/triangle/blob/master/output/sample_0.png)
![Triangle2](https://github.com/esimov/triangle/blob/master/output/sample_1.png)
![Triangle3](https://github.com/esimov/triangle/blob/master/output/sample_11.png)

## License
Copyright © 2018 Endre Simo

This project is under the MIT License. See the [LICENSE](https://github.com/esimov/triangle/blob/master/LICENSE) file for the full license text.

repository: esimov/triangle

gha_language: Go

repo_name: esimov/triangle


text:
---
toc: true
layout: post
author: "Sanjeevi Subramani"
description:
categories: [DotnetCore, Troubleshooting]
title: Troubleshooting by writing logs at the application start for .NET core app using Serilog
---

![](https://cdn-images-1.medium.com/max/2000/1*-xYp4lT93KUu1teArXv5-w.jpeg)

.NET core 3.1 app may fail to start, and any logging integration implemented in startup using a middleware or anything wont log the errors for the exception occurring at the app start.

To troubleshoot this, we will write log at the Program.cs and startup.cs using Serilog.

Install Serilog related items from Nuget:
>  <PackageReference Include=”Serilog” Version=”2.10.0" />
 <PackageReference Include=”Serilog.AspNetCore” Version=”3.4.0" />
 <PackageReference Include=”Serilog.Sinks.File” Version=”4.1.0" />

Initialize the Serilog using below hightlighted code in Main method in Program.cs.

And call UseSerilog() method when setting up the HostBuilder.

Thats all we must do for setting up the Serilog for logging at app start up logs. Now you can call the Log.Error or Log.Information from the application it will log it in the file and in console if application called from console. If deployed in Azure App Service this log will come in the LogStream option also.

For App Service log at console feature in Azure App Service refer [this article](https://medium.com/lkg-in-it/troubleshooting-http-error-500-30-79e3b4f660ee).
>  namespace SampleStartupLog
{
 using System;
 using Serilog;
>  public class Program
 {
 public static void Main(string[] args)
 {
 **
Log.Logger = new LoggerConfiguration()
 .WriteTo.File(
 @”D:\home\LogFiles\Application\myapp.txt”,
 fileSizeLimitBytes: 1_000_000,
 rollOnFileSizeLimit: true,
 shared: true,
 flushToDiskInterval: TimeSpan.FromSeconds(1))
 .WriteTo.Console()
 .CreateLogger();**
>  try
 {
 CreateHostBuilder(args).Build().Run();
 }
 catch (Exception ex)
 {
 Log.Error(ex.Message + ex.StackTrace);
 }
 finally
 {
 Log.CloseAndFlush();
 }
 }
>  public static IHostBuilder CreateHostBuilder(string[] args) =>
 Host.CreateDefaultBuilder(args)
 **.UseSerilog()**
 .ConfigureAppConfiguration((hostContext, config) =>
 {
 var env = hostContext.HostingEnvironment;
>  config.SetBasePath(env?.ContentRootPath)
 .AddEnvironmentVariables();
 })
 .ConfigureWebHostDefaults(webHostBuilder =>
 {
 HostBuilderService hostBuilderService = new HostBuilderService(webHostBuilder);
 webHostBuilder.UseStartup<Startup>();
 })
 .UseDefaultServiceProvider((context, options) =>
 {
 options.ValidateScopes = context.HostingEnvironment.IsDevelopment();
 options.ValidateOnBuild = true;
 });
 }
}

Thanks.

repository: SSanjeevi/lkgforitmediumish

branch_name: refs/heads/main

repo_name: SSanjeevi/lkgforitmediumish


text:
---
wordpress_id: 1008
layout: post
title: Cloaking your web apps - The hooded Apache
date: 2011-04-25 19:54:06 +01:00
tags:
- security
- linux
- apache
- hacking
categories:
- hacking
- linux
- security
wordpress_url: https://blog.oneiroi.co.uk/hacking/cloaking-your-web-apps-the-hooded-apache
comments: true
---

Go ahead and run

{% highlight bash %}
curl -I https://blog.oneiroi.co.uk
{% endhighlight %}

You will get

{% highlight bash %}
HTTP/1.1 200 OK
Date: Mon, 25 Apr 2011 19:33:29 GMT
Server: Apache
Vary: Accept-Encoding,Cookie
Cache-Control: max-age=3, must-revalidate
WP-Super-Cache: Served supercache file from PHP
Connection: close
Content-Type: text/html; charset=UTF-8
{% endhighlight %}

As an attacker looking to hit a web app, one of the first things you're going to want to look into is what version of web server is running, in this case you can see this blog in fact runs apache ... but there is not much else to go on here is there.

That's intentional, and by manual configuration changes I have put in place, this is not the case of a default LAMP install, take for instance, this snippet from another website,

{% highlight bash %}
Server: Apache/2.2.16 (Debian)
X-Powered-By: PHP/5.2.14
{% endhighlight %}

This already has given me a wealth of information to go on and begin prepping an attack, I now know the site is running php version 5.2.14 Apache version 2.2.16 and that the underlying OS is Debian.

See the dilemma? your default roll outs are just declaring their running versions to anyone willing to listen, so lets make it a little more stealthy.

First and foremost if you are using php, edit your php.ini and set the following:

{% highlight bash %}
expose_php = off
{% endhighlight %}

Now head into your httpd.conf and set the following

{% highlight bash %}
ServerTokens prod
{% endhighlight %}

and

{% highlight bash %}
ServerSignature off
{% endhighlight %}

With these 3 simple steps all the headers will now return is Server: Apache this is the first step to shielding your app, I'll be covering further steps as time allows.

branch_name: refs/heads/octopress

extension: markdown


text:
# [WIP] Time to First Commit

It’s the time it takes
from when The New Person turn on PC
to the time when they've pushed the first commit to the version control system.

## It’s Comprehensive

developer

- organization’s Software Development Life Cycle polices
- a task in issue tracking system
- security credentials
- a fully configured development envrioment
- source code from the version control system

## It’s Quantitative

Time to First Commit is a measurable quantity, which means that it’s relatively easy to figure out where your team is at now, what a reasonable target might be, and then steps the team can take to drive towards achieving that goal. It means that as new tools are adopted and processes evolved over time, you can measure whether these things have positively or negatively impacted this metric and take the necessary steps to address any problems. For example, if a developer checks in a change that brings in some new dependency and hasn’t documented how to set it up (or better yet, automated the setup), it’s pretty likely you’ll see a regression in this metric.

## Optimizing For Time to First Commit

Documentation:

- Development environment setup guide.
- Makefile target descriptions.
- Instructions for running both unit and end-to-end tests
- Recommended tools, editor plug-ins, etc.

Automation:

- CI
- Git hooks
- Makefiles

repository: ptux/mashtun

path: /docs/Artifacts/StreamlineOnboarding/time to first commit.md

filename: time to first commit.md

repo_name: ptux/mashtun


text:
# Milestone-2: SUDOKU

## Team Members:

[Aniket-ap](https://github.com/Aniket-ap)

[Sunitha142](https://github.com/Sunitha142)

M Chandrashekar

Sudoku is a logic-based, combinatorial number-placement puzzle. The objective is to fill a 9×9 grid with digits so that each column, each row, and each of the nine 3×3 sub-grids that compose the grid (also called "boxes") contains the digits from 1 to 9.

Generally, a puzzle provides a partial solution so that some squares already have numbers. To solve the puzzle, we need to fill in the unsolved squares, as demonstrated in Figure 1.

By the end of this challenge we'll have a fully functioning Sudoku solver that runs from the command line. We'll be presented with 9x9 unsolved Sudoku puzzle grid. The puzzles grid can be found in the file sudoku_puzzles.txt.

Sudoku Solver is basically your code that takes your input and produces output mathematically

Input: format Space separated given numbers in the grid ( 0 for empty place ) in sudoku_puzzles.txt

Output: format 9x9 sudoku grid

A complete solution to this challenge take Input 9x9 and produce output grid 9x9


text:
---
title: Python
weight: 70
tags:
  - python
  - languages
categories:
  - languages
---
We use **virtualenv** to manage python environments for you. We currently support Python `2.7.6`. Version `3.4.0` of Python is installed as well and available via the `python3` binary.

## Dependencies
You can use pip to install any dependencies, for example

```shell
pip install -r requirements.txt
```

## Python 3
As the virtual environment from `${HOME}/.virtualenv` is already activated and configured for use on the build VMs, if you want to switch to version 3, simply add the following commands to your _Setup Steps_.

```shell
virtualenv -p $(which python3) "${HOME}/cache/python3_env"
source "${HOME}/cache/python3_env/bin/activate"
```

gha_language: CSS


text:
# CartCollector-8
Contains two parts:

1. A Python utility which installs the latest PICO-8 cartridges.
2. An SDL launcher for carts held in the PICO-8 cart directory.

Dependencies
------------

**Python**

```
pip install beautifulsoup4
```

**C++**

```
SDL2
SDL2_ttf
SDL2_image
```


text:
---
title: "Writing pre-request scripts"
order: 42
updated: 2022-07-20
page_id: "pre_request_scripts"
contextual_links:
  - type: section
    name: "Additional resources"
  - type: subtitle
    name: "Videos"
  - type: link
    name: "Pre-request Scripts in Postman | The Exploratory"
    url: "https://youtu.be/1ls5Dr5SOxw"
  - type: link
    name: "Get and Set Variables | Postman Level Up"
    url: "https://youtu.be/EKv6n-jY9lU"
  - type: subtitle
    name: "Blog posts"
  - type: link
    name: "When and How to Use JSON Serialization in Postman"
    url: "https://blog.postman.com/when-and-how-to-use-json-serialization-in-postman/"
  - type: subtitle
    name: "Case Studies"
  - type: link
    name: "Twitter uses pre-request scripts to create a testing environment"
    url:  "https://www.postman.com/case-studies/twitter/"
  - type: link
    name: "Toast chains requests automatically with pre-request scripts"
    url:  "https://www.postman.com/case-studies/toast/"
warning: false

---

You can use pre-request scripts in Postman to execute JavaScript before a request runs. By including code in the __Pre-request Script__ tab for a request, collection, or folder, you can carry out pre-processing such as setting variable values, parameters, headers, and body data. You can also use pre-request scripts for debugging code, for example by logging output to the console.

## Contents

* [Pre-request scripting example](#pre-request-scripting-example)
* [Scripting before your request runs](#scripting-before-your-request-runs)
* [Re-using pre-request scripts](#re-using-pre-request-scripts)
* [Next steps](#next-steps)

## Pre-request scripting example

An example usage of pre-request scripting could be as follows:

* You have a series of requests in a collection and are running them in a sequence, such as when using the [collection runner](/docs/collections/running-collections/intro-to-collection-runs/).
* The second request is dependent on a value returned from the first request.
* The value needs to be processed before you pass it to the second request.
* The first request sets the data value from a response field to a variable in its __Tests__ script.
* The second request retrieves the value and processes it in its __Pre-request Script__, then sets the processed value to a variable (which is referenced in the second request, for example in its parameters).

## Scripting before your request runs

To include code you want to execute before Postman sends a request, do the following:

1. Select __Collections__ in the sidebar.
1. Open the request, then select the __Pre-request Script__ tab.
1. Enter the JavaScript you need to process before the request runs, then select __Save__.
1. Select __Send__ to send the request. The code will execute before Postman sends the request to the API.

    ![Pre-Request Code](https://assets.postman.com/postman-docs/pre-request-script-v8.jpg)

## Re-using pre-request scripts

You can add pre-request scripts to entire collections and folders within collections. In both cases, your pre-request script will run before every request in the collection or direct child request in the folder. This allows you to define commonly used pre-processing or debugging steps you need to execute for multiple requests.

> You can define a pre-request script when you first create a collection or folder, or at any time after that.

To add pre-request scripts to a collection or folder, do the following:

1. Select __Collections__ in the sidebar.
1. Select the more actions icon , then select __Edit__.

1. Select the __Pre-request Scripts__ tab. Enter code that will run before every request in the collection or direct child request in the folder.

   ![Collection pre-request script](https://assets.postman.com/postman-docs/edit-collection-pre-request-v9.jpg)

1. Select __Save__.

## Next steps

After learning the basics of writing pre-request test scripts, you can extend your scripts:

* To learn more about how to use the `pm` object, visit the [Postman JavaScript reference](/docs/writing-scripts/script-references/postman-sandbox-api-reference/).

repository: postmanlabs/postman-docs

branch_name: refs/heads/develop

repo_name: postmanlabs/postman-docs


text:
---
title: Custom Watercolor Family Portraits
date: 2018-12-03 18:25:45 +0000
layout: post
preview: "/uploads/family-3-custom.png"
tags:
- Family portraits
cost: "$30.00"

---
An 8" x 10" watercolor piece on high quality watercolor paper. A simple and unique way of capturing your family and the perfect gift for someone special!

Send me the picture you want painted , and I'll create an 8" x 10" watercolor portrait.

**Details**

* Handmade item
* Made to order
* Shipping available

[To place an order send me your information here](https://artbymegannacc.com/contact/).

##### Here are some of my most recent work.

![](/uploads/family-3-custom.png)

![](/uploads/family-portrait.png)

![](/uploads/IMG_0656.JPG)

repository: naccrat/megan

repo_name: naccrat/megan


text:
# Evolutionary Flocking Shooter
Recently, upgraded with Genetic algorithm. Which enabled bots to learn how to locate the target, avoid danger and exterminate it.

### Technology Used
 *  Unity3d Engine
 *  Genetic Algorithm
 *  C#

### Made with Unity
 *  Tanks
 *  Survival Shooter
 *  Genetic Algorithm

### Links
[Demo Video Link](http://www.youtube.com/watch?v=A9k6WBoY548 "Evolutionary Flocking Shooter")

[Portfolio Link](https://suhaibashraf.github.io/Portfolio/evolutionary-flocking-shooter)

### License
This project (Flocking Shooter) is licensed under the [MIT license](https://github.com/suhaibashraf/Evolutionary-Flocking-Shooter/blob/master/LICENSE.TXT).

### Worked with CoklatGames 2017


text:
# Change Log

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

## [0.0.2](https://github.com/andyperlitch/ngx-super-table/compare/v0.0.1...v0.0.2) (2017-07-19)

### Bug Fixes

* **super-table-component:** Fix issue with async changes ([d6fe14d](https://github.com/andyperlitch/ngx-super-table/commit/d6fe14d)), closes [#19](https://github.com/andyperlitch/ngx-super-table/issues/19)

## [0.0.1](https://github.com/andyperlitch/ngx-super-table/compare/v0.0.0...v0.0.1) (2017-07-16)

# [0.0.0](https://github.com/andyperlitch/ngx-super-table/compare/v0.2.0...v0.0.0) (2017-07-12)

repository: andyperlitch/ngx-super-table

repo_name: andyperlitch/ngx-super-table


text:
---
# Documentation: https://sourcethemes.com/academic/docs/managing-content/

title: "BYK E350"
summary: ""
authors: [glennji]
tags: [inprogress]
categories: []
date: 2020-04-16T12:03:50+10:00

# Optional external URL for project (replaces project detail page).
external_link: ""
crosslink: "true"

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ""
  focal_point: ""
  preview_only: false

# Custom links (optional).
#   Uncomment and edit lines below to show custom links.
# links:
# - name: Follow
#   url: https://twitter.com
#   icon_pack: fab
#   icon: twitter

url_code: ""
url_pdf: ""
url_slides: ""
url_video: ""

# Slides (optional).
#   Associate this project with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
slides: ""
---

## Features

• For kids aged 4 - 6 years and height 95 - 117cm
• Increased knee to handlebar clearance for growing bodies
• Long wheelbase for more predictable handling at higher speeds
• Smooth running tyres to reduce road friction and noise so your child can hear safety instructions
• Ergonomic riding triangle between pedals, seat and handlebar for best balance and efficiency
• Minimum Seat height: 46cm
• Maximum Seat height: 59cm
• Alloy seat clamp
• Custom length cranks
• Pedals with bearings
• Frame: Lightweight Alloy, Low Gravity Concept Design
• Gears: SRAM i-motion Internal 3 Speed Cassette Gears, Totally Integrated & Synchronized Gearing
• Wheels: Dynamic Advantage Tall Alloy Wheels, Reinforced 36 Hole with Toughnut Eyelets
• Tyres: Low-Profile, Low-Resistance Design with Tough Tubes
• Brakes: Alloy Front and Rear Calibrated V Brakes
• Brake Levers: Alloy, Adjustable Short Reach
• Saddle: Comfort Mini
• Handlebars: Custom Width Low Rise V-Bars
• Weight: 11.3kg

**Standard Extras:**
• Safety Reflectors
• Bell
• Kickstand

repository: glennji/website

gha_language: HTML

repo_name: glennji/website


text:
---
layout: post
title: "Richmond Libraries Homework Club"
permalink: /archives/2014/03/richmond_libraries_homework_club.html
commentfile: 2014-03-28-richmond_libraries_homework_club
category: news
date: 2014-03-28 23:43:35
image: "/assets/images/2014/Richmond-Homework-help-poster_thumb.jpg"
excerpt: |
    _Richmond Library is a great place to do your homework!_

    Come along to our free Homework Club during term-time for a quiet place to study, friendly assistance from our specially trained helpers, a wide range of books and supervised internet access. We won't do your homework for you but we'll show you the resources for you to find all the information you need. For 8 - 14 year olds.

---

*Richmond Library is a great place to do your homework!*

Come along to our free Homework Club during term-time for a quiet place to study, friendly assistance from our specially trained helpers, a wide range of books and supervised internet access. We won't do your homework for you but we'll show you the resources for you to find all the information you need. For 8 - 14 year olds.

There are four clubs across the borough:

-   Castelnau Library Tuesdays from 4 March, 3.00 - 4.30pm
-   Richmond and Whitton, Wednesdays from 5 March, 3.00 - 4.30pm
-   Hampton Hill, Thursdays from 6 March, 3.30 - 5.00pm

repository: pmahnke/stmgrts

repo_name: pmahnke/stmgrts


text:
Installation
------------

AirSonos requires [node.js](http://nodejs.org) v0.10.x installed to run. (Progress for 0.11.x support [here](https://github.com/stephen/airsonos/issues/33))

Install via [npm](https://www.npmjs.org)
```
$ npm install airsonos -g
```

Install latest via source
```
$ git clone https://github.com/stephen/airsonos.git
$ cd airsonos
$ npm install -g
```

### Platform Specific Instructions

Some non-OS X platforms require additional dependencies or steps to work.

- [Linux](#linux)
- [Synology](#synology)
- [Raspberry Pi](#raspberry-pi)
- [Windows](#windows)

#### Linux

On linux machines, there are dependencies for `libavahi-compat-libdnssd-dev libasound2-dev` packages (or equivalent). On distributions with `apt`...
```
$ sudo apt-get install libavahi-compat-libdnssd-dev libasound2-dev
```
for `yum`-based distros (CentOS/RHEL):
```
$ yum install avahi avahi-compat-libdns_sd avahi-compat-libdns_sd-devel
```

Note that for some distributions, `nodejs` must be [symlinked to `node` prior to install](https://github.com/stephen/airsonos/issues/90).

#### Synology

See: https://github.com/stephen/airsonos/issues/22

#### Raspberry Pi

You will likely need to [overclock your raspberry pi](https://github.com/stephen/airsonos/issues/42) to achieve acceptable performance.

#### Windows

There is a pre-packaged Windows install that you can use.

- Ensure that 32-bit node.js ([version 0.10.33, 32-bit](http://nodejs.org/dist/v0.10.33/node-v0.10.33-x86.msi)) is installed.
- Download and Install the [Bonjour for Windows SDK](https://developer.apple.com/downloads/index.action?q=Bonjour%20SDK%20for%20Windows#) (requires an AppleID)
- Download [`airsonos_windows_x86.zip`](https://github.com/stephen/airsonos/releases/tag/0.0.19)
- Create the folder `C:\Users\username\AppData\Roaming\npm` if it doesn't already exist.
- Unzip the contents of this package at `C:\Users\username\AppData\Roaming\npm\`, so that `airsonos` and `airsonos.cmd` are directly inside the `\npm\` folder.
- Open a command prompt and type `where airsonos`. The output should look something like:
```
C:\Users\stephen>where airsonos
C:\Users\stephen\AppData\Roaming\npm\airsonos
C:\Users\stephen\AppData\Roaming\npm\airsonos.cmd
```
- Type `airsonos` to run.

Building from source on Windows is not recommended.

Please report issues for this pre-packaged Windows installer here: https://github.com/stephen/airsonos/issues/59

repository: stephen/airsonos

repo_name: stephen/airsonos


text:
# PLCnext Technology compatible container runtimes - Docker, Moby, balenaEngine

[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Web](https://img.shields.io/badge/PLCnext-Website-blue.svg)](https://www.phoenixcontact.com/plcnext)
[![Community](https://img.shields.io/badge/PLCnext-Community-blue.svg)](https://www.plcnext-community.net)

## Project details

|Description   | Value      |
|--------------|------------|
|Created       | 18.02.2020 |
|Last modified | 21.10.2020 |
|Controller    | ALL        |
|Firmware      | 2020.6     |

Hardware requirements:

- AXC F 1152
- AXC F 2152
- AXC F 3152

## Changes for PLCnext firmware 2020.6

- The command "balena-engine exec -it <container> <execute>"  works now
- Integrate `iptables-nft` for automatic firewall configuration
- Publish as APP in [PLCnext Store](https://www.plcnextstore.com/)
- Added in the Setup Docker as selection for installation
- Added Docker-Compose

For the difference between Docker and balenaEngine, see [https://www.balena.io/engine/](https://www.balena.io/engine/)

Known bugs:

- If the firewall is activated in WBM or rules are changed here, the container runtime must be restarted.
- Docker-Compose does not work if the compose file is located directly in */opt/plcnext/*
- Factory reset does not remove application images and cache.

## Install on Target

For installation you need to be root user:

To change to root:

```sh
su
```

To set the password from root

```sh
sudo passwd root
```

For installation:

```sh
# Download the Project
git clone https://github.com/PLCnext/Docker_GettingStarted.git

# Execute Setup.sh in archive
cd Docker_GettingStarted
chmod +x setup.sh
./setup.sh
```

## Hotfix for FW2020.6

After a restart the firewall rules are set incorrectly. For development purposes, the PLCnext firewall can be removed from the autostart. This is adapted in Firmware 2021.0 LTS.

```sh
update-rc.d -f firewall remove
```

## Workaround to fully remove images and cache before/after firmware reset

Login to the terminal, change to root and remove the folder manually

```sh
rm -rf /media/rfs/rw/var/lib/balena
```

## Introduction

The multi-part tutorial provides an introduction to Balena-Engine an IoT focused Docker like container technology on a PLCnext control.

For more Information about Balena-Engine visit the [website](https://www.balena.io/engine/) and the [GitHub project](https://github.com/balena-os/balena-engine).

## License

[balenaEngine](https://github.com/balena-os/balena-engine/blob/master/README.md), [Moby and Docker](https://github.com/moby/moby/blob/master/README.md) are licensed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).

## Roadmap

- With PLCnext Technology **Firmware 2020.0** the AXC controller are **Docker Ready**, this includes a basic set of kernel flags.
- With Firmware 2020.3 there will follow some advanced settings like additional kernel flags and cgroup mounts.
- With Firmware 2021.0 xtables will be part of the image

> The solution for containerization in this tutorial is only for testing and development purposes.
> update could interfere with this solution. Please make sure to backup your images before updating to a new Firmware.

## Before getting started

Please note that the introduction in this series of articles uses:

- Internet-Connection

## Getting Started

In the following series of technical articles, you will install Balena Engine for PLCnext Control and run [OCI container](https://www.opencontainers.org/) on a PLCnext Control.

|\#| Topic | Objectives |
| --- | ------ | ------ |
|[01](getting-started/Part-01/README.md)| [Installation](getting-started/Part-01/README.md)| Install the Balena Engine and run the Balena Container on a PLCnext Control.|
|[02](getting-started/Part-02/README.md)| [Firewall Configuration](getting-started/Part-02/README.md)| How to configure the device firewall for the network access of the container.|
|| [Explore unlimited possibilities ...](getting-started/Part-99/README.md)| Get ideas for other interesting features you can implement in your own PLCnext docker application.|

## How to get support or provide suggestion and ideas

You can get support or provide suggestion and ideas in the forum of the [PLCnext Community](www.plcnext-community.net).

## License

Copyright (c) Phoenix Contact Gmbh & Co KG. All rights reserved.

Licensed under the [MIT](LICENSE) License.


text:
# RuleSchemaFormulaMicroburst

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**if_name** | **str** | Interface name. This should be field name where interface names are being stored |
**packets** | **str** | Queue egress packets. This should be field name where queue egress packets are being stored |
**percentage** | **str** | Queue buffer occupancy percentage. This should be field name where queue buffer occupancy percentage are being stored |
**queue_no** | **str** | Queue numbers. This should be field name where queue numbers are being stored |

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

repository: Juniper/healthbot-py-client

gha_language: Python

repo_name: Juniper/healthbot-py-client


text:
# Concourse
## Installation

Getting connection credentials:
 from bosh-cli:
  - log-credhub
  - credhub g -n /micro-bosh/concourse/local_user

### Spike: embedded version management
We try to replace COA version management by having boshrelease downloaded by bosh director

### Pro
 * allows multiple products with different versions (like concourse 3.14.1 and concourse 5.2)
 * may defined convention to still use `xxx-depls-version.yml` in priority, instead of defining a

### Cons
 * version not enforced by COA

### Issues
[//]: #proxy (TODO Discuss bosh director internet access through proxy)

 * as SNAT is disabled, we need to change bosh director config to allow internet access =>

 ==> workaround manually upload required release
   https_proxy=http://system-internet-http-proxy.internal.paas:3128 curl "https://bosh.io/d/github.com/concourse/concourse-bosh-release?v=5.3.0" -L -o concourse-bosh-release-5.3.0.tgz
   https_proxy=http://system-internet-http-proxy.internal.paas:3128 curl "https://bosh.io/d/github.com/cloudfoundry/postgres-release?v=37" -L -o postgres-release-37.tgz
   https_proxy=http://system-internet-http-proxy.internal.paas:3128 curl "https://bosh.io/d/github.com/cloudfoundry-community/haproxy-boshrelease?v=9.6.0" -L -o haproxy-boshrelease-9.6.0.tgz
   https_proxy=http://system-internet-http-proxy.internal.paas:3128 curl "https://bosh.io/d/github.com/cloudfoundry-incubator/bpm-release?v=1.0.4" -L -o bpm-release-1.0.4.tgz
   bosh upload-release concourse-bosh-release-5.2.0.tgz
   bosh upload-release postgres-release-37.tgz
   bosh upload-release haproxy-boshrelease-9.6.0.tgz

repository: orange-cloudfoundry/paas-templates

branch_name: refs/heads/manual-drop

repo_name: orange-cloudfoundry/paas-templates