text:
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.arpitram/bulkmailer/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.arpitram/bulkmailer)

# Bulk Mail Sender Application

This software requires Java to be installed on your machine. So first check whether java is installed or not in your machine using command :

>java -version

## Requirements

You should have proper SMTP configuration in place in order to send
emails. To test your SMTP server working, run command:

>telnet smtp.host.in 25

Change your SMTP hostname instead of *smtp.host.in* & verify port
*25* as well.

Now, create configuration setting file, eg., config.properties as per your mail server
and provide proper details below:

- fromMailID (From Email ID)
- host (SMTP Server Host name)
- port (SMTP Server Port)
- delayTimeInSec (Delay Time after sending multiple emails as per sent mail count)
- afterSentMailCount (Total sent mails after application should have to wait)
- username (Valid email id / username for authentication purpose)
- password (Valid password for authentication purpose)

You can set **delayTimeInSec** as per your mail server settings or leave it to 0, if
you have no idea. Similarly, when you send bulk mails, it is often
recommended defining mail counts after which application will
wait. So you can define this mail count **afterSentMailCount**. If you
do not have any idea, define 30 or 50 depending upon total mails you are
going to send.

**NOTE :** You should contact your Mail administrator for
these settings.

## Usage :

Use the interface from your application :

```
public static void main(String[] args) {

    try {
        String mailConfigFile = "config.properties";
        java.awt.EventQueue.invokeLater(() -> new SendMailFrame(mailConfigFile).setVisible(true));
    }
    catch (Exception e) {
        e.printStackTrace();
    }
}
```

## Execute application

When you run application on your machine, an interface will be
popped out, and you need to provide following details :

- TO (mandatory): select file containing valid email ids. All email ids should be comma separated or in new line.
- CC (optional): select file containing valid email ids. All email ids should be comma separated or in new line.
- Subject (mandatory): Email Subject Line
- Content (mandatory): Email Content
- Attachment (optional): Optional Attachment file

Supported File Type : Text file (.txt), Excel & CSV

## Mail Status

When all the emails are sent, you will notify with "Mails Sent successfully" message.
In case of any errors, kindly refer to output file.

After a successful message, you may either take backup of output.txt or empty the output.txt file content.


text:
---
title: Share Not Accessible Error
date: 2016-05-21T23:06:00+00:00
author: gerryw1389
layout: single
classes: wide
permalink: /2016/05/share-not-accessible-error/
categories:
  - Networking
tags:
  - FileSystem
---
<!--more-->

### Description:

When trying to access a network resource, you get the following message: `(ShareName or ComputerName) is not accessible`

  <img class="alignnone size-full wp-image-709" src="https://automationadmin.com/assets/images/uploads/2016/09/share-not-accessible.png" alt="share-not-accessible" width="572" height="184" srcset="https://automationadmin.com/assets/images/uploads/2016/09/share-not-accessible.png 572w, https://automationadmin.com/assets/images/uploads/2016/09/share-not-accessible-300x97.png 300w" sizes="(max-width: 572px) 100vw, 572px" />

### To Resolve:

1. These steps will be similiar to [Mapped Network Drive Issues](https://automationadmin.com/2016/05/mapped-network-drives-issues/), but try these steps.

2. First try to ping the computer by IP. Does it work? Try by name if not => you may have a DNS issue at hand.

3. If you can ping successfully, the next step is to make sure both the `Server` and `Workstation` services are running on both the computer requesting the resource (the client) and the computer sharing the resource (the server). To do this:

   - Run => `services.msc` => Navigate to the named services and make sure they are both running. I have seen instances where they were disabled for some reason.

4. Next, click Start => Credential Manager (in search bar) => Add a Windows credential => Add the host name of the server, the user name and password to connect into it.

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
[back to summary](summary.md)

##Modal Selector Directive
------------------------------------------------------------------------
Modal selector is a bootstrap modal implementation with single or multiple selection through table factory.
Html syntax is:

```html
<ng-modal-selector show="=" items="=" single="=?" title="=?" display-field="@" value-field="@" additionals="=?" ng-model="=">
```

###show
(Boolean) Boolean object used to control the modal, when value is true the modal is shown

###items
(Array of Object) Items attribute is the data source of data table in the modal

###single
(Boolean) When true the selection is single row, otherwise multiple (default true)

###title
(String) Title of the modal window

###display-field
(string) Property name of object in items array with value to display in modal

###value-field
(string) Property name of object in items array with value to return through ng-model directive

###additionals
(Array of Object) Objects array of type { field:'', width:'' } to show additional column in the table modal.
Property 'field' is the property name of items array, 'width' is the width of the column, in css string.

###ng-model
The angular proprietary directive ng-model is used to save modal selection

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

[back to top](#modal-selector-directive) - [back to summary](summary.md)

repository: feiman/tablefactory

branch_name: refs/heads/master

repo_name: feiman/tablefactory


text:
## NATS Data Interface

The *nats* data interface can be used to connect the NATS resources you have set up on the edge to Karbon Platform Services. To start setting up this datasource, use the following example YAML and create your data source via the Karbon Platform Services CLI.

**nats.yaml**
```yaml
kind: dataSource
name: ex_nats
svcDomain: <Service Domain>
protocol: DATAINTERFACE
type: Sensor
authType: CERTIFICATE
ifcInfo:
  class: DATAINTERFACE
  img: registry.hub.docker.com/xiiot/nats:v1.0
  kind: IN
  protocol: nats
  ports:
    - name: nats
      port: 4222
edge: myprovideredge
fields:
- name: topic
  topic: "<Device Topic>"
- name: host
  topic: "natshost-x.x.x.x"
- name: port
  topic: "natsport-4222"
```

**Note:** Your *Device Topic* is the NATS address your device communicates with.

Run the following command to create an instance of the datasource:
```console
kps create -f nats.yaml
```
* If the yaml was configured correctly, you should now see a datasource in your UI called *ex-nats*.
* This device can now be leveraged as a data source in entities such as Kubernetes Applications and Data Pipelines.

### Litmus Edge

The NATS data interface can also be used to integrate with [Litmus Edge](https://litmus.io/litmus-edge/) to enable a wide range of [device and protocol data sources](https://litmus.io/litmus-edge/supported-devices/) with minor adjustments.
The following YAML file is configured to connect with Litmus Edge.

**litmus.yaml**
```yaml
kind: dataSource
name: litmus
svcDomain: <Service Domain>
protocol: DATAINTERFACE
type: Sensor
authType: CERTIFICATE
ifcInfo:
  class: DATAINTERFACE
  img: registry.hub.docker.com/xiiot/litmus:v1.0
  kind: IN
  protocol: nats
  ports:
    - name: nats
      port: 4222
edge: myprovideredge
fields:
- name: secret
  topic: "<LoopEdge Secret>"
- name: host
  topic: "natshost-<LoopEdge IP>"
- name: port
  topic: "natsport-4222"
```

If your LoopEdge information was configured correctly, your device names and topics should now be in the cloud as artifacts.
To see your newly created artifacts run the following command:
```console
kps get datasource --show-artifacts
```

You should be met with a row entry labelled *litmus*. Inside this row entry you should see a list of your device tags and corresponding device topics:
```console
NAME         	ENDPOINTS                                             CLIENT SECRET
litmus        	<names>:
              		devicehub.raw.<topic>.*
                <names>:
               		devicehub.raw.<topic>.*
```

Proceed to add required device topics directly in the Karbon Platform Services UI. Proceed to **Infrastructure** → **Data Sources** and click on *litmus*.
Select **Edit** and you should be brought to a menu where you can define your data source topics. You should see your some topics such as port and secret already present. Now you
can add the device topic of your choice and select **Update**.
* Once you have updated your data source, you will start ingesting data from your selected device and use this entity in Kubernetes Applications and Data Pipelines.

## NATS FAQs

What happens if a device topic is removed and a new one added?
* The stream will be immediately cancelled and the data source will start ingesting data from the new device topic.

Can topics from multiple devices be added to the same Karbon Platform Services data source?
* No, it is recommended to create multiple data sources for each unique device topic. External gateway devices or software (like Litmus Edge) may also be used to aggregate data from multiple sources.

Is there a way to ingest multiple device and protocol (i.e. PLC) sources as one Karbon Platform Services data source?
* Yes, multiple devices can be configured under one device topic in Litmus Edge.

repository: heiko-koehler/xi-iot

gha_license_id: MIT

repo_name: heiko-koehler/xi-iot


text:
---
layout: index
title: dynamictemplate element
---

    <dynamictemplate name="name">expression</template>

A dynamictemplate is used in a similar way as [template](template.html), except that its value is an expression, not a static string. The expression will have access to an object called "object", which you can use to craft a response.

You can print a dynamic template using the [DynamicTemplate](../functions/dynamictemplate.html) function. This takes an object or text parameter, which is then passed in to the template expression.

repository: textadventures/quest

gha_language: C#

repo_name: textadventures/quest


text:
---
layout: twoColumn
section: home
type: "Technology Stack"
title:  "Off-the-shelf HATs"
description: "Off-the-shelf HATs"
weight: 9
---

# HATs on Demand

If you are an organisation needing to deploy X HATs to conduct a survey, or to collect individual's data in a privacy preserving way, You can commission a short term provisioning of HATs e.g. yourusersname.hubofallthings.net to do so.

HATs can also be available to purchase 'off-the-shelf' at [HATTERS](https://hatters.hubofallthings.com).

repository: ireneclng/open-source-developer-portal

repo_name: ireneclng/open-source-developer-portal


text:
[![NPM version](https://badge.fury.io/js/spam-detector.svg)](http://badge.fury.io/js/spam-detector)
[![build status](https://secure.travis-ci.org/Planeshifter/node-spam-detector.png)](http://travis-ci.org/Planeshifter/node-spam-detector)

node-spam-detector
======================

This little module exposes a single function which can be used to check whether a given URL is considered spam after consulting several major domain blacklists. Under the hood, the function first uses the `unshortener` package to
reduce the URL to its original form in case that it was shortened. It then makes DNS calls to blacklists provided by URIBL, Spamhaus and SURBL.

## Installation & Loading

The module can be easily installed via npm:

```
npm install spam-detector
```

To use it in a project, require the package with the command

```
isSpam = require("spam-detector");
```

## Syntax

### isSpam(url, callback)

The function has two parameters: The first is the URL which has to be checked, and the second is a callback function of the form `function(err, data)`. The first argument `err` is equal to `null` if no error has occured during checking and an Error object otherwise. The second argument is a Boolean value which evaluates to `true` in case that the supplied URL is considered to be spam and `false` otherwise.

Example:

```
var isSpam = require("spam-detector");
isSpam("http://www.github.com", function(err, data){
console.log(data);
});
```

Output:

```
false
```

repository: Planeshifter/node-spam-detector

repo_name: Planeshifter/node-spam-detector


text:
# Test-Driven iOS Development with Swift 3
This is the code repository for [Test-Driven iOS Development with Swift 3](https://www.packtpub.com/application-development/test-driven-ios-development-swift-3?utm_source=github&utm_medium=repository&utm_campaign=9781787129078), published by Packt. It contains all the supporting project files necessary to work through the book from start to finish.
## Instructions and Navigations
All of the code is organized into folders. Each folder starts with a number followed by the application name. For example, Chapter02.

The code will look like the following:
```
func makeHeadline(string: String) -> String {
 return "This Is A Test Headline"
}
```

The following hardware and software is needed to follow the code examples in the book:
Mac with Sierra (MAC OS 10.12)
Xcode 8

## Related Products
* [Test-Driven iOS Development with Swift](https://www.packtpub.com/application-development/test-driven-ios-development-swift?utm_source=github&utm_medium=repository&utm_campaign=9781785880735)

* [Swift: Developing iOS Applications](https://www.packtpub.com/virtualization-and-cloud/swift-developing-ios-applications?utm_source=github&utm_medium=repository&utm_campaign=9781787120242)

* [Learning iOS 8 Game Development Using Swift](https://www.packtpub.com/game-development/learning-ios-8-game-development-using-swift?utm_source=github&utm_medium=repository&utm_campaign=9781784393557)
### Suggestions and Feedback
[Click here](https://docs.google.com/forms/d/e/1FAIpQLSe5qwunkGf6PUvzPirPDtuy1Du5Rlzew23UBp2S-P3wB-GcwQ/viewform) if you have any feedback or suggestions.


text:
Getting started

Run ./gradlew (or gradlew.bat on Windows) to create Eclipse project,
get all dependencies, build the code and run the tests.

To see which tasks are available, run ./gradlew tasks

repository: henkir/luncher

repo_name: henkir/luncher


text:
ember_front_end
===============

Basic Front End CRUD in Ember.js built using Ember-Tools

First Make sure you have Ember Tools installed

`npm install -g ember-tools`

Next clone the repository and change directories to the root of the project:

`git clone git@github.com:sakoh/ember_front_end.git`

To compile Ember templates and javascript files, run the command:

`git clone git@github.com:sakoh/ember_front_end.git`

Next to compile the file:

`ember build`

To track changes as you build:

`ember build -w`

Warning
-------

There could be a namespace collision if you try to install ember tools if you have installed ember-cli. To avoid the namespace collision:

create a bash_profile script from your computer root:

`sudo nano ~/.bash_profile`

and inside the bash profile create alias for ember-tools and ember-cli respectively:

`alias ember-cli="~/.node/lib/node_modules/ember-cli/bin/ember"`

`alias ember-tools="~/.node/lib/node_modules/ember-tools/bin/ember"`

then run the bash profile with `. .bash_profile` for Mac or `./.bash_profile` for linux.

next run `ember-tools --help` to see if works. you should see:

`$ ember-tools --help

  Usage: ember [command] [options]

  Command-Specific Help

    ember [command] --help

  Commands:

    create [options]       creates a new ember application at [dir]
    build [options]        compiles templates and builds the app
    watch
    generate [options]     generates application files
    precompile [options]   precompile templates from src dir to target dir
    update [version]       Update ember.js from ember's s3 build service to [version].
    			   Versions are latest(built from master, bleeding edge) and stable.
    			   Default version is stable.

`


text:
# WallabyExample

This is a sample app for a
[talk](https://www.meetup.com/ChicagoElixir/events/237255274) I'm giving at the
[Chicago Elixir Meetup](https://www.meetup.com/ChicagoElixir).

The goal of this application is to demonstrate an integration test with Phoenix and Wallaby.
The test:

- Visits users index page
- Asserts we are on the users index page
- Clicks a link to create a new user
- Asserts we are on the user form
- Fills in the form
- Submits the form
- Asserts we are on the users index page
- Asserts our new user is there

### Slides

The slides for this talk are available [here](https://github.com/jwworth/talks/tree/master/integration-testing-phoenix-with-wallaby).

### Setup

To start your Phoenix app:

  * Install dependencies with `mix deps.get`
  * Create and migrate your database with `mix ecto.create && mix ecto.migrate`
  * Install Node.js dependencies with `npm install`
  * Start Phoenix endpoint with `mix phoenix.server`

Now you can visit [`localhost:4000`](http://localhost:4000) from your browser.

### Contributing

1. [Fork](https://help.github.com/articles/fork-a-repo/) it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

Bug reports and pull requests are welcome on GitHub at
https://github.com/jwworth/wallaby_example.

### License

This application is released under the [MIT License](http://www.opensource.org/licenses/MIT).


text:
# Codegen

## Table of contents
- [Introduction](#introduction)
- [The rules of codegen](#the-rules-of-codegen)
- [Basic structure](#basic-structure)
    - [General](#general)
    - [Language-specific](#language-specific)
- [Codegen sections](#codegen-sections)
    - [JSON Schema](#json-schema)

## Introduction

The need of input validation requires using json schemas. But json schemas allow for more than that. Since they describe the shape of serializable data which can be expressed by interfaces, the interfaces can be derived from them too (which can be implemented as classes). All of that can be done manually as the need arises for sure, but manual approach is prone to errors and gets hard to keep track of and synchronize changes due to indirect relation between json schema files and the code using them. Therefore it is better to have a system which derives the needed code from the schemas.

## The rules of codegen
- **no runtime codegen**

    Because generated code can be quite verbose and complicated, it is pretty hard to debug the code which isn't expressed in the source files. And runtime code can't be statically analyzed consistently either so it's also a security issue.

- **no production codegen**

    Because production environment deals with real data and the code generated will inevitably manipulate it in some way with no easy way to revert, there must be not production-only codegen.

- **no automatic codegen**

    The developer has to initiate a command to update the generated code. If there is a system which can detect the desync, it has to log a warning along with the instructions on how to update.

- **all generated code is checked into the repo**

    This one allows to automatically check for consistency. Given the same input the codegen has to produce the same output and any difference is human error (i.e. the person comitting the code edited the output) or malicious intent.

Because almost all these points deal with security one way or another, it might give an impression that codegen is some sort of security hazard. But it's only due to its nature of creating arbitrary code in a server language. It is no more insecure than adding a 3rd-party dependency.

## Basic structure

### General
The codegen consist of 2 parts:

- codegen folder
- codegen lib

#### Codegen Folder

This is the folder where all generated code resides. This folder is further separated into codegen modules of this structure:

- generator file

    A file which exports a generator function with no arguments which returns a string of the code generated.

- result file

    A file into which generated string is written into

- index file

    If the language supports re-exports, the generated symbols are re-exported there.

For the folder to count as a codegen module, the generator file must be present. Codegen modules cannot have nested codegen modules within them.

#### Codegen Lib

This library is responsible for analyzing, formatting and writing the generated code. Its module can export whatever number of symbols to help wtih code generation, but has to export a function with this signature:
```typescript
async function runCodegen(): string[]
```

This function walks the `codegen folder` and performs these operations in a `codegen module`:
1. Runs the generator.
2. The resulting string then formatted and written to the `result file`.
3. `index file` is created and populated.
4. The folder path is added to the list of paths.

### Language-specific

#### Javascript
- folder: `/webapp/src/codegen`
- module:
    - index file: `_index.ts`
    - generator: `generator.ts`
    - result file: `result.ts`
- command: `npm run codegen`

#### Golang
- folder: `/cli/src/codegen`

    For now it lives within the `cli` until the structure for shared packages is figured out.

- module
    - generator: `generator.go`
    - result file: `exports.go`

    Golang doesn't seem to support re-exports so the result file is also an index file.

- command: `./horahora codegen`

## Codegen sections

These are sections all target language codegens have to implement.

### JSON Schema

- Schema folder - `/schema`
- Schema file ending - `.schema.json`

JSON schema codegen has to travel in the `schema folder` and for each `schema file` export these things:
- an interface of the target JSON
- an immutable variable storing the parsed version of schema
- a function to validate the target JSON

As an example Typescript generated exports would look like this:
```typescript
export interface IMeta {...};
export const metaSchema = {...} as const;
export function validateMeta(inputJSON: unknown): inputJSON is IMeta;
```

repository: horahoradev/horahora

gha_language: Go

repo_name: horahoradev/horahora


text:
___  ___ _____
|  \/  |/  __ \
| .  . || /  \/
| |\/| || |
| |  | || \__/\
\_|  |_/ \____/
_______________

This is the Management Console WAR project, this readme is pretty much for copy/pasting commands.

To watch changes to coffeescript and jade files do:

* mvn brew:compile -Dbrew.watch=true

in the fmc-webui directory. If you make changes to the backend stuff (any of the scala, etc) you can rebuild using:

* mvn compile war:exploded bundle:manifest

which will rebuild the exploded war file.

Note that since the bundle is fully redeployed whenever a file in the exploded war is updated you'll run into OOM PermGen issues, so might be worth bumping that up.

* JAVA_OPTS="-XX:PermSize=64m -XX:MaxPermSize=512m ./bin/fmc

With debug enabled:

* JAVA_OPTS="-XX:PermSize=64m -XX:MaxPermSize=512m -Xmx2G -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005" ./bin/fmc

repository: kpelykh/fuse

repo_name: kpelykh/fuse


text:
# no-typed-global-store

The global store should not be typed.

- **Type**: suggestion
- **Recommended**: Yes
- **Fixable**: No
- **Suggestion**: Yes
- **Requires type checking**: No
- **Configurable**: No

<!-- Everything above this generated, do not edit -->
<!-- MANUAL-DOC:START -->

## Rule Details

Typing the global `Store` is redundant because selectors are type-safe, so adding the generic state interface while injecting the store is unnecessary.
Providing the wrong type can also result in unexpected type-related problems. See [discussion](https://github.com/ngrx/platform/issues/2780) for more info.

To prevent a misconception that there are multiple stores (and even that multiple stores are injected into the same component, see [`no-multiple-global-stores`](guide/eslint-plugin/rules/no-multiple-global-stores)), we only want to inject 1 global store into components, effects, and services.

Examples of **incorrect** code for this rule:

```ts
export class Component {
  data$ = this.store.select(data);

  constructor(private readonly store: Store<{ data: Data }>) {}
}
```

Examples of **correct** code for this rule:

```ts
export class Component {
  data$ = this.store.select(data);

  constructor(private readonly store: Store) {}
}
```


text:
# kitchen-vra

A driver to allow Test Kitchen to consume vRealize Automation (vRA) resources to perform testing.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'kitchen-vra'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install kitchen-vra

Or even better, install it via ChefDK:

    $ chef gem install kitchen-vra

## Usage

After installing the gem as described above, edit your .kitchen.yml file to set the driver to 'vra' and supply your login credentials:

```yaml
driver:
  name: vra
  username<EMAIL_ADDRESS>  password: mypassword
  tenant: mytenant
  base_url: https://vra.corp.local
  verify_ssl: true
```

If you want username and password to be prompted, remove usename and password in your .kitchen.yml as shown below:

```yaml
driver:
  name: vra
  tenant: mytenant
  base_url: https://vra.corp.local
  verify_ssl: true
```
If you don't want to explicitly specify username and password in the kitchen.yml, you have an option to set it in the environment variable as

    $ export<EMAIL_ADDRESS>    $ export VRA_USER_PASSWORD='mypassword'

Then configure your platforms. Either a catalog_id or a catalog_name is required for each platform. If both catalog_id and catalog_name are mentioned in .kitchen.yml then catalog_name would be used to derive the catalog_id and this catalog_id would override the catalog_id being passed in .kitchen.yml. In the below example as can be seen we are using catalog_id for centos6 driver while catalog_name for the centos7 driver just to demonstrate that we can use either of the two.

```yaml
platforms:
  - name: centos6
    driver:
      catalog_id: e9db1084-d1c6-4c1f-8e3c-eb8f3dc574f9
  - name: centos7
    driver:
      catalog_name: my_catalog_name
```

Other options that you can set include:

 * **lease_days**: number of days to request for a lease, if your catalog item / blueprint requires it
 * **request_timeout**: amount of time, in seconds, to wait for a vRA request to complete. Default is 600 seconds.
 * **server_ready_retries**: Number of times to retry the "waiting for server to be ready" check. In some cases, this will error out immediately due to DNS propagation issues, etc. Setting this to a number greater than 0 will retry the `wait_until_ready` method with a growing sleep in between each attempt. Defaults to 1. Set to 0 to disable any retrying of the `wait_until_ready` method.
 * **cpus**: number of CPUs the host should have
 * **memory**: amount of RAM, in MB, the host should have
 * **shirt_size**: This parameter corresponds to shirt size option of vRA available on blueprint like ValueSet.Large, ValueSet.Small etc. As shirt size is a combination of memory and RAM, hence while using this no need to use cpus and memory parameter. This shirt size option helps in standardizing the sizing available for end users
 * **requested_for**: the vRA login ID to list as the owner of this resource. Defaults to the vRA username configured in the `driver` section.
 * **subtenant_id**: the Business Group ID to list as the owner. This is required if the catalog item is a shared/global item; we are unable to determine the subtenant_id from the catalog, and vRA requires it to be set on every request.
 * **subtenant_name**: the Business Group Name as the owner. This can be passed instead of subtenant_id and would act as a more friendly name. subtenant_id would be internally retrieved based on the provided subtenant_name. In case both subtenant_id and subtenant_name are passed, subtenant_name would take the precendence and would try to retrieve subtenant_id based on subtenant_name passed.
 * **private_key_path**: path to the SSH private key to use when logging in. Defaults to '~/.ssh/id_rsa' or '~/.ssh/id_dsa', preferring the RSA key. Only applies to instances where SSH transport is used; i.e., does not apply to Windows hosts with the WinRM transport configured.
 * **use_dns**: Defaults to `false`.  Set to `true` if vRA doesn't manage vm ip addresses.  This will cause kitchen to attempt to connect via hostname.
 * **dns_suffix**: Defaults to `nil`.  Set to your domain suffix, for example 'mydomain.com'.  This only takes effect when `use_dns` == true and is appended to the hostname returned by vRA.
 * **extra_parameters**: a hash of other data to set on a catalog request, most notably custom properties. Allows updates to existing properties on the blueprint as well as the addition of new properties. Each key in the hash is the property name, and the value is a another hash containing the value data type and the value itself. It is possible to use a `~` to add nested parameters.

These settings can be set globally under the top-level `driver` section, or they can be set on each platform, which allows you to set globals and then override them. For example, this configuration would set the CPU count to 1 except on the "large" platform:

```yaml
driver:
  name: vra
  cpus: 1

platforms:
  - name: small
    driver:
      catalog_name: my_catalog_name_small
      catalog_id: 8a189191-fea6-43eb-981e-ee0fa40f8f57
      extra_parameters:
        mycustompropname:
          type: string
          value: smallvalue
        Vrm.DataCenter.Location:
          type: string
          value: Non-Prod
  - name: large
    driver:
      catalog_name: my_catalog_name_large
      catalog_id: 1d7c6122-18fa-4ed6-bd13-8a33b6c6ed50
      cpus: 2
      subtenant_name: my_subtenant_name
      extra_parameters:
        mycustompropname:
          type: string
          value: largevalue
        Vrm.DataCenter.Location:
          type: string
          value: Prod
```

## License and Authors

Author:: Chef Partner Engineering<EMAIL_ADDRESS>
Copyright:: Copyright (c) 2015-2019 Chef Software, Inc.

License:: Apache License, Version 2.0

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

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

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

## Contributing

We'd love to hear from you if this doesn't work in your vRA environment. Please log a GitHub issue, or even better, submit a Pull Request with a fix!

1. Fork it ( https://github.com/chef-partners/kitchen-vra/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

repository: sanjain-progress/kitchen-vra

repo_name: sanjain-progress/kitchen-vra


text:
---
layout: post
title: "AS3 Pixel Conversion Utils"
categories: util
---

Flash programmers are not used to bitwise operations. Period.

Even though, such operations are indeed very important in ActionScript3. For example, pixel components (red, green, blue and alpha) are commonly packed into a 32 bits unsigned integer - see [BitmapData's official documentation](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/BitmapData.html).

To lend you a hand, I created a simple static class (Pixel class) which provides ways to convert pixels stored in uints to higher level structures like Arrays/Objects and vice versa.

Usage:<br>

	var sourceArray:Array; // source pixel as an array
	var sourceObj:Object;  // source pixel as an object
	var sourcePixel:uint;  // source pixel as an unsigned integer

	// 24 bits pixel conversion - RGB format
	var uintFromArray:uint = Pixel.arr2int(sourceArray);
	var uintFromObject:uint = Pixel.obj2int(sourceObj);
	var arrayFromUint:Array = Pixel.int2arr(sourcePixel);
	var objectFromUint:Object = Pixel.int2obj(sourcePixel);

	// 32 bits pixel conversion - ARGB format
	var uintFromArray32:uint = Pixel.arr2int32(sourceArray);
	var uintFromObject32:uint = Pixel.obj2int32(sourceObj);
	var arrayFromUint32:Array = Pixel.int2arr32(sourcePixel);
	var objectFromUint32:Object = Pixel.int2obj32(sourcePixel);

	// 24 bits examples
	var result1:uint = Pixel.arr2int([0xff, 0xcc, 0x88]);
	var result2:uint = Pixel.obj2int({r: 150, g: 100, b: 50});
	var result3:Array = Pixel.int2arr(0xff00ff);
	var result4:Object = Pixel.int2obj(0x00ffcc);

	// 32 bits examples
	var result5:uint = Pixel.arr2int32([0xff, 0xff, 0xcc, 0x88]);
	var result6:uint = Pixel.obj2int32({a: 80, r: 150, g: 100, b: 50});
	var result7:Array = Pixel.int2arr32(0xffff00ff);
	var result8:Object = Pixel.int2obj32(0xbb00ffcc);

The requeriments of using Arrays as source pixels are at least 3 elements for 24 bits and at least 4 elements for 32 bits.
And for Objects the members 'r', 'g' and 'b' must exist for 24 bits and 'a', 'r', 'g' and 'b' must exist for 32 bits.

Check Pixel class gist [here](https://gist.github.com/loteixeira/5637721).


text:
### How to deploy Genie applications

In this guide we will walk through how to deploy a Genie App to Amazon Cloud. This article will be added with more information in future.

### Prerequisite:
* Genie Application with ready Dockerfile(Refer to Genie Docker Tutorial)
* Opened account in main cloud providers

That’s it, from this point we can start with deployment.

## AWS

### Networking

The easiest and quickest to deploy and expose Genie applications is to create a EC2 instance and run docker container inside it.

After opening an AWS console you should be able to see your network under VPC tab. This is default one, and we’ll use it for hosting our EC2 instance.

![network-vpc](../assets/Deploying_Genie_Apps_On_AWS/1_network_tab.png)

This VPC already contains a predefined subnets. We need a public subnet as we should access our Application via Internet.

![subnet](../assets/Deploying_Genie_Apps_On_AWS/2_subnet.png)

Great, let’s move on.

### Setup EC2 instance

Navigate to EC2 tab in AWS Console and then click on “Launch instances“.

![launch-instance](../assets/Deploying_Genie_Apps_On_AWS/3_launch_instance.png)

We will use a Free Tier Amazon  Linux 2 AMI image. It can fit our needs for this demo

![free-tier](../assets/Deploying_Genie_Apps_On_AWS/4_free_instance.png)

For an Instance type lets choose t2.small, in that case we’ll get 1vCPU and 2Gb Memory. We should have enough memory with this instance to meet our application requirements. Also we should allow HTTP & HTTPS access. For SSH let’s specify your IP or let <IP_ADDRESS>/0 with is allows connect to this instance from everywhere (not secure). Also double check that “Auto-assign public IP“ is enabled.

![instance-conf](../assets/Deploying_Genie_Apps_On_AWS/5_instance_conf.png)

Click on "Launch instance". It’ll take around 2min and we can proceed.

![launch-instance](../assets/Deploying_Genie_Apps_On_AWS/6_launch_instance.png)

Ok, now our Instance is Running and have a public IP.

### Setup Docker on EC2

Now let’s connect to is and install a docker. Here is the command to connect via SSH. Please change this IP by yours.

```
ssh -i my-demo-app.pem<EMAIL_ADDRESS>```

Let’s Install Docker on it, it’s pretty easy, just execute next commands:

```
sudo yum update
sudo yum install docker -y
sudo usermod -a -G docker ec2-user
id ec2-user
newgrp docker
sudo systemctl enable docker.service
sudo systemctl start docker.service
```

Now we can verify that our docker was installed and runs successfully

```
sudo systemctl status docker.service
```

For more information you can check this [guide](https://www.cyberciti.biz/faq/how-to-install-docker-on-amazon-linux-2/). Amazing, basically that’s it, now we can deploy our application.

Let’s clone repository with our applications and Dockerfile to EC2. If git is not installed on EC2 just execute

```
sudo yum git install -y
# And clone your git repo
git clone <your-repo.git>
cd <your-repo>
```

### Building a Genie Application

First of all let’s build our app using docker cli

```
docker build -t my-demo-app .
docker images
```

If build was successful your should be able to see docker image. Now let’s just start it. In our case application works on port 8000, so we did a port-mapping to port 80.

```
docker run -p 80:8000 my-demo-app
```

Then just grep a public IP from AWS console and open it in your browser.

![deployed-app](../assets/Deploying_Genie_Apps_On_AWS/7_aws_app.png)

That’s it, your application was successfully deployed. Thanks.

gha_language: Julia


text:
# smart_cities_schemas
Desription:
The project contains schemas describing meta-information for various deployed
data sources (sensors/actuators, devices, virtual sensors etc.). The schemas
are described in json-schema format.
Resource catalog stores the information about each device (also referred to
as catalog item). The structure of information contained in each item is specified
by a json-schema (specified in this project). Apart from specifying a structure of
the catalog item, the schemas are also used to validate this item before storing
into the catalog using json-schema validator tools.

Directory structure:

Base directory contains all the schema files and the associated definition files.

Schema-list.txt:
Contains the list of all the schema files along with the tags
to help a user choose the right schema for its device.

./example_items:
This directory contains sample items for various devices
./skeleton_items:
This directory contains the skeleton_item files for each json schema.
A skeleton item contains the minimum required number of fields for a given schema
(mandatory fields). These files are provided to help a user create its own device item
using a given skeleton file as a start point.

repository: rbccps-iisc/ideam-poc-ui

repo_name: rbccps-iisc/ideam-poc-ui


text:
# config-yourself-python

[![Test status](https://github.com/blinkhealth/config-yourself-python/workflows/Tests/badge.svg)](https://github.com/blinkhealth/config-yourself-python/actions?query=branch%3Amaster+event%3Apush)
[![Documentation Status](https://readthedocs.org/projects/config-yourself-python/badge/?version=latest)](https://config-yourself-python.readthedocs.io/en/latest/?badge=latest)
[![Coverage Report](https://codecov.io/gh/blinkhealth/config-yourself-python/branch/master/graph/badge.svg)](https://codecov.io/gh/blinkhealth/config-yourself-python)

`config-yourself` is a python 2.7+ package to help your application read [go-config-yourself files](https://github.com/blinkhealth/go-config-yourself#config-files).

---

## Installation

```sh
# choose if you'd like to use `kms`, `gpg` or the `password` provider
pip install 'config_yourself[kms]'

# or go crazy with all of them
pip install 'config_yourself[all]'

# with pipenv
pipenv install 'config_yourself[kms]'

# with poetry
poetry add config_yourself --extras kms
```

## Usage

Here's how to work with `config_yourself` in python:

## Basic usage

```py
import config_yourself as cy

# Load one config file
encrypted_config = cy.load.file("config/test.yml")
config = cy.Config(encrypted_config)
# now use it like a dict, all secrets have been decrypted
print(config["database"])
```

## Complete usage

```py
# Let's get a little more creative
# `config_yourself` can take a number of config files, merge, and decrypt them

# we start with a defaults file, that defines the valid keys for all subsequent files
# then, we take a file path provided from the environment
files = ['config/defaults.yml', os.environ['CONFIG_FILE']]

# During development, we might choose to have a SCM-ignored personal file, to apply overrides to our personal taste
if os.path.exists(personal_config_path):
  files.append('config/personal.yml')

# we take every file, deserialize it from YAML
configs = [cy.load.file(path) for path in files]
# we can also append regular dicts to this list
configs.append({
  'MODE': os.environ.get('BACKEND_MODE', 'tripolar')
})

# we can also decide to override values straight from the environment...
if os.environ['SHOOT_MYSELF_IN_THE_FOOT']:
  # config_yourself will parse env values as JSON, so this will turn to False
  os.environ['CONFIG.someService.enabled'] = 'false'
  configs.append(cy.load.env('CONFIG'))

# Take our list of configs, and pass secrets to the decryption provider
config = cy.Config(*configs, secrets={'password': os.environ['SUPER_SECRET_PASSWORD']})
# The resulting merged config is finally decrypted

print(config['someService']['endpoint']) # => "https://super-secure-service.example.com"
print(config['someService']['enabled']) # => False
```

### From a Django or Flask application

When using in Flask or Django and you'd like to follow the same pattern above, use the :py:meth:`~config_yourself.AppConfig` method instead:

```py
import config_yourself as cy

# Use AppConfig
config = cy.AppConfig()
# functionally equal to:

# Remember to set CONFIG_FILE=./config/production.yml
cy.Config(**[
  "./config/defaults.yml",
  "./config/production.yml",
])

# assuming CONFIG_FILE="" and an existing "personal.yml" file
cy.Config(**[
  "./config/defaults.yml",
  "./config/local.yml",
  "./config/personal.yml",
])
```

repository: blinkhealth/config-yourself-python

gha_language: Python

gha_license_id: NOASSERTION

repo_name: blinkhealth/config-yourself-python


text:
# 1D Heat Stencil

## Introduction

The 1D Heat Stencil code calculates the heat distribution in a 1D domain. The heat source is a fixed point, which remains on the same temperature for the whole calculation. To evaluate the new temperature value for a given point only the direct neighbours are considered. The original code is fetched from [Introduction to parallel computing and parallel algorithms](https://github.com/philippgs/uibk_ipcpa_19).

## Prerequisites

- Boost 1.68
- OpenMPI 4.0.0
- HipSYCL
- C++ 17 compiler
- Celerity

## Required input parameters

Expected input: `./[file_name] timesteps length [optional parameters]`

1. timesteps: defines the number of timesteps executed
2. length: defines the length of the stencil

## Optional input parameters

- -s

  Enables the check against the sequential computation (This can increase runtime drastically if length and time steps are high).

- -d

  Enable simulation. After each 100 time steps the current heat distribution is printed to the standard output.

- -p

  Enable printing. This will print the result array to the standard output. If the sequential check is enabled both arrays will be printed. The print will only be executed if the verification is successful.

- -pr

  Enable progression. This will print the current progression of the sequential computation. If enabled the time measurement for the sequential computation will be affected.

## Contributors

- Pernecker Ralf
- Wald Linus

repository: waldlinus/Celerity-Benchmarks

repo_name: waldlinus/Celerity-Benchmarks


text:
# Nbdev tutorial of the tutorial
> Supertutorial of the tutorial for nbdev :D

This is mainly a guide for me to follow during my live tutorial and, at the same time, get familiar with nbdev while writing it.

## Install

`pip install nbdev_metatuto`

## How to use

We can't really screw anything up. There is only one function and one class so far:

```python
say_hi("Bitz")
```

    'Hii Bitz!'

```python
ss = SoothSayer("Emilio")
ss.say()
```

    'Hii Emilio!'

gha_language: Jupyter Notebook


text:
# TUYA-V1.0
This project is developed using Tuya SDK, which enables you to quickly develop branded apps connecting and controlling smart scenarios of many devices.
For more information, please check Tuya Developer Website.

![界面](https://user-images.githubusercontent.com/82811682/115402259-d7034880-a21d-11eb-85f4-6aa1690648f9.jpg)


text:
# Kronecoin

Kronecoin is just another cryptocoin.
Scrypt minable (CPU, GPU) with 84.000.000 max coins .
Minable with old hardware was created for grant access to everyone in the cryptocurrencies world

This repo contains the source code.

#How to mine Kronecoin

To mine Kronecoin you can use a CPU miner (minerd for linux, bfgminer for Mac and Windows) and connect to http://kronepool.org or set up your minining pool using this repo : https://github.com/UNOMP/node-merged-pool or ask to your Mining pool to add Krone

#How to store coins

The simplest way to store coins is the Desktop Wallet for Linux, Mac, Windows
=======

Kronecoin is just another cryptocoin.
Scrypt minable (CPU, GPU) with 84.000.000 max coins .
Minable with old hardware was created for grant access to everyone in the cryptocurrencies world

This repo contains the source code.

repository: Olaur/Kronecoin

repo_name: Olaur/Kronecoin


text:
---
path: "/blog/dhamma"
title: Dhamma
author: Min Aung
date: 2010-01-02
hero: ./images/hero.png
excerpt: This page is devoted to Dhamma.
---
[DarNaTaYar](https://www.learnteachcenter.com/files/DarNaTaYar1.pdf)

#### How to eradicate sufferings layer after layer
<br />

1 One Authentic Training School
  * [1.1 Vipassana International Academy](http://www.dhamma.org/en/schedules/schgiri.shtml)(Practice)
  * [1.2 Vipassana Research Institute](http://www.vridhamma.org/Home.aspx) (Theory)
  * [1.3 World Peace (Speech By S N Goenka in U.N. Peace Summit ( Part 1 ))](http://www.youtube.com/watch?v=5ak5K4M3X2c&feature=related)
  * [1.4 World Peace (Speech By S N Goenka in U.N. Peace Summit ( Part 2 ))](http://www.youtube.com/watch?v=4zMUIGI2yRM)

2 [Reverend Maharsi Sayardaw U Saw Bana and U Zawana (Now Chanmyay Sayardaw)](https://www.youtube.com/watch?v=_U7TtSeOlG4)

repository: noblesilence/Learn-Teach-Center

gha_language: JavaScript

repo_name: noblesilence/Learn-Teach-Center


text:
# File Generator

A very basic and dirty implementation of a Finder extension that adds a "New File" menu item to Finder's context menu.
I know this code is very unprofessional but I've never had the time to fix this…

Feel free to modify this code and redistribute it.

![alt text](Preview.jpg)

## License

This project is licensed under the MIT License - see the [License.md](License.md) file for details

repository: mtjo/File-Generator

repo_name: mtjo/File-Generator


text:
---
layout: page
title: /about
permalink: /about/
---

# Hila Shmuel
I have Bsc in **Computer science**, which I studied for during high school. I recently completed another Bsc in **Math & Physics**, just because I like it, and I think that a good solid mathematical background is a must for every person who identifies itself as a great thinker.
 I love to solve riddles on my free time, read books (I’m a Harry Potter fan), and code.
This blog mainly exists as a way to document my thoughts during the process of solving problems and making projects.
Feel free to contact me.

{% if site.linkedin_username %}

{% endif %}


text:
# lifeguard ![CI Build](https://github.com/zslayton/lifeguard/workflows/Rust/badge.svg) [![](http://meritbadge.herokuapp.com/lifeguard)](https://crates.io/crates/lifeguard)
## Object Pool Manager
[API Documentation](http://zslayton.github.io/lifeguard/lifeguard/)

### Examples

`Pool` issues owned values wrapped in smartpointers.

```rust
extern crate lifeguard;
use lifeguard::*;

fn main() {
    let pool : Pool<String> = pool().with(StartingSize(10)).build();
    {
        let string = pool.new_from("Hello, World!"); // Remove a value from the pool
        assert_eq!(9, pool.size());
    } // Values that have gone out of scope are automatically moved back into the pool.
    assert_eq!(10, pool.size());
}
```

Values taken from the pool can be dereferenced to access/mutate their contents.

```rust
extern crate lifeguard;
use lifeguard::*;

fn main() {
    let pool : Pool<String> = pool().with(StartingSize(10)).build();
    let mut string = pool.new_from("cat");
    string.push_str("s love eating mice"); //string.as_mut() also works
    assert_eq!("cats love eating mice", *string);
}
```

Values can be unwrapped, detaching them from the pool.

```rust
extern crate lifeguard;
use lifeguard::*;

fn main() {
    let pool : Pool<String> = pool().with(StartingSize(10)).build();
    {
        let string : String = pool.new().detach();
    } // The String goes out of scope and is dropped; it is not returned to the pool
    assert_eq!(9, pool.size());
}
```

Values can be manually entered into / returned to the pool.

```rust
extern crate lifeguard;
use lifeguard::*;

fn main() {
    let pool : Pool<String> = pool().with(StartingSize(10)).build();
    {
        let string : String = pool.detached(); // An unwrapped String, detached from the Pool
        assert_eq!(9, pool.size());
        let rstring : Recycled<String> = pool.attach(string); // The String is attached to the pool again
        assert_eq!(9, pool.size()); // but it is still checked out from the pool
    } // rstring goes out of scope and is added back to the pool
    assert_eq!(10, pool.size());
}
```

`Pool`'s builder API can be used to customize the behavior of the pool.

```rust
extern crate lifeguard;
use lifeguard::*;

fn main() {
 let pool : Pool<String> = pool()
   // The pool will allocate 128 values for immediate use. More will be allocated on demand.
   .with(StartingSize(128))
   // The pool will only grow up to 4096 values. Further values will be dropped.
   .with(MaxSize(4096))
   // The pool will use this closure (or other object implementing Supply<T>) to allocate
   .with(Supplier(|| String::with_capacity(1024)))
   .build();
  // ...
}
```

### Highly Unscientific Benchmarks

Benchmark source can be found [here](https://github.com/zslayton/lifeguard/blob/master/benches/lib.rs). Tests were run on an early 2015 MacBook Pro.

Each benchmark comes in three flavors:

1. `tests::*_standard`: Uses the system allocator to create new values.
2. `tests::*_pooled_rc`: Uses a `Pool` to create new values which hold `Rc` references to the `Pool`. These values can be freely passed to other scopes.
3. `tests::*_pooled`: Uses a `Pool` to create new values which hold `&` locally-scoped references to the `Pool`. These values are the cheapest to create but are bound to the lifetime of the `Pool`.

#### Uninitialized Allocation

Compares the cost of allocating a new `String` (using `String::with_capacity`, as `String::new` does not allocate immediately) with the cost of retrieving a `String` from the pool.

```ignore
tests::allocation_standard                          ... bench:   5,322,513 ns/iter (+/- 985,898)
tests::allocation_pooled_rc                         ... bench:     784,885 ns/iter (+/- 95,245)
tests::allocation_pooled                            ... bench:     565,864 ns/iter (+/- 66,036)
```

#### Initialized Allocation

Compares the cost of allocating a new `String` and initializing it to a given value (via `&str::to_owned`) with the cost of retrieving a `String` from the pool and initializing it to the same value.

```ignore
tests::initialized_allocation_standard              ... bench:   5,329,948 ns/iter (+/- 547,725)
tests::initialized_allocation_pooled_rc             ... bench:   1,151,493 ns/iter (+/- 119,293)
tests::initialized_allocation_pooled                ... bench:     927,214 ns/iter (+/- 147,935)
```

#### Vec<Vec<String>> Allocation

Creates a two-dimensional vector of initialized Strings. All `Vec`s and `String`s created are from a `Pool` where applicable. Adapted from [this benchmark](https://github.com/frankmcsherry/recycler/blob/master/benches/benches.rs#L10).

```ignore
tests::vec_vec_str_standard                         ... bench:   1,353,906 ns/iter (+/- 142,094)
tests::vec_vec_str_pooled_rc                        ... bench:     298,087 ns/iter (+/- 168,703)
tests::vec_vec_str_pooled                           ... bench:     251,082 ns/iter (+/- 24,408)
```

Ideas and PRs welcome!

Inspired by frankmcsherry's [recycler](https://github.com/frankmcsherry/recycler).

repository: zslayton/lifeguard

gha_language: Rust

repo_name: zslayton/lifeguard


text:
# CapsNet-GAN-Tensorflow Implmentation
An experimental Generative Adversarial Network implementation of the Capsule Neural Network. It is based on the recent works on Dynamic Routing between Capsules:
reference: [Dynamic routing between capsules](https://arxiv.org/abs/1710.09829v1) by **Sara Sabour, Nicholas Frosst, Geoffrey E Hinton**

## Requirements
  - Tensorflow
  - Numpy
  - Pandas
  - DateTime
  - Matplotlib

## Installation
  `pip install -r requirements.txt`

## Training
   python CapsNetGANs.py

## Training Details
   Currently the initial commit is implemented to train on the domains of the MNIST Dataset.

## Results
   Resulting generated images of the network are on the way. I'll soon commit them.

## Note
   -If the CapsNetGANs.py does not work on your machine due to GPU Memory constraint, try CapsNetGANs2.py, in this only the discriminator has the CapsNet layer and thus takes much lesser memory.

   -Added the CapsNet layer to the generative model, but the entire network hogs a lot of GPU memory, need to find a way to reduce it in the next commit. Optimised for memory constraints.

   -Need to tune hyperparameter so that the GAN gets properly trained.

   -Add an option to also train on Fashion MNIST dataset
## Reference
   - https://github.com/llSourcell/Generative_Adversarial_networks_LIVE For EZGAN implementation
   - https://github.com/naturomics/CapsNet-Tensorflow For CapsNet Implementation


text:
# PacketCluster CRD

The PacketCluster is the CRD that contains information about where to place the
Kubernetes cluster: facility and project.

We do not support cross facilities or multi projects cluster. If you need so my
suggestion is to look for what it is called [federation](k8s-federation).

## Topology

Each cluster we create leverages at least two Equinix Metal features: Device and ElasticIP.

Kubernetes node is a Device and each cluster has an
[ElasticIP](elastic-ip-packet) that is tagged with the name of the cluster.

The ElasticIP guarantees a stable endpoint even when the control plane(s) are
recycled during a Kubernetes version update or an outages.

## ElasticIP lifecycle

Every cluster has its own ElasticIP. It is tagged with the name of the cluster and
it does not get removed when a cluster is terminated. You have to remove it manually.

This is a safety feature in this way you can re-assign the IP to another
cluster with the same name.

## FAQ

**Does cluster-api work with only Ubuntu/Debian?**

Currently the cluster-template only supports Ubuntu because it uses `apt` and it
does a couple of assumptions around networking. This does not mean that you
can't use `cluster-api-provier-packet` with other templates, but you will have
to make your own cluster specification in order to make the installation process
to work as you want.

[k8s-federation]: https://kubernetes.io/blog/2018/12/12/kubernetes-federation-evolution/
[elastic-ip-packet]: https://metal.equinix.com/developers/docs/networking/elastic-ips/


text:
# Tools for analyzing performance of a Haskell program

## Question

While solving some Project Euler Problems to learn Haskell (so currently I'm a completly beginner) I came over [Problem 13](http://projecteuler.net/index.php?section=problems&id=12). I wrote this (naive) solution:

    --Get Number of Divisors of n
    numDivs :: Integer -> Integer
    numDivs n = toInteger $ length [ x | x<-[2.. ((n `quot` 2)+1)], n `rem` x == 0] + 2

    --Generate a List of Triangular Values
    triaList :: [Integer]
    triaList =  [foldr (+) 0 [1..n] | n <- [1..]]

    --The same recursive
    triaList2 = go 0 1
      where go cs n = (cs+n):go (cs+n) (n+1)

    --Finds the first triangular Value with more than n Divisors
    sol :: Integer -> Integer
    sol n = head $ filter (\x -> numDivs(x)>n) triaList2

This Solution for n=500 (sol 500) is extremly slow (running for more than 2 hours now), so I wondered how to find out why this solution is so slow. Are there any commands that tell me where most of the computation-time is spend so I know which part of my haskell-program is slow? Something like a simple profiler.

To make it clear, i'm not asking **for** a faster solution but for **a way** to find this solution. How would you start if you would have no haskell knowledge?

I tried to write two triaList functions but found no way to test which one is faster, so thats where my problems start.

Thanks

## Answer

> how to find out why this solution is so slow. Are there any commands that tell me where most of the computation-time is spend so I know which part of my haskell-program is slow?

Precisely! GHC provides many excellent tools, including:

*   [runtime statistics](http://www.haskell.org/ghc/docs/6.12.2/html/users_guide/runtime-control.html)
*   [time profiling](http://www.haskell.org/ghc/docs/6.12.2/html/users_guide/prof-time-options.html)
*   [heap profiling](http://www.haskell.org/ghc/docs/6.12.2/html/users_guide/prof-heap.html)
*   [thread analysis](http://research.microsoft.com/en-us/projects/threadscope/)
*   [core analysis.](http://hackage.haskell.org/package/ghc-core)
*   [comparative benchmarking](http://hackage.haskell.org/package/criterion)
*   [GC tuning](http://hackage.haskell.org/package/ghc-gc-tune)

A tutorial on using time and space profiling is [part of Real World Haskell](http://book.realworldhaskell.org/read/profiling-and-optimization.html).

**GC Statistics**

Firstly, ensure you're compiling with ghc -O2. And you might make sure it is a modern GHC (e.g. GHC 6.12.x)

The first thing we can do is check that garbage collection isn't the problem. Run your program with +RTS -s

    $ time ./A +RTS -s
    ./A +RTS -s
    749700
       9,961,432,992 bytes allocated in the heap
           2,463,072 bytes copied during GC
              29,200 bytes maximum residency (1 sample(s))
             187,336 bytes maximum slop
                   **2 MB** total memory in use (0 MB lost due to fragmentation)

      Generation 0: 19002 collections,     0 parallel,  0.11s,  0.15s elapsed
      Generation 1:     1 collections,     0 parallel,  0.00s,  0.00s elapsed

      INIT  time    0.00s  (  0.00s elapsed)
      MUT   time   13.15s  ( 13.32s elapsed)
      GC    time    0.11s  (  0.15s elapsed)
      RP    time    0.00s  (  0.00s elapsed)
      PROF  time    0.00s  (  0.00s elapsed)
      EXIT  time    0.00s  (  0.00s elapsed)
      Total time   13.26s  ( 13.47s elapsed)

      %GC time       **0.8%**  (1.1% elapsed)

      Alloc rate    757,764,753 bytes per MUT second

      Productivity  99.2% of total user, 97.6% of total elapsed

    ./A +RTS -s  13.26s user 0.05s system 98% cpu 13.479 total

Which already gives us a lot of information: you only have a 2M heap, and GC takes up 0.8% of time. So no need to worry that allocation is the problem.

**Time Profiles**

Getting a time profile for your program is straight forward: compile with -prof -auto-all

     $ ghc -O2 --make A.hs -prof -auto-all
     [1 of 1] Compiling Main             ( A.hs, A.o )
     Linking A ...

And, for N=200:

    $ time ./A +RTS -p
    749700
    ./A +RTS -p  13.23s user 0.06s system 98% cpu 13.547 total

which creates a file, A.prof, containing:

        Sun Jul 18 10:08 2010 Time and Allocation Profiling Report  (Final)

           A +RTS -p -RTS

        total time  =     13.18 secs   (659 ticks @ 20 ms)
        total alloc = 4,904,116,696 bytes  (excludes profiling overheads)

    COST CENTRE          MODULE         %time %alloc

    numDivs            Main         100.0  100.0

Indicating that _all_ your time is spent in numDivs, and it is also the source of all your allocations.

**Heap Profiles**

You can also get a break down of those allocations, by running with +RTS -p -hy, which creates A.hp, which you can view by converting it to a postscript file (hp2ps -c A.hp), generating:

![alt text](https://i.imgur.com/OoSB6.png)

which tells us there's nothing wrong with your memory use: it is allocating in constant space.

So your problem is algorithmic complexity of numDivs:

    toInteger $ length [ x | x<-[2.. ((n `quot` 2)+1)], n `rem` x == 0] + 2

Fix that, which is 100% of your running time, and everything else is easy.

**Optimizations**

This expression is a good candidate for the [stream fusion](https://stackoverflow.com/questions/578063/what-is-haskells-stream-fusion) optimization, so I'll rewrite it to use [Data.Vector](http://hackage.haskell.org/package/vector), like so:

    numDivs n = fromIntegral $
        2 + (U.length $
            U.filter (\x -> fromIntegral n `rem` x == 0) $
            (U.enumFromN 2 ((fromIntegral n `div` 2) + 1) :: U.Vector Int))

Which should fuse into a single loop with no unnecessary heap allocations. That is, it will have better complexity (by constant factors) than the list version. You can use the ghc-core tool (for advanced users) to inspect the intermediate code after optimization.

Testing this, ghc -O2 --make Z.hs

    $ time ./Z
    749700
    ./Z  3.73s user 0.01s system 99% cpu 3.753 total

So it reduced running time for N=150 by 3.5x, without changing the algorithm itself.

**Conclusion**

Your problem is numDivs. It is 100% of your running time, and has terrible complexity. **Think about numDivs, and how, for example, for each N you are generating \[2 .. n `div` 2 + 1\] N times. Try memoizing that, since the values don't change.**

To measure which of your functions is faster, consider using [criterion](http://hackage.haskell.org/package/criterion), which will provide statistically robust information about sub-microsecond improvements in running time.

* * *

**Addenda**

Since numDivs is 100% of your running time, touching other parts of the program won't make much difference, however, for pedagogical purposes, we can also rewrite those using stream fusion.

We can also rewrite trialList, and rely on fusion to turn it into the loop you write by hand in trialList2, which is a "prefix scan" function (aka scanl):

    triaList = U.scanl (+) 0 (U.enumFrom 1 top)
        where
           top = 10^6

Similarly for sol:

    sol :: Int -> Int
    sol n = U.head $ U.filter (\x -> numDivs x > n) triaList

With the same overall running time, but a bit cleaner code.

repository: stackflow-io/stackflow

repo_name: stackflow-io/stackflow


text:
# dvm

Fast and simple Deno runtime version manager built with Native Reason.

## Current Status

You probably don't want to use this, yet. If you want to work on making dvm
feature-complete, check out the
[issue tracker](https://github.com/imbsky/dvm/issues)! We're not just looking
for professional Reason developers either, beginners, documentarians, etc, are
highly welcome!

## Hacking on the code

### Prerequisites

- esy
- git

### Getting the source

You can clone the source from GitHub with

```console
git clone https://github.com/imbsky/dvm.git
```

You can complete the setup of your development environment with

```console
cd dvm
esy
```

You can build and test this package with

```console
esy build
esy x dvm.exe
```

## License

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

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

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

repository: nzws/dvm

repo_name: nzws/dvm


text:
---
title: last week of scratch
layout: post
author: john.nickless
permalink: /last-week-of-scratch/
source-id: 1a2FI9MBTwgsYxwp1HkNU7jGosBkgG7w5qsaoMD83HEo
published: true
---

    Title
    last week of scratch
    Date
    13/2/18

    Starting point:
    Finished base defender, need to add some details.

    Target for this lesson?
    Add the improvements that my friends gave me

    Did I reach my target?
    Yes.

    How did you use your learning habits this week?

    Persevering
    I filled in the improvements that people wanted me to

    Questioning?
    I asked what people meant when i did not understand

    Independence
    I continued coding by myself

    Reflecting
    I used my previous knowledge to fix the suggestions that my friends pointed out

    Engagement
    I put up my hand in class

    What changes do you need to make to improve your learning next time?

    Work quicker


text:
---
title: Copy of Copy of Using Github
layout: post
author: billy.craddock
permalink: /copy-of-copy-of-using-github/
source-id: 1gOLCTeGSO5J4bpW6SPF-rtegZo2GHK6IQwy2_sU37xU
published: true
---

    Title
    Football match (wasn't here)
    Date
    31/01/17

    Starting point:
    Warming up on the pitch

    Target for this lesson?
    To win the match and get to the final

    Did I reach my target?
(add details to "Lesson Review")
     Yes as we won 5-4 against Oesdale

    Lesson Review

    How did I learn? What strategies were effective?

    I learnt by watching the attackers style of play and after he got the ball I would go in for the tackle and try to get the ball out to the midfielders and striker.  Which habits do I need to work on?

    The things that limited my learning were not getting tackled in as then they would be through on goal which wouldn't have been good. Luckily, had that happened to me, someone would be there to sweep in behind and I would do the same thing if it happened to him.

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

    I will try harder to get some good passes around and try to make some more solid tackles because then I will be improving as a footballer and we would be improving as a team and would then win more and more games.


text:
% Getting Started
% Alex Honor; Greg Schueler
% November 20, 2010

This chapter helps new users get started with Rundeck. We will begin
by explaining a few essential Rundeck concepts and
terminology and then discuss installation, project setup and introduce
you to the top level navigation of the interface.

## Essential Concepts

Several fundamental concepts underly and drive the Rundeck system.
If you are a new user, knowing about them will
help you use or integrate Rundeck into your environment.

Role-based Access Control Policies

:   A Rundeck *access control policy* grants users
	and user groups certain
    privileges to perform actions against rundeck resources
    like projects, jobs, nodes, commands and API.
    Every action requested by a user is evaulated by the
    Rundeck authorization system and logged for
    reporting and auditing purposes.

    Since Rundeck respects the policy definition, you can define role-based
    authorization to restrict users to only a subset of actions. This
    enables a self-service type interface, where some users have
    access to a limited set of executable actions.

Projects

:   A *project* is a place to separate management activity.
    All Rundeck activities occur within the context of a project.
    Multiple projects can be maintained on the same Rundeck server.
    Projects are independent from one another, so you can use them to
    organize unrelated systems within a single Rundeck
    installation. This can be useful for managing different infrastructures,
    environments or applications.
    Projects can be archived and imported to other Rundeck servers to help
    promote changes between environments.

Jobs

:   *Jobs* encapsulate a sequence of steps, job options and
    a nodes where the steps execute.
    Jobs can be given a unique
    ID, a name, and group to organize them. Jobs can be
    run on demand or they may be scheduled to run periodically.
    Jobs can send notifications when they begin, succeed or fail.
    Jobs take a number of parameters to control execution, including
    what to do when an error occurs in one of the steps or
    how many threads to execute actions across a list of nodes.

    Jobs can be composed out of other jobs. Each job can be a step
    in another job sequence.

Nodes

:   A _Node_  is a resource that is either a physical or virtual instance
    of a network accessible host.
    Nodes have a number of basic attributes but these attributes can be
    extended to include arbitrary named key/value pairs.
    A *node filter* is a search expression that matches a set of nodes
    by their attributes. Rundeck  node filters let you match Nodes based on a pattern like "tags" or any node attribute.

    A *resource model* is a representation of Nodes in a project.
    Each project can be configured to have multiple resource model sources
    and each model source can contribute its own set of nodes and node attributes.

Commands

:   A _command_ is a single executable string executed on a Node.
    Rundeck invokes commands on nodes via a *node executor*
    which evaluates the command string and executes it.
    Node executors evaluate the command string in a data context
    containing information about the Node resource. Command strings
    can reference this data and thus avoid hard coding node or environment
    specific values.

Executions

:   An _execution_ is a representation of the activity of a running or completed
    command or job. The data about the execution is used in rundeck to monitor
    the progress of a job or command and later for reporting about what happened.

    Each execution contains any output generated by commands or job steps,
    a record of the nodes where they occurred and the start/end time and status
    for each step.

Plugins

:   Most of what Rundeck does is via one of its plugins. Plugins exist
    to execute commands on nodes, perform a step in a workflow,
    send a notification about job status, gather
    information about the hosts in your network, copy a file to a remote
    server, store and stream logs, or talk to a user directory.
    A *node executor* is a Rundeck plugin that implements how to
    communicate with the Node and how to invoke the command action.

## Download and Installation

If a running Rundeck instance isn't already available to you,
[download](http://rundeck.org/downloads.html) and
install it. There are several package formats.
Choose the one that best suits your infrastructure.

After installation, be sure Rundeck has been started.
See [Startup](../administration/startup-and-shutdown.html) to learn how to
startup and shutdown rundeck.

The default port for the web interface is `4440`. If you
installed Rundeck on your local machine, go to this URL: <http://localhost:4440>

## Login

Rundeck requires every user to login. The default installation
defines an "admin" user with access to perform all actions.
Use "admin" for username and password.

![Login form](../figures/fig0202.png)

## Project setup

A new installation will not contain any projects so Rundeck will present
you with a dialog to create one. Press the "New Project" button to create
a project.
Fill the project creation form with a desired name. Project names can
contain letters and numbers but do not use spaces or special characters.
The [Project setup](../administration/project-setup.html)
chapter in the Administrator guide
will show you how to learn to add Nodes, automate the creation and maintenance of
Rundeck projects.

Once the project has been created you are ready to use your Rundeck instance.

## Rundeck Graphical Console

### Navigation

The Rundeck page header contains global navigation control to move
between tabbed pages: Jobs, Nodes, Commands and Activity. It also has links to
Configure the project, logout, view your user profile and a link to this online help.

![Top navigation bar](../figures/fig0201.png)

Project menu

:    The top navigation bar contains a menu to select the
     desired project. If only one project exists, the menu will
     automatically be selected. You can create new projects from
     this menu, too.

Jobs

:    From the Jobs page, one can list, create and run Jobs. A
     configurable filter allows a user to limit the Job listing to those
     Jobs matching the filtering criteria. These filter settings can be
     saved to a Users profile. Only authorized jobs will be visible.

     See [Jobs](jobs.html).

Nodes

:    The Nodes page is used to browse your Nodes configured in your
     Project resource model. A filter  control can be used to
     limit the listing to just the Node resources
     matching the filter criteria. Given the appropriate authorization
     you can also execute ad hoc commands to your filtered node set.

     See [Nodes](nodes.html).

Commands

:    The Commands page lets you execute abitrary commands against the
     nodes that match the node filter.

     See [Commands](commands.html).

Activity

:    From the Activity page, one can view currently executing commands
     and Jobs or browse execution history. The execution
     history can be filtered based on user selected parameters. Once the
     filter has been set, the matching history is displayed. The current
     filter settings also configure an RSS link, found in the top right of
     the page (see Rundeck Administration to enable RSS).

     See [Activity](activity.html).

Configure

:    If your login belongs to the "admin" group and therefore granted
     "admin" privileges, a "Configure" icon will be displayed in
     the top navigation bar.
     From the Configure page you can edit project configuration,
     export and import project archives, view system information,
     and see what plugins are installed.

     See [Configure](configure.html)

User

:    The User menu lets you logout and view your profile page.
     Your user profile lists your group memberships and a form to list
     and generate API tokens.

     See [User](user.html)

Help

:    Opens a page to this user manual.

## Command Line Tools

Rundeck includes a number of shell tools to dispatch commands, load
and run Job definitions and interact with the dispatcher queue. These
command tools are an alternative to functions accessible in the
graphical console.

See the [Command line tools](../man1/index.html).

## API

You can also use the Web API to interface with all aspects of node
and Job execution.

See the [Rundeck API](../api/index.html) page for a reference on the
endpoints and examples.

## Document Formats

If you prefer to manage job and resource definitions using text files
you can do so using XML or YAML formats.

See the [Document Format Reference](../man5/index.html).

repository: spacexnasa/rundeck

repo_name: spacexnasa/rundeck


text:
# EasyEatAPI
This is the backend software whose purpose is handle the business model for EasyEat. It exposes the endpoints as a REST API that the different
Clients can consume.

## Getting Started
These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites
What things you need to install the software and how to install them.

```
Will be filled while development begins
```

### Installing

A step by step series of examples that tell you how to get a development env running

Say what the step will be

```
Give the example
```

And repeat

```
until finished
```

End with an example of getting some data out of the system or using it for a little demo

## Running the tests

Explain how to run the automated tests for this system

### Break down into end to end tests

Explain what these tests test and why

```
Give an example
```

### And coding style tests

Explain what these tests test and why

```
Give an example
```

## Deployment

Add additional notes about how to deploy this on a live system

## Built With

* [Laravel](https://laravel.com/docs) - The web framework

## Collaboration Rules
The collaboration Rules are simple and also very important. They ensure that everyone involved into this project know what and how to do the right things.
Those rules help in preventing the chaos while testing the API.
All collaborators have to follow those rules:
* There is one branch for production: MASTER
* There is one branch for development: DEVELOP
* Each feature must be developped in a dedicated branch. Once the feature is done. The content of the branch will be merged to the DEVELOP's branch.
* Once features in DEVELOP's branch are stables we merge to the MASTER's branch so that the feature can be pulled to production's environment.
* Developper must annotate the commits with comprehensible comments.

## Developpers

* **Rulx Philomé ALEXIS** - [rpalexis](https://github.com/rpalexis)

repository: rapadds/EasyEatAPI

repo_name: rapadds/EasyEatAPI


text:
# AntWorks-OOP-library-for-rbxLua
AntWorks features a very powerful yet simple approach to object oriented programming in rbxLua. Get started by visiting the setup page within the repository.

## Features
AntWorks supports most of which an OOP library would need, some of which is:

**Inheritence** - Very flexible inheritance allowing both objects and classes to inherit from multiple sources.

**DataTypeLimits** - Supports limitations to the datatype of the value which can be set at index.

**Multimethods** - Supports the creation and usage of multimethods.

**readOnly/locked properites** - The ability to lock indexes making them readOnly. You could also lock the entire object and then unlock specific indexes.

**Events** - Allows you to easily create new custom events, with simple management of connections helping you avoid memory leaks.

**Changed event** - Including a changed event which will fire whenever an index-s value within your AntObject is changed.

## Documentation
Api documentations and examples can be found in the repository.

## Credits to
**Ozzypig** - For repr, a function which is used to print out tables.

## License
MIT License Copyright (c) 2019 ScripterGo


text:
CORONA COVID 19 BRAZIL

    An awesome analysis of CORONA COVID 19! MODELO PREDIÇÃO CORONA VÍRUS QUARENTENA PARA O ESTADO DE SÃO PAULO, BRASIL

    Explore the docs »

    ·
    Report Bug
    ·
    Request Feature

## Table of Contents

* [About the Project](#about-the-project)
* [Getting Started](#getting-started)
  * [Prerequisites](#prerequisites)
  * [Installation](#installation)
* [Usage](#usage)
* [Roadmap](#roadmap)
* [License](#license)
* [Contact](#contact)
* [Acknowledgements](#acknowledgements)

## About The Project

[![Product Name Screen Shot][product-screenshot]](https://example.com)

Observing the worldwide tendency to ignore some diseases that can become a pandemic. the pandemic that is in fashion requiring some knowledge of its behavior for the prediction and estimation of cases from tables of data collected from the global health agencies. These routines are still very primary, but we can already observe some behavior that we can predict or estimate with models of evolution of the infection (I) of healthy individuals (S) that can kill (D) these or let these (R, E) live.

## Getting Started

This program has a database until March 24, 2020 for the number of confirmed cases for several countries. With the programs you can carry out an assessment of the mortality of this CORONA 19, and time evolution.

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

### Prerequisites

The list of things that you need to use the software and how to install them.
* pip
```sh
pip install pandas numpy scipy wget
```

### Installation

1. Get a free API Key at [https://github.com/cmpaulo/corona19](https://github.com/cmpaulo/corona)
2. Clone the repo
```sh
git clone https://github.com/cmpaulo/corona.git
```

## Usage

ABOUT TAXS IN BRASIL

ABOUT SIR MODEL

## License

Distributed under the MIT License. See `LICENSE` for more information.

## Contact

Your Name - [@cmp0484](https://twitter.com/cmp0484)

Project Link: [https://github.com/cmpaulo/corona](https://github.com/cmpaulo/corona)

## Acknowledgements
* [GitHub Pages](https://pages.github.com)

-->
[linkedin-url]: https://br.linkedin.com/in/claudio-machado-paulo

# CORONA COVID19 BRAZIL
MODELO PREDIÇÃO CORONA VÍRUS QUARENTENA PARA O ESTADO DE SÃO PAULO, BRASIL
MODELO SIR/SIRE BRASIL 2019

repository: mmacpaulo/corona

repo_name: mmacpaulo/corona


text:
# PostgreSQL + PostGIS docker image

This derivative work is based on https://github.com/kiasaki/docker-alpine-postgres and https://github.com/Rushmorefm/docker-images

**Warning !!!**

this repo contain binary blob from:
gosu-amd64: https://github.com/tianon/gosu/releases/download/1.2/gosu-amd64
testing.tar.xz: https://github.com/Rushmorefm/alpine-packages/releases/download/v0.1/testing.tar.xz

repository: abihf/docker-alpine-postgres

repo_name: abihf/docker-alpine-postgres


text:
# Remove url component

Remove some url parameter from url in browser.
Uses history API.

This will also work if you have got hash in your url.

## Abandoned

Unfortunately I don't have any more time to maintain this repository :-(

![sad cat](https://raw.githubusercontent.com/sakren/sakren.github.io/master/images/sad-kitten.jpg)

## Usage

```
var remove = require('remove-url-component');

remove(['page']);
```

This will remove `page` parameter from your url.

False is returned if history API is not supported.

## Example

`http://my.super-page.com/?arg1=aaaaa&page=2&arg2=bbbbb`

will become:

`http://my.super-page.com/?arg1=aaaaa&arg2=bbbbb`

## Timeout

Maybe you will need to set timeout before removing, so you can set second argument in remove function.

```
remove(['arg1', 'arg2'], 3000);
```

## Changelog list

* 1.0.1
	+ Move under Carrooi organization
	+ Abandon package

* 1.0.0
	+ Initial version

repository: Carrooi/Node-RemoveUrlComponent

repo_name: Carrooi/Node-RemoveUrlComponent


text:
---
title: Taranaki Falls loop
date: 2018-07-28
publishdate: 2018-08-19
author: Chris Scott
image: 008_IMG_20180728_104229.jpg
latitude: -39.199858
longitude: 175.541656
tags:
  - hike
categories:
  - Activities
resources:
  - src: 005_IMG_20180728_102848.jpg
    title: Little waterfall
  - src: 001_IMG_20180728_094323.jpg
    title: Start of lower track
  - src: 010_IMG_20180728_104538.jpg
    title: IMG_20180728_104538.jpg
  - src: 012_IMG_20180728_111921.jpg
    title: IMG_20180728_111921.jpg
  - src: 008_IMG_20180728_104229.jpg
    title: Taranaki Falls
  - src: 003_IMG_20180728_101525.jpg
    title: Wairere Stream
  - src: 002_IMG_20180728_095826.jpg
    title: Forest
  - src: 011_IMG_20180728_110322.jpg
    title: Lava Flow
  - src: 007_IMG_20180728_103740.jpg
    title: IMG_20180728_103740.jpg
  - src: 004_IMG_20180728_101547.jpg
    title: IMG_20180728_101547.jpg
  - src: 006_IMG_20180728_103649.jpg
    title: Taranaki Falls
---

We went to National Park for a long weekend at the end of July, hoping to do some skiing for the first time since moving to New Zealand.
We were able to ski on the first day and, after a couple of times down the beginner's area, I remembered the basics (I haven't done much skiing before and the last time was over 3 years ago) and was able to move on to the next slopes up.
The visibility got pretty bad later in the day but we managed to get quite a lot of runs in and I was feeling much more confident by the end.
Gemma went off by herself for a bit to do some more interesting slopes for her.

Unfortunately, the weather on the second day looked even worse and we decided it wasn't worth trying to ski again, so we went for a walk to Taranaki Falls, from Whakapapa Village, just below the skiing place.
It was a nice walk; we took the lower track first, through some forest and along a river.

{{< photo src="002_IMG_20180728_095826.jpg" title="Taranaki Falls lower track" >}}

Eventually, we spotted the falls in the distance.

{{< photo src="006_IMG_20180728_103649.jpg" title="Taranaki Fall" >}}

They were quite impressive, with the best view from the far side.

{{< youtube FQizNlfWy8c >}}

After the falls we climbed up on the upper track, which was quite a bit more exposed, especially with the wind starting to pick up, and it was getting quite cold.
Eventually, we were back into the shelter of trees again and the track headed back down to the carpark.

{{< photo src="012_IMG_20180728_111921.jpg" title="Forest track" >}}

{{< map gpx="taranaki-falls-loop.gpx" >}}

gha_language: CSS


text:
Upload configuration about the current state, so that 'kubeadm upgrade' can later know how to configure the upgraded cluster.

### Synopsis

Upload configuration about the current state, so that 'kubeadm upgrade' can later know how to configure the upgraded cluster.

```
kubeadm config upload [flags]
```

### Options

```
  -h, --help   help for upload
```

### Options inherited from parent commands

```
      --kubeconfig string   The kubeconfig file to use when talking to the cluster. If the flag is not set, a set of standard locations are searched for an existing KubeConfig file. (default "/etc/kubernetes/admin.conf")
      --rootfs string       [EXPERIMENTAL] The path to the 'real' host root filesystem.
```

repository: zchee/kubernetes-docs

repo_name: zchee/kubernetes-docs


text:
# Atom Term 2

Shell sessions within atom editor. It's a fork of "[Term][1]" package.

```bash
apm install term2
```

![Term](https://dl.dropboxusercontent.com/u/20947008/webbox/atom/atom-term2-1.png)

## A Complete Terminal

You can run **Vim, Emacs, Htop, etc.** in your Atom.

![Vim, Emacs and HTop](https://dl.dropboxusercontent.com/u/20947008/webbox/atom/atom-term3.png)

## Startup Command

It adds startup command to run at startup.

![Term Startup](https://dl.dropboxusercontent.com/u/20947008/webbox/atom/atom-term2.png)

## Shell Arguments

You can define your bash arguments. It's `--init-file ~/.bash_profile` by default.

[1]: http://atom.io/packages/term

## Key Bindings:

**`CTRL + ALT + T`** Opens new tab.

**`CTRL + ALT + <Direction>`**

and you can also use **`CMD + K T <Direction>`**

`CMD + K <Direction>` is the default key binding to open split windows. If you just add `T` after
`K` press, you'll open a window.

Now you can use simply `CTRL + ALT + Left`, `CTRL + ALT + Right`, `CTRL + ALT + Up` or `CTRL + ALT + Down`.

## Custom Title

You can customize Title with using some variables. These are the current variables you can use:

  - `bashName`
  - `hostName`
  - `platform`
  - `home`

Default version of Title template is `Template ({{ bashName }})`.


text:
# PDF viewer showcase sample
## Requires
- Visual Studio 2013
## License
- MS-LPL
## Technologies
- Windows Runtime
## Topics
- Portable Document Format (pdf)
## Updated
- 05/13/2014
## Description

This sample demonstrates how to work with Portable Document Format (PDF) files programmatically.

Specifically, this sample shows how to:

Scroll through various pages in a PDF file.

Use semantic zoom to switch between viewing single and multiple pages in a PDF file.

Share a PDF file in an email message.

For detailed info about how this sample works, see the companion
PDF viewer end-to-end sample documentation.

To obtain an evaluation copy of Windows 8.1, go to
Windows 8.1.

To obtain an evaluation copy of Microsoft Visual Studio 2013, go to
Visual Studio 2013.

Note  For Windows 8 app samples, download the
Windows 8 app samples pack. The samples in the Windows 8 app samples pack will build and run only on Microsoft Visual Studio 2012.

Related topics

Windows.Data.Pdf

PDF viewer sample

Operating system requirements

Client

Windows 8.1

Server

Windows Server 2012 R2

Build the sample

Start Visual Studio 2013 and select File > Open > Project/Solution.

Go to the directory in which you unzipped the sample. Go to the directory named for the sample, and double-click the Visual Studio 2013 Solution (.sln) file.

Press F7 or use Build > Build Solution to build the sample.

Run the sample

To debug the app and then run it, press F5 or use Debug > Start Debugging. To run the app without debugging, press Ctrl+F5 or use
Debug > Start Without Debugging.

To test semantic zoom with the keyboard, press CTRL+PLUS SIGN or CTRL+MINUS SIGN. If your testing machine doesn't have touch enabled or does not support touch, run the app in
Simulator mode in Microsoft Visual Studio. After the app starts in the simulator, click the
Pinch/zoom touch mode icon on the simulator's edge, and then use the mouse to simulate pinch and zoom touch gestures. To perform these gestures, press and hold the left mouse button while rotating the mouse wheel backward or forward. To turn off pinch/zoom
 touch mode, click either the Mouse mode or Basic touch icon on the simulator's edge.

To test device rotation, if you have a desktop PC or your testing machine doesn't have rotation enabled, run the app in
Simulator mode in Visual Studio. After the app starts in the simulator, click the
Rotate clockwise (90 degrees) or Rotate counterclockwise (90 degrees) icon on the simulator's edge to simulate device rotation.

After the app starts, you can load a different PDF file. To do this, display the app bar: swipe from the top or bottom edge; or right-click the mouse; or with
Basic touch mode enabled in the simulator, with the mouse pointer anywhere on the top or bottom device frame, press and hold the left mouse button while dragging onto the app's surface. Click the open button on the app bar, and browse to and select the
 desired PDF file.

In the JavaScript sample: to share the loaded PDF file in an email message, display the charms bar: swipe from the right edge; or move the mouse pointer to the upper-right or lower-right corner; or with
Basic touch mode enabled in the simulator, with the mouse pointer anywhere on the right device frame, press and hold the left mouse button while dragging onto the app's surface. Click the
Share charm, and follow the on-screen instructions.

url: https://raw.githubusercontent.com/Violet26/msdn-code-gallery-microsoft/df0f5129fa839a6de8f0f7f7397a8b290c60ffbb/Official Windows Platform Sample/PDF viewer showcase sample/README.md


text:
##  clinical:hl7-resource-subscription

#### Licensing
![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)

#### Integration & Verification Tests
[![CircleCI](https://circleci.com/gh/clinical-meteor/hl7-resource-risk-assessment/tree/master.svg?style=svg)](https://circleci.com/gh/clinical-meteor/hl7-resource-risk-assessment/tree/master)

#### API Reference
The resource in this package implements Subscription resource schema, specified at [https://www.hl7.org/fhir/DSTU2/subscription.html](https://www.hl7.org/fhir/DSTU2/subscription.html).

#### Installation

```bash
meteor add clinical:hl7-resource-subscription
```

You may also wish to install the `autopublish` package, which will set up a default publication/subscription of the Subscriptions collection for logged in users.  You will need to remove the package before going into production, however.

```bash
meteor add clinical:autopublish
```

#### Utilities

If you're working with HL7 FHIR Resources, we recommend using [Postman](https://chrome.google.com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop?hl=en).


text:
# Multicellaesporites megareniformis Z.C. Song SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Fossil Spores and Pollen of China (Beijing) 1: 20 (1999)

#### Original name
Dicellaesporites reniformis Zhong Y. Zhang

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# building

`ami` requires Maven to build.
It relies on a parent POM which should be used to edit resources uniformly (e.g. Java version, maven plugins, etc.).

## POM file
The POM file depends on a parent.
```
    <parent>
        <groupId>org.contentmine</groupId>
        <artifactId>cm-parent</artifactId>
        <version>7.1.0</version>
    </parent>
```

The instructions in the POM include:

### jar-with-dependencies
The POM can generate a single Java JAR which contains all the upstream libraries so it is the only thing that has to be downloaded. There are deliberately many entry points. To run it:
```
java -jar <version>-jar-with-dependencies -cp <jar-location> <mainClass>
```
There are many main class entry points - the pom will show those mapped onto commands.

### appassembler
This generates platform-independent scripts (UNIX, MACOSX, Windows) which run the different functions. The scripts are initially located in
```
some/where/ami3/target/appassembler/bin
```
and you probably want to copy them to your library directories.

Current entry points - these are being explanded
```
contentMine          exist???
cproject             runs "cproject [args]
makeProject          runs - -makeProject (\\1)/fulltext.pdf - -fileFilter .*/(.*)\\.pdf"
norma                norma [args]
                            but also runs makeProject (FIX this)
ami-all              lists AMI commands (ami-*)
ami-dictionaries     edit/create AMI dictionaries
ami-search-cooccur   run AMI searches and co-occurrence
ami-pdf              convert PDF into SVG and extract images
ami-xml              ???
cmine
ami-frequencies
ami-gene
ami-identifier
ami-regex
ami-search
ami-sequence
ami-species
ami-word
```
(This needs updating and will be).

## versioning
Currently all versions are `SNAPSHOTS` and treated a such by Maven.

# commands

## full build

Make sure `ami3` is sync'ed with the git repo, rebuilt and reinstalled.

The following command will clean, build, and install `org.contentmine:ami3` in your personal `.m2` repository.
```
mvn clean install -DskipTests
```

## tests
NOTE: Tests are a work in progress.

Tests are separated in unit tests and integration tests.
Integration tests have names that end in `IT` and are run during a different Maven build phase:

* Unit tests are run by the Maven Surefire plugin during the `test` phase (so included when you run `mvn package`) and failing unit tests fail the build.
* Integration tests are run by the Maven Failsafe plugin during the `integration-test` and `verify` phases of the build, so included when you run `mvn verify`, or `mvn install`. Failing integration tests will not fail the build.

There is a switch `skipITs` to disable the integration tests, but it is currently disabled:

```
# currently does not work
mvn clean install -DskipITs=false
```

Finally, if you wish to skip compiling the tests, run:
```
mvn install -Dmaven.test.skip=true
```

gha_language: HTML


text:
# Adding an upload/download script (draft)

Creating a full upload and download for a new datatype or data source
is one of the more complex activities to attempt in KBase.  This guide
will is not a comphrensive guide, but will walk though the high-level
steps and explain how development is done in the deplooy_dev docker
environment.

## Overview

An upload/download requires creating several configurations (both for the
UI pieces and the conversion pieces), creating scripts to do validation and
conversion, and modifying some Javascript files in the narrative.  In the
future we hope to combine this pieces so that everything can be specified in
a single repository.

## Preparing the environment

Start by cloning the deploy_dev environment and following the instructions to
starting a isolated development version of KBase.  See the top-level README
for instructions.

Fork and clone:

* https://github.com/kbase/narrative (docker branch)
* https://github.com/kbase/narrative_method_specs_ci
* https://github.com/kbase/transform

Clone the transform fork directly in the deploy_dev directory.
The others can be forked in a different area. For example:

    cd deploy_dev
    GITUSER=<username>
    git clone git@github.com:$GITUSER/transform.git
    cd ..
    git clone git@github.com:$GITUSER/narrative.git -b docker
    git clone git@github.com:$GITUSER/narrative_method_specs_ci.git

Modify the Dockerfile to your modifications to the above directories into your image build.
Add the lines below to the Dockerfile in the base of your deploy_dev directory.

ADD ./transform /kb/dev_container/modules/transform
RUN cd /kb/dev_container/modules/transform && . ../../user-env.sh && make && make deploy

Modify the method-spec-git-repo parameter in your cluster.ini file to point to your
fork of narrative_method_specs_ci.  Also modify the method-spec-git-repo-branch to match
the branch you will push changes to.  For example:

    [NarrativeMethodStore]
    method-spec-git-repo-branch=master
    method-spec-git-repo=https://github.com/<username>/narrative_method_specs_ci

## Make the changes

### Creating the scripts

Follow the guide at [https://github.com/kbase/project_guides/blob/master/How_to_add_a_new_data_type.md](How_to_add_a_new_data_type.md).  Create the scripts in your clone of the transform repo.

### Create the UI specs

Create configuration in your fork and clone of the narrative_method_specs.  Conculst the README in that repo
for details.

### Add the type to the sidebar

The narrative data pane has a pop out window to perform upload/download operations.  Currently you need to
modify a javascript file to recongnize the new type.  Edit the file at:
> src/notebook/ipython_profiles/profile_narrative/kbase_templates/static/kbase/js/widgets/narrative_core/kbaseNarrativeSideImportTab.js

## Build and Test

To test your modifications you will need to rebuild thhe narrative image and redeploy.

    cd ../narrative
    docker build -t kbase/narrative:1.0.3 .
    cd ../deploy_dev
    ./deploy.sh

The deploy will rebuild the primary image which will include your modifications to transform and use your method specs file.  If services were already runing you will need to restart them.  You can do this by using the DELETE/kill URL to kill the running service.  You can then poke the normal service url to restart the service.  You will need to do this anytime you make changes to a service.

    . ./site.cfg
    curl -X DELETE http://${PUBLIC_ADDRESS}:8080/kill/transform
    curl http://${PUBLIC_ADDRESS}:8080/services/transform
    curl -X DELETE http://${PUBLIC_ADDRESS}:8080/kill/narrativemethodstore
    curl http://${PUBLIC_ADDRESS}:8080/services/narrativemethodstore

At this point you should be able to navigate to the narrative site and try opening the data tab and test your changes.

gha_language: Shell