text:
# Object storage buckets

The `Bucket` API defines a source for artifacts coming from S3 compatible storage
such as Minio, Amazon S3, Google Cloud Storage, Alibaba Cloud OSS and others.

## Specification

Bucket:

```go
// BucketSpec defines the desired state of an S3 compatible bucket
type BucketSpec struct {
	// The S3 compatible storage provider name, default ('generic').
	// +kubebuilder:validation:Enum=generic;aws
	// +optional
	Provider string `json:"provider,omitempty"`

	// The bucket name.
	// +required
	BucketName string `json:"bucketName"`

	// The bucket endpoint address.
	// +required
	Endpoint string `json:"endpoint"`

	// Insecure allows connecting to a non-TLS S3 HTTP endpoint.
	// +optional
	Insecure bool `json:"insecure,omitempty"`

	// The bucket region.
	// +optional
	Region string `json:"region,omitempty"`

	// The name of the secret containing authentication credentials
	// for the Bucket.
	// +optional
	SecretRef *corev1.LocalObjectReference `json:"secretRef,omitempty"`

	// The interval at which to check for bucket updates.
	// +required
	Interval metav1.Duration `json:"interval"`

	// The timeout for download operations, defaults to 20s.
	// +optional
	Timeout *metav1.Duration `json:"timeout,omitempty"`

	// Ignore overrides the set of excluded patterns in the .sourceignore format
	// (which is the same as .gitignore). If not provided, a default will be used,
	// consult the documentation for your version to find out what those are.
	// +optional
	Ignore *string `json:"ignore,omitempty"`

	// This flag tells the controller to suspend the reconciliation of this source.
	// +optional
	Suspend bool `json:"suspend,omitempty"`
}
```

Supported providers:

```go
const (
	GenericBucketProvider string = "generic"
	AmazonBucketProvider  string = "aws"
)
```

### Status

```go
// BucketStatus defines the observed state of a bucket
type BucketStatus struct {
	// ObservedGeneration is the last observed generation.
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Conditions holds the conditions for the Bucket.
	// +optional
	Conditions []meta.Condition `json:"conditions,omitempty"`

	// URL is the download link for the artifact output of the last Bucket sync.
	// +optional
	URL string `json:"url,omitempty"`

	// Artifact represents the output of the last successful Bucket sync.
	// +optional
	Artifact *Artifact `json:"artifact,omitempty"`

	// LastHandledReconcileAt is the last manual reconciliation request (by
	// annotating the Bucket) handled by the reconciler.
	// +optional
	LastHandledReconcileAt string `json:"lastHandledReconcileAt,omitempty"`
}
```

### Condition reasons

```go
const (
	// BucketOperationSucceedReason represents the fact that the bucket listing and
	// download operations succeeded.
	BucketOperationSucceedReason string = "BucketOperationSucceed"

	// BucketOperationFailedReason represents the fact that the bucket listing or
	// download operations failed.
	BucketOperationFailedReason string = "BucketOperationFailed"
)
```

## Artifact

The resource exposes the latest synchronized state from S3 as an artifact
in a gzip compressed TAR archive (`<bucket checksum>.tar.gz`).

### Excluding files

Git files (`.git/`, `.gitignore`, `.gitmodules`, and `.gitattributes`) are
excluded from the archive by default, as well as some extensions (`.jpg, .jpeg,
.gif, .png, .wmv, .flv, .tar.gz, .zip`)

Excluding additional files from the archive is possible by adding a
`.sourceignore` file in the root of the bucket. The `.sourceignore` file
follows [the `.gitignore` pattern
format](https://git-scm.com/docs/gitignore#_pattern_format), pattern
entries may overrule default exclusions.

Another option is to use the `spec.ignore` field, for example:

```yaml
apiVersion: source.toolkit.fluxcd.io/v1beta1
kind: Bucket
metadata:
  name: podinfo
  namespace: default
spec:
  ignore: |
    # exclude all
    /*
    # include deploy dir
    !/deploy
    # exclude file extensions from deploy dir
    /deploy/**/*.md
    /deploy/**/*.txt
```

When specified, `spec.ignore` overrides the default exclusion list.

## Spec examples

### Static authentication

Authentication credentials can be provided with a Kubernetes secret that contains
`accesskey` and `secretkey` fields:

```yaml
apiVersion: source.toolkit.fluxcd.io/v1beta1
kind: Bucket
metadata:
  name: podinfo
  namespace: default
spec:
  interval: 1m
  provider: generic
  bucketName: podinfo
  endpoint: minio.minio.svc.cluster.local:9000
  insecure: true
  secretRef:
    name: minio-credentials
---
apiVersion: v1
kind: Secret
metadata:
  name: minio-credentials
  namespace: default
type: Opaque
data:
  accesskey: <BASE64>
  secretkey: <BASE64>
```

> **Note:** that for Google Cloud Storage you have to enable
> S3 compatible access in your GCP project.

### AWS IAM authentication

When the provider is `aws` and the `secretRef` is not specified,
the credentials are retrieve from the EC2 service:

```yaml
apiVersion: source.toolkit.fluxcd.io/v1beta1
kind: Bucket
metadata:
  name: podinfo
  namespace: default
spec:
  interval: 5m
  provider: aws
  bucketName: podinfo
  endpoint: s3.amazonaws.com
  region: us-east-1
  timeout: 30s
```

> **Note:** that on EKS you have to create an IAM role for the source-controller
> service account that grants access to the bucket.

## Status examples

Successful download:

```yaml
  status:
    artifact:
      checksum: b249024b8544521792a079c4037d0a06dd0497a9
      lastUpdateTime: "2020-09-18T08:34:49Z"
      path: bucket/source-system/podinfo/aeaba8b6dd51c53084f99b098cfae4f5148ad410.tar.gz
      revision: aeaba8b6dd51c53084f99b098cfae4f5148ad410
      url: http://localhost:9090/bucket/source-system/podinfo/aeaba8b6dd51c53084f99b098cfae4f5148ad410.tar.gz
    conditions:
    - lastTransitionTime: "2020-09-18T08:34:49Z"
      message: 'Fetched revision: aeaba8b6dd51c53084f99b098cfae4f5148ad410'
      reason: BucketOperationSucceed
      status: "True"
      type: Ready
    observedGeneration: 2
    url: http://localhost:9090/bucket/source-system/podinfo/latest.tar.gz
```

Failed download:

```yaml
status:
  conditions:
  - lastTransitionTime: "2020-09-18T08:34:49Z"
    message: "bucket 'test' not found"
    reason: BucketOperationFailed
    status: "False"
    type: Ready
```

Wait for ready condition:

```bash
kubectl -n gitios-system wait bucket/podinfo --for=condition=ready --timeout=1m
```

repository: bashims/source-controller

repo_name: bashims/source-controller


text:
# pathEnd

## Description

Only passes the request to its inner route if the unmatched path of the `RequestContext` is empty, i.e. the request
path has been fully matched by a higher-level @ref[path](path.md#path-java) or @ref[pathPrefix-java](pathPrefix.md#pathprefix-java) directive.

This directive is a simple alias for `rawPathPrefix(PathEnd)` and is mostly used on an
inner-level to discriminate "path already fully matched" from other alternatives (see the example below).

## Example

@@snip [PathDirectivesExamplesTest.java](../../../../../../../test/java/docs/http/javadsl/server/directives/PathDirectivesExamplesTest.java) { #path-end }

repository: jonas/akka-http

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: jonas/akka-http


text:
Description
=============

#### - MQTT protocol
  - Communication with minimal power and packet amount: suited for M2M (Machine To Machine) & IoT (Internet of Things)

#### - Components of MQTT protocol

  - Broker: transit between publisher and subscriber
  - Publisher: publish (sending message to broker on the specific topic)
  - Subscriber: subscribe (Receiving message published on the same topic)

#### - Topic of MQTT protocol
  - A kind of address (IP) role: connection allocation according to the topic of publisher or subscriber in broker
  - Hierarchical structure of topics: ease of data management
  - Multiple subscribers can be subscribing to a single topic: 1 to N communication is advantageous

Contents
=============

#### - MQTT test
  - Creating Publisher & Subscriber
  - Set Collback Function to Subscriber
  - Connecting to Broker
  - Subscribing & Publishing
  - Subscribing Loop

How to use
=============

#### - Running Mosquitto broker example
```
mosquitto_sub -t "#" -p 1883
```

#### - Running MQTT protocol py example
```
python MQTT_protocol_python.py --host <IP_ADDRESS> --port 1883 --topic login --message hi
```

References
=============

#### - MQTT protocol

https://medium.com/@jspark141515/mqtt%EB%9E%80-314472c246ee/

http://www.steves-internet-guide.com/into-mqtt-python-client/

#### - Mosquitto Download

https://mosquitto.org/download/

Author
=============

#### - LinkedIn: https://www.linkedin.com/in/taeyong-kong-016bb2154

#### - Blog URL: https://blog.naver.com/qbxlvnf11

#### - Email<EMAIL_ADDRESS><EMAIL_ADDRESS>

license: MIT

branch_name: refs/heads/main


text:
---
layout:     post
title:      Learning to Program
date:       2015-12-03 10:00:00
summary:    Guide and list of resources to self-learn programming.
categories:
---

My first taste of programming was in high school and I didn’t think much of it. My second taste was at university when I had spare subjects and decided to take a programming 101 course utilising [Python](https://en.wikipedia.org/wiki/Python_(programming_language)){:target="_blank"} out of curiosity. It was right about the time when the mobile revolution was starting and I had an inkling that maybe this tech stuff might be important. That was a couple of years ago and since then I’ve gradually built up my knowledge through self-learning that I feel confident enough to build apps or learn new technologies to build apps.

Given the quality and breadth of resources freely available via the internet I’m a firm believer that you can learn to program and become a competent technologist/data scientist without spending a cent (whether you should is another question) and you certainly do not need to graduate with a university degree to become one.

Depending on your circumstances you may want to pursue a university degree. Whether you should go to university to learn this material is a question that I don’t intend to explore in this blog post. This is a guide to self-learning programming.

##Timeframe and Costs

I’ve personally spent a couple of hundred dollars on various course material but you don’t have to. I have for different reasons but mainly because I could save time by purchasing helpful material.

It’s taken me a couple of years to get to the point where I know enough to build apps but probably not skilled to be employed professionally as a software engineer. To be frank, I don’t believe the gap is huge and filling it is just a question of time and motivation. Personally, I believe if a person is motivated enough and allocates enough time they could learn enough to be employed professionally within a couple of months if not weeks.

Ultimately, how long it takes to competence depends on what you’re trying to achieve and the motivation and time you can allocate towards this pursuit.

##Basics

Programming is not the same thing as computer science. For a guide on what computer science is see this [blog post](http://matt.might.net/articles/what-cs-majors-should-know/){:target="_blank"} by Matt Might.

Whether you’re someone looking to build applications, taking the data science route or aspiring technologist, learning a programming language will be the starting point.

A programming language is the language computers understand. If you want to build an application and want the computer to make the application work you need to ‘speak’ to the computer in a language it understands.

Keeping things simple, most of the concepts and principles underlying most programming languages will be the same or analogous and the difference is in the syntax. Hence, for the layman coming to programming the choice of programming language won’t matter much except for pedagogical purposes i.e. pick the language that will help you learn most efficiently. Having gone through this process myself I can help you make that choice. Once you have grasped the key concepts learning the syntax of another language takes minimal effort.

Once you’ve learnt a programming language, you can choose a learning track depending on your motivation:

* Web Development
* Mobile Development
* Data Science

Note that depending on which track you choose you may have to learn an additional languages suitable for that track.

##What track to start with?

If you're planning a career in data science then go straight to the data science track. If you want to build apps I would start with web development even if you intend to only build mobile applications due to the fact any mobile app with a reasonable set of features will at some point require implementing technologies within the web development stack.

##What programming language to start with?

I personally would start with the Ruby on Rails stack because the learning resources available are excellent. More importantly Ruby on Rails is known for allowing you to build a working deployable app quite quickly. It's a mature technology stack so support via the community is excellent.

If there were better learning resources available for Python+Django stack I may have gone with that. I would not go with PHP because it has a reputation for not being modern. Ruby and Python are contemporary.

I would avoid going through the Node.js stack initially as there are not a lot of great learning resources for it and because it is more cutting edge it is not as mature and well supported by the community compared to Ruby and Python.

##Pedagogy

I’m a better reader than listener. Anytime I have to listen/watch a lecture I lose focus very quickly. Luckily the best learning resources available these days reflect this so maybe I’m not the only one with this predilection.

##Learning Resources

####Starting with Codecademy

Start with [Codecademy](https://www.codecademy.com){:target="_blank"} to learn the popular programming languages. Once I finished one programming language I continued with a different one to reinforce the concepts I’ve learnt. It’s for free and cover many of the most popular programming language in use today. They recently introduced a paid version but nothing that wasn’t free prior requires payment now. This is my [Codecademy profile](https://www.codecademy.com/ThePoliEcon){:target="_blank"}.

The great thing about Codecademy style learning is that it’s learning by doing and you can complete things in small self-contained chunks and it’s free. One con some people may find is that it doesn’t provide enough detail or motivation behind concepts. It’s a great starting point.

Codecademy is great for familiarising yourself with the syntax of various programming languages and a basic understanding on how web technology works.

#####Graduating to Codeschool

Once I completed most of the Codecademy courses I felt I didn’t know enough details. That’s when I paid to enrol in the courses provided by [Codeschool](https://www.codeschool.com){:target="_blank"}. Learning style in the same vein as Codecademy except that it provides more depth in concepts and you get access to broader set of technologies that software engineers use day to day such as Git.

Strong on front-end web development, Ruby on Rails and Javascript stack and also Git. No Python or Android, basic iOS. Move onto Codeschool if you want to pursue a web development track. All you can eat charged monthly. Relatively cheap and good value for money.

 This
[how to guide](http://www.jonhmchan.com/blog/2014/4/28/finally-a-guide-to-hosting-your-website){:target="_blank"} by Jon Chan is what I used to help build my first website.

####Building a dynamic website with Michael Hartl's Ruby on Rails Tutorial

To complete your education in the basics of web development you should build a dynamic website. I used [Michael Hartl’s Ruby on Rails Tutorial](https://www.railstutorial.org/book){:target="_blank"} for this purpose. It’s universally well reviewed, being regarded as the preeminent tutorial book for Ruby on Rails and having completed all twelve chapters I understand why. It brings together all the concepts you have learnt up to now and very carefully takes you step by step in putting all the pieces together to build a twitter-clone and into production. You can see the version I built [here](https://enigmatic-peak-1983.herokuapp.com){:target="_blank"}. By the way did I mention it’s for free? You can pay for extra materials but not required.

####Resources for data science

If the motivation for learning programming is to pursue an interest in data science then you have the option to skip Codecademy and start straight away with the following resources:

[Datacamp](https://www.datacamp.com){:target="_blank"} - Codecademy style learning focused on the R programming language (which is the leading language used in data science. Python is probably second). Costs USD $25 per month all you can eat style. Wide breadth of courses covering most fields of data science, from programming in R, probability and statistics as well as applications, to machine learning and data manipulation/visualisation. Good value for money.

[Dataquest](https://www.dataquest.io){:target="_blank"} - Haven’t personally used myself but looks like a good complement to Datacamp. Focus on Python.

R and Python are complements in the data scientist toolkit. There will be things that R is preferable to Python and vice versa so worthwhile to learn both.

####Additional resources for mobile development

For mobile app development check out Codeschool mentioned above for iOS and [Swifty](http://swifty-app.com){:target="_blank"} to learn the Swift language.

There is also [Appcamp](http://appcamp.io){:target="_blank"} focusing on mobile development but I haven’t used this personally and appears to focus on Angular.js as a 'cross-platform' tech stack serving both iOS and Android. I can’t comment on the merits of such a approach.

Codeschool and the resources listed here are probably not sufficient to build and deploy a mobile app so you will need to complement with courses from the lecture based resources I list below.

####Lecture based learning resources

For learners who prefer video and lecture like approach to learning I’ve listed resources below:

[Udacity](https://www.udacity.com){:target="_blank"} and [Treehouse](https://teamtreehouse.com){:target="_blank"} are more modern approach to university style lectures. Have varying degrees of interaction. You can access most material from Udacity for free and essentially you’re paying for certificates which is optional. Treehouse is pay per month all you can eat.

There’s also [Udemy](https://www.udemy.com/){:target="_blank"} which is a marketplace version of Udacity and Treehouse.

[EDx](https://www.edx.org){:target="_blank"}, [Coursera](https://www.coursera.org){:target="_blank"}, and [iTunes University](https://itunes.apple.com/au/course/developing-ios-8-apps-swift/id961180099){:target="_blank"} are basically online university courses. All provide course material for free but EDx and Coursera provide option to pay for course certificate

I like EDx, Coursera, iTunes U to learn about topics that aren’t covered in the other resources I use.

If you’ve tried all of the above but find that you need the real-life human touch than there are various bootcamps such as [General Assembly](https://generalassemb.ly){:target="_blank"}.

Finally check out [Bento](https://www.bento.io/grid){:target="_blank"} by Jon Chan. It’s a cool website pointing out tonnes of other resources out there.

##Appendix - Taxonomy of Technologies and Jargon

This list is not meant to be comprehensive or correct to the letter. I’ve taken some liberties in order to convey the general gist of ideas.

#####Web v Mobile

Web refers to web browser which can be on both PCs and smartphones. When referring to mobile, this is to denote applications 'native' to that mobile device, i.e. downloaded from the App Store as opposed to using an application in a webpage/site through the web browser.

#####Front-end v Back-end

Front-end refers to the interface of an application (web or mobile). This is the part of the application  that you can see and interact with by using touch, mouse, or keyboard. Every website will have a front-end

Back-end refers to the components of the application that a user can’t see but are required for an application to provide more utility. To draw an analogy with the human body, the back-end is like your memory and cognitive skills. You can’t really 'see' memory or cognitive ability but your interaction with someone is enhanced when they have memory and some cognitive ability.

I know it's not a great analogy but I think it provides the gist of the idea.

#####Static v Dynamic website

A static website is an application with a front-end but no meaningful back-end. Dynamic websites have both front-end and back-end.

#####Web Development Technology Stack

To create a static website you need at the minimum HTML and CSS. For interactivity in the front-end e.g. motion, you need Javascript and jQuery.

To create a dynamic website, in addition to the above, you require knowledge of a programming language that can interact with servers and databases. You have a number of options to choose from but the most commonly used ones are:

* PHP
* Python (combined with Django)
* Ruby (combined with Rails aka Ruby on Rails)
* Javascript (combined with Node.js + Express.js) - Can be used for both front- and back-end

My recommendation is to use either Python or Ruby because they’re designed for the web in it’s modern incarnation yet mature and well supported. Javascript via node.js is more cutting edge which also means it’s not as mature and therefore harder to get help when you can’t work out why something isn’t working.

Django and Rails in the lingo are referred to as 'frameworks' corresponding with their respective programming languages. In this context, basically you can think of the programming language as factory machinery that manufacture tools in which case are Django, Rails, and Node.js (you can add jQuery to this category as well). Technically Node.js is not a framework but the analogy still holds.

Rails is a collection of tools made from Ruby. Django is collection of tools made from Python. Node.js/jQuery is a collection of tools made from Javascript.

Frameworks are like infrastructure. Basically they make your life easier by not having to reinvent the wheel each time you build a new application.

Finally, you need a database. Database are analogous to your memory. The most commonly used database are [relational](https://en.wikipedia.org/wiki/Relational_database){:target="_blank"}. I won’t go into details as not important at this stage except that you need a database to build a dynamic website. In order to use relational databases, you need to learn SQL (which is a language that manages the database).

#####Mobile Development Technology Stack

The two most important mobile platforms are iOS and Android. The programming language you need to learn are Swift or Objective-C for iOS and Java for Android. One small positive thing about iOS and Android is you only need one language for both front-end and back-end for feature lite apps.

Unfortunately as soon as you develop more feature rich apps that provide utility through the internet you will need to learn the web development back-end stack.

With respect to iOS, Swift is the new language Apple released in 2014 and is most likely to be the basis for future development on all Apple products. I’m planning to focus on Swift rather than Objective-C for my mobile projects.

#####Data Science Technology Stack

If you’re an aspiring data scientist you’re learning programming to help you do your job better. If you plan to build data products you will need to learn some web/mobile development as well.

To get started the two main languages you need to learn are [R](https://en.wikipedia.org/wiki/R_%28programming_language%29){:target="_blank"} and [Python](https://en.wikipedia.org/wiki/Python_(programming_language)){:target="_blank"}. R was designed for statistical computing while Python is a more of a general purpose language with applications in data science being a strong component.

There will be applications where R is better than Python and vice versa but ultimately you should aim to have both in your toolset because they complement each other.


text:
### Getting Started
Clone this repo, run ```npm i```.

If you haven't already, make sure your machine is setup to have MongoDB running.  If you haven't installed it already I suggest getting setup with HomeBrew: http://brew.sh/ and then downloading and setting up MongoDB by following this nice little getting started guide: http://treehouse.github.io/installation-guides/mac/mongo-mac.html

You'll have to get the correct keys from me for the .env.example file for the app to actually run.  Provided you have that file then you can continue below.

After all that `npm start` should get you up and running on localhost:3000 as long as you have nodemon installed.  If you don't have nodemon run `npm install -g nodemon` before `npm start`

### Main Features
- Weekly / Monthly / Daily email send out via SendGrid with a “subscription center” front-end
- Modal asking for users to submit their email to receive Weekly / Monthly / Daily emails
- Form Validation on the www.storytimebedtime.com/submit page where stories are created
  - that textarea is under 160
  - add error handling to input directives
  - all keywords that they've entered are also keywords in the storyDiv
  - catch errors on everything
- Create new MongoDB collection / UI for stories that need approval
- Create new MongoDB collection that logs purchases for seller reconcilliation
- Create Paginated API call
- Testimonials
- Testing Framework ()
- Photo upload
- Polish Checkout Process

### Other Features (after beta)
- get page titles working
- submit page preview for story card and story detail page
- possibly a blinking cursor in inputs or auto select?
- share story on facebook prompt - on success page, and at end of story
- delete stories by sending them to another collection called "deleted" or something
- change text font to "europa"
- Fix Facebook singup to work if user with email is already found
- Get "no story found" state and page
- Save story on their account / device so no "reloading" - have it local
- create 'indexes' in DB to help speed up searches


text:
# Middleware

The middleware is supported by providing an `middleware` object to the `install` function.

```js
import { Middleware, install } from 'mobx-little-router'
const router = {
  middleware: Middleware(evt => evt),
  // ...
}
```

Each [event](./events.md) dispatched through the system will pass through the middleware chain. The middleware
can add additional data or change the dispatch event entirely.

For example, here is a middleware that cancels every navigation -- not very useful of course.

```js
import { EventTypes } from 'mobx-little-router'
Middleware(evt => ({
  ...evt,
  type: EventTypes.NAVIGATION_CANCELLED
})
```

## Combining middlewares

Middleware objects can be combined using the `concat` method.

```js
const a = Middleware(evt => { /* ... */ })
const b = Middleware(evt => { /* ... */ })
const c = Middleware(evt => { /* ... */ })
const combined = a.concat(b).concat(c)
```

This will flow the data from right-to-left. Meaning that the above configuration will
pass through `a`, then `b`, and finally through `c`.

Some of the internal routing features are handled through middlewares, such as parsing the query object (See
[withQueryMiddleware](/packages/mobx-little-router/src/middleware/withQueryMiddleware.js)).

repository: mobx-little-router/mobx-little-router

gha_language: JavaScript

gha_license_id: MIT

repo_name: mobx-little-router/mobx-little-router


text:
# Installation

## Install CLI

Fluvio comes with CLI which can be used install, manage topic, produce and consume messages.

* First download Fluvio CLI binaries [github release](https://github.com/infinyon/fluvio/releases) for your OS.
* Copy CLI binary to your bin path and make it executable.

To test CLI binary:
```
$ fluvio version

version is: 0.4.1
```

Fluvio can be installed in any Kubernetes cluster.  For running in your laptop, it is recommended to use minikube.  There is special instruction for minikube for or cluster which uses IP address.  After minikube is setup, please follow regular kubernetes installation sections

## Set up Minikube

Install [Minikube](https://www.fluvio.io/docs/getting-started/minikube/) and create new cluster

```
minikube start
```

To work around certificate issue with IP address, use following create kubectl context which create dummy DNS rather than IP address
```
fluvio cluster set-minikube-context
```

This will create new kubectl context ```mycube``` and switch to it.

finally, start minikube tunnel which let you create external load balancer:

```
sudo nohup  minikube tunnel  > /tmp/tunnel.out 2> /tmp/tunnel.out &
```

If you want to terminate tunnel, you can do
```
sudo pkill minikube
rm /tmp/tunnel.*
```

## Install Helm binary

Fluvio use Helm chart for installation.

Please follow [Helm](https://helm.sh) doc to download and setup helm binary.  Once it is setup, you can use following command to test see if it is properly installed:

```
helm list
```

## Installing Fluvio system chart

Fluvio system chart will install cluster-wide components.  This is only needed to be done once per Kubernetes cluster.

This is only step where cloud specific components are configured.  For example, minikube and eks have different driver for storage.

Default is minikube.

```
$ fluvio cluster install --sys
```

For eks,
```
$ fluvio cluster install -sys --cloud eks
```

## Installing Fluvio cluster

Each Fluvio cluster consist of at least 1 controller and multiple SPU. A Fluvio cluster can be installed per namespace.

To install a cluster:
```
$ fluvio cluster install --namespace <namespace>
```

To install on default name space.
```
$ fluvio cluster install
```

After installation, spu should see them provisioned:
```
$ fluvio spu list
flvd spu list
 ID  NAME    STATUS  TYPE     RACK  PUBLIC              PRIVATE
  0  main-0  online  managed   -    <IP_ADDRESS>:9005  flv-spg-main-0.flv-spg-main:9006
```

## Quick Start

To perform a simple consume and producer test:

First. a create a simple topic name ```message```

```
$ fluvio topic create message
topic "message" created
```

Produce a text to message topic:
```
$ fluvio produce message
hello world
Ok!
```
Then we can consume or retrieve message.  In this case, we retrieve from beginning.  By default, messages are retrieval from last.  "-d" terminate immediately instead of waiting for next message.
```
$ flvd consume message -B -d
hello world
```

You can retrieve from known offset.
```
flvd consume message -o 0
```

repository: Ryanmtate/fluvio

repo_name: Ryanmtate/fluvio


text:
---
layout: default
title: Apps should support multiple accounts
tags: app multiple account
comments: true
---
# Apps should support multiple accounts

Apps that are backed by some kind of service in the cloud should support multiple accounts. This is a no-brainer but several apps fail to provide this convenience feature. I'm particularly frustrated by the Kindle app. Though it could apply to other apps like Netflix.

Why would you need multiple accounts? Well, you might have a personal account and a business account, for starters. You may have an account you share with other family members, and so on. It is, of course, quite likely that limiting the number of simultaneous accounts to two or some such upper limit is desirable, for performance reasons and to prevent abuse.

gha_language: Ruby


text:
# enigma_travel

Enigma Travel helps you travel with your friends!

[About Enigma Travel](https://docs.google.com/presentation/d/17j-ysATzTyVSGlD3Akh4H3dzQevAR5F3XXFdSLH48-o/edit?usp=sharing)

**Re-constructed as ["enigma abroad"](https://github.com/icoxfog417/enigma_abroad) !**
* use [Recruit AB-Road api](http://webservice.recruit.co.jp/ab-road/reference.html) as travel data.
* use [Topic Model](http://tech-sketch.jp/2015/09/topic-model.html) to choose similar travels.


text:
# Running Locally

This tool was originally designed to help editing keymap files in repositories
already cloned onto your computer.

## Setup

1. Clone this repo and open the new directory in a terminal.
3. Clone a `zmk-config`\* repo. Either create symlinks in this directory to the
  cloned repositories or clone them into this directory if you must.
3. Run `npm install`
4. Run `npm run dev`
5. Open `http://localhost:8080` in your browser. If a different port is needed
  set it in an environment variable when starting the server (e.g.
  `PORT=8081 node index.js`).

\**The editor works using metadata files that describe the layout and keymap of
the keyboard. This is based on JSON files used by QMK and Keyboard Layout Editor
with some customization to generated human readable code as well. For an example
see [zmk-config-corne-demo]*

## Using the editor

Your selected keyboard should be loaded automatically. Click on the top-left
corner of a key to change its bind behaviour, or in the middle to change the
bind parameter.

See also: [demo video](keymap-editor-demo.mov)

Click the _Save Local_ button to save the modified keymap back to your local
zmk-config repo. From here you can commit and push those changes to your remote
on GitHub to trigger the build.

[zmk-config-corne-demo]: https://github.com/nickcoutsos/zmk-config-corne-demo


text:
---
advisory: swarm-standalone
hide_from_sitemap: true
description: Swarm rescheduling
keywords: docker, swarm, clustering, rescheduling
title: Swarm rescheduling
---

You can set rescheduling policies with Docker Swarm. A rescheduling policy
determines what the Swarm scheduler does for containers when the nodes they are
running on fail.

## Rescheduling policies

You set the reschedule policy when you start a container. You can do this with
the `reschedule` environment variable or the
`com.docker.swarm.reschedule-policies` label. If you don't specify a policy, the
default rescheduling policy is `off` which means that Swarm does not restart a
container when a node fails.

To set the `on-node-failure` policy with a `reschedule` environment variable:

```bash
$ docker run -d -e "reschedule:on-node-failure" redis
```

To set the same policy with a `com.docker.swarm.reschedule-policies` label:

```bash
$ docker run -d -l 'com.docker.swarm.reschedule-policies=["on-node-failure"]' redis
```

## Review reschedule logs

You can use the `docker logs` command to review the rescheduled container
actions. To do this, use the following command syntax:

```bash
docker logs SWARM_MANAGER_CONTAINER_ID
```

When a container is successfully rescheduled, it generates a message similar to
the following:

```none
Rescheduled container 2536adb23 from node-1 to node-2 as 2362901cb213da321
Container 2536adb23 was running, starting container 2362901cb213da321
```

If for some reason, the new container fails to start on the new node, the log
contains:

```none
Failed to start rescheduled container 2362901cb213da321
```

## Related information

* [Apply custom metadata](/engine/userguide/labels-custom-metadata/)
* [Environment variables with run](/engine/reference/run/#env-environment-variables)


text:
# Slot: positively correlated with

holds between any two named thing entities "correlated with" one another in a positive manner.

URI: [biolink:positively_correlated_with](https://w3id.org/biolink/vocab/positively_correlated_with)

## Domain and Range

[NamedThing](NamedThing.md) →  0..\* [NamedThing](NamedThing.md)

## Parents

 *  is_a: [correlated with](correlated_with.md)

## Children

## Used by

## Other properties

|  |  |  |
| --- | --- | --- |
| **In Subsets:** | | translator_minimal |
| **Exact Mappings:** | | CTD:positive_correlation |

repository: linkml/linkml

gha_language: Python

repo_name: linkml/linkml


text:
# Vehicle Detection
[![Udacity - Self-Driving Car NanoDegree](https://s3.amazonaws.com/udacity-sdc/github/shield-carnd.svg)](http://www.udacity.com/drive)

In this project, your goal is to write a software pipeline to detect vehicles in a video (start with the test_video.mp4 and later implement on full project_video.mp4), but the main output or product we want you to create is a detailed writeup of the project.

The Project
---

The goals / steps of this project are the following:

* Perform a Histogram of Oriented Gradients (HOG) feature extraction on a labeled training set of images and train a classifier Linear SVM classifier
* Optionally, you can also apply a color transform and append binned color features, as well as histograms of color, to your HOG feature vector.
* Note: for those first two steps don't forget to normalize your features and randomize a selection for training and testing.
* Implement a sliding-window technique and use your trained classifier to search for vehicles in images.
* Run your pipeline on a video stream (start with the test_video.mp4 and later implement on full project_video.mp4) and create a heat map of recurring detections frame by frame to reject outliers and follow detected vehicles.
* Estimate a bounding box for vehicles detected.

Here are links to the labeled data for [vehicle](https://s3.amazonaws.com/udacity-sdc/Vehicle_Tracking/vehicles.zip) and [non-vehicle](https://s3.amazonaws.com/udacity-sdc/Vehicle_Tracking/non-vehicles.zip) examples to train your classifier.  These example images come from a combination of the [GTI vehicle image database](http://www.gti.ssr.upm.es/data/Vehicle_database.html), the [KITTI vision benchmark suite](http://www.cvlibs.net/datasets/kitti/), and examples extracted from the project video itself.   You are welcome and encouraged to take advantage of the recently released [Udacity labeled dataset](https://github.com/udacity/self-driving-car/tree/master/annotations) to augment your training data.

[//]: # (Image References)
[image1]: ./output_images/car_not_car.png
[image2]: ./output_images/HOG_example.png
[image4]: ./output_images/img_box.png
[image5]: ./output_images/heatmap.png
[image6]: ./output_images/labeled.png
[image7]: ./output_images/output_bboxes.png
[video1]: ./project_video.mp4

---
### Writeup / README

### Histogram of Oriented Gradients (HOG)

#### 1. Explain how (and identify where in your code) you extracted HOG features from the training images.

The code for this step is contained in the second and third code cell of the IPython notebook.

I started by reading in all the `vehicle` and `non-vehicle` images.  Here is an example of one of each of the `vehicle` and `non-vehicle` classes:

![alt text][image1]

I then explored different color spaces and different `skimage.hog()` parameters (`orientations`, `pixels_per_cell`, and `cells_per_block`).  I grabbed random images from each of the two classes and displayed them to get a feel for what the `skimage.hog()` output looks like.

Here is an example using the `YCrCb` color space and HOG parameters of `orientations=11`, `pixels_per_cell=(8, 8)` and `cells_per_block=(2, 2)`:

![alt text][image2]

#### 2. Explain how you settled on your final choice of HOG parameters.

I tried various combinations of parameters and check it by validating the trained SVM. Finally, I chose `YCrCb` as the color space and `orientations=11`, `pixels_per_cell=(8, 8)` and `cells_per_block=(2, 2)`

#### 3. Describe how (and identify where in your code) you trained a classifier using your selected HOG features (and color features if you used them).

I trained a linear SVM using the following steps:

* Read the data
* Extracted the features of the image include:
  * Histogram of Oriented Gradients (HOG)
  * Color features (spatial and histograms)
* Normalized the data
* Randomized the order of the data
* Split the data into train and test parts for validation

Finally, the model reached an accuracy of 99.3%.

### Sliding Window Search

#### 1. Describe how (and identify where in your code) you implemented a sliding window search.

I decided to search limited window positions at five different scales in the image:

Window size| Y start | Y end| X start| Overlap ratio
-----|-----|---|---|---
70x70|  380|490|606|0.8
90x90|  380|530|476|0.7
110x110|380|570|346|0.6
130x130|380|610|216|0.5
150x150|380|650| 86|0.4

Here is the code of `multi_window_search` function:

        winsow_sizes = (70, 90, 110, 130, 150)
        def multi_window_search(image, winsow_sizes, svc, X_scaler, color_space='RGB',
                            spatial_size=(32, 32), hist_bins=32,
                            hist_range=(0, 256), orient=11,
                            pix_per_cell=11, cell_per_block=2,
                            hog_channel=0, spatial_feat=True,
                            hist_feat=True, hog_feat=True):
            hot_windows=[]
            for i in range(len(winsow_sizes)):
                xy_window = (winsow_sizes[i], winsow_sizes[i])
                y_start = 380
                y_stop = 490+40*i
                x_start = 606-i*130
                overlap = 0.8 - 0.1*i
                y_start_stop = [y_start, y_stop]
                windows = slide_window(image, x_start_stop=[x_start, None], y_start_stop=y_start_stop,
                                    xy_window=xy_window, xy_overlap=(overlap, overlap))
                hot_window = search_windows(image, windows, svc, X_scaler, color_space=color_space,
                                        spatial_size=spatial_size, hist_bins=hist_bins,
                                        orient=orient, pix_per_cell=pix_per_cell,
                                        cell_per_block=cell_per_block,
                                        hog_channel=hog_channel, spatial_feat=spatial_feat,
                                        hist_feat=hist_feat, hog_feat=hog_feat)
                hot_windows.extend(hot_window)
            return hot_windows

        hot_windows = multi_window_search(image.astype(np.float32)/255, winsow_sizes, svc, X_scaler, color_space=color_space,
                                    spatial_size=spatial_size, hist_bins=hist_bins,
                                    orient=orient, pix_per_cell=pix_per_cell,
                                    cell_per_block=cell_per_block,
                                    hog_channel=hog_channel, spatial_feat=spatial_feat,
                                    hist_feat=hist_feat, hog_feat=hog_feat)

        draw_image = np.copy(image)
        window_img = draw_boxes(draw_image, hot_windows, color=(0, 0, 255), thick=6)

        plt.imshow(window_img)

#### 2. Show some examples of test images to demonstrate how your pipeline is working.  What did you do to optimize the performance of your classifier?

Ultimately I searched on two scales using `YCrCb` 3-channel HOG features plus spatially binned color and histograms of color in the feature vector, which provided a nice result.  I also optimized the searching area of the window sliding method and the size of the windows to get a better result.
Here are some example images:

###### Original image with the boxes
![alt text][image4]

###### Heatmap
![alt text][image5]

###### Labeled image
![alt text][image6]

---

### Video Implementation

#### 1. Provide a link to your final video output.  Your pipeline should perform reasonably well on the entire project video (somewhat wobbly or unstable bounding boxes are ok as long as you are identifying the vehicles most of the time with minimal false positives.)
Here's a [link to my video result](./project_video_output.mp4)

#### 2. Describe how (and identify where in your code) you implemented some kind of filter for false positives and some method for combining overlapping bounding boxes.

I recorded the heatmap stream and calculate the average heatmap of the last four frames to get a stable and accurate result adopted 1.5 as the final threshold. In that case, the true position of the vehicles would be enhanced while the influence of the outliers would be weakened due to the average calculation. Notice that the heatmap recorded is the data before applying the threshold but not the processed one. Here is the code of the pipeline:

    hot_cache=[]
    frame_num=0
    cache_num = 4
    def img_proc(image):
      global hot_cache
      global frame_num
      if frame_num > cache_num:
          hot_windows = multi_window_search(image.astype(np.float32)/255, winsow_sizes, svc, X_scaler, color_space=color_space,
                              spatial_size=spatial_size, hist_bins=hist_bins,
                              orient=orient, pix_per_cell=pix_per_cell,
                              cell_per_block=cell_per_block,
                              hog_channel=hog_channel, spatial_feat=spatial_feat,
                              hist_feat=hist_feat, hog_feat=hog_feat)
          heat = np.zeros_like(image[:,:,0]).astype(np.float)
          heat = add_heat(heat, hot_windows)
          hot_cache.append(heat)
          hot_cache = hot_cache[-cache_num:]
          heat_best = np.average(hot_cache, axis=0)
          heat = apply_threshold(heat_best, 1)
          # Visualize the heatmap when displaying
          heatmap = np.clip(heat, 0, 255)
          # Find final boxes from heatmap using label function
          labels = label(heatmap)
          draw_img = draw_labeled_bboxes(np.copy(image), labels)
          frame_num += 1
      else:
          hot_windows = multi_window_search(image.astype(np.float32)/255, winsow_sizes, svc, X_scaler, color_space=color_space,
                      spatial_size=spatial_size, hist_bins=hist_bins,
                      orient=orient, pix_per_cell=pix_per_cell,
                      cell_per_block=cell_per_block,
                      hog_channel=hog_channel, spatial_feat=spatial_feat,
                      hist_feat=hist_feat, hog_feat=hog_feat)
          heat = np.zeros_like(image[:,:,0]).astype(np.float)
          heat = add_heat(heat, hot_windows)
          hot_cache.append(heat)
          heat = apply_threshold(heat, 1)
          heatmap = np.clip(heat, 0, 255)
          # Find final boxes from heatmap using label function
          labels = label(heatmap)
          draw_img = draw_labeled_bboxes(np.copy(image), labels)
          frame_num += 1
      return draw_img

---

### Discussion

#### 1. Briefly discuss any problems / issues you faced in your implementation of this project.  Where will your pipeline likely fail?  What could you do to make it more robust?

Here I'll talk about the approach I took, what techniques I used, what worked and why, where the pipeline might fail and how I might improve it if I were going to pursue this project further.

The approach worked well in the given video and it also identified the cars coming from the other side of the road. Though it was able to find out the car in the image, the location and the size of the block is still not precise enough to calculate the distance of the car from the observer and the real size of the detected car. The approach still needs to be modified to get an accurate and precise result under pixel level. During the test I found that dense windows would help making the result more accurate and robust but required massive computation which significantly slowed down the detection speed. We may apply the deep learning method to increase accuracy and precision of the result such as `SSD`.

Another problem was that the approach was not able to separate the two cars if they were close to each other in the image.  I am wondering if we can use stereo imaging as the input source and the new depth information may help identify the two different cars during searching. Deep learning can be another solution and we can add such case in the training dataset to bring the model more knowledge of segmentation.


text:
2449\. Minimum Number of Operations to Make Arrays Similar

Hard

You are given two positive integer arrays `nums` and `target`, of the same length.

In one operation, you can choose any two **distinct** indices `i` and `j` where `0 <= i, j < nums.length` and:

*   set `nums[i] = nums[i] + 2` and
*   set `nums[j] = nums[j] - 2`.

Two arrays are considered to be **similar** if the frequency of each element is the same.

Return _the minimum number of operations required to make_ `nums` _similar to_ `target`. The test cases are generated such that `nums` can always be similar to `target`.

**Example 1:**

**Input:** nums = [8,12,6], target = [2,14,10]

**Output:** 2

**Explanation:** It is possible to make nums similar to target in two operations:

- Choose i = 0 and j = 2, nums = [10,12,4].

- Choose i = 1 and j = 2, nums = [10,14,2].

It can be shown that 2 is the minimum number of operations needed.

**Example 2:**

**Input:** nums = [1,2,5], target = [4,1,3]

**Output:** 1

**Explanation:** We can make nums similar to target in one operation: - Choose i = 1 and j = 2, nums = [1,4,3].

**Example 3:**

**Input:** nums = [1,1,1,1,1], target = [1,1,1,1,1]

**Output:** 0

**Explanation:** The array nums is already similiar to target.

**Constraints:**

*   `n == nums.length == target.length`
*   1 <= n <= 105
*   1 <= nums[i], target[i] <= 106
*   It is possible to make `nums` similar to `target`.

repository: javadev/LeetCode-in-Java

gha_language: Java

repo_name: javadev/LeetCode-in-Java


text:
# The Mileposts Methodology

Mileposts are special types of issues, similar to _[milestones](https://guides.github.com/features/issues/#filtering)_, but not as heavy and not (necessarily) bound to any specific release of the software.

### Purpose of a Milepost

In Mileposts, the _milepost lead_ saves the entire team energy _by clearly explaining what's going on_.

##### _Mileposts_ vs _Milestones_

- A milepost (MP) is _assigned-to_ and _managed-by_ a specific person: the milepost lead.
- Both milestones and mileposts aggregate _other issues_ together.
- Mileposts can contain issues that are assigned to a milestone, but a milepost does not need to be assigned to a milestone.
- Mileposts describe a specific _subarea_ of the project that has been claimed by the milepost lead (and those who may be helping them work on that subarea).

We include an example and a [specification](#the-milepost-spec) (for those who want one) below.

## Badge

Taking inspiration from [standard-js](https://github.com/feross/standard), you can include one of these badges in your readme to
let people know that your project is using Mileposts for its onboarding and project management.

[![mileposts](https://cdn.rawgit.com/taoeffect/mileposts/master/badge/badge.svg)](https://github.com/taoeffect/mileposts)

```markdown
[![mileposts](https://cdn.rawgit.com/taoeffect/mileposts/master/badge/badge.svg)](https://github.com/taoeffect/mileposts)
```

[![mileposts](https://img.shields.io/badge/team%20clarity-mileposts-brightgreen.svg)](https://github.com/taoeffect/mileposts)

```markdown
[![mileposts](https://img.shields.io/badge/onboarding-mileposts-brightgreen.svg)](https://github.com/taoeffect/mileposts)
```

## Milepost Example

See the [example milepost](https://github.com/taoeffect/mileposts/issues/1) in this issues tracker.

## Milepost Template

We recommend using **[saved replies](https://help.github.com/articles/creating-a-saved-reply/)** instead of [issue templates](https://github.com/blog/2111-issue-and-pull-request-templates) for creating Mileposts on GitHub.

Create a saved reply and copy/paste this content into it:

```markdown
The primary branch for this [milepost](https://github.com/taoeffect/mileposts) is located **[here](URL to branch).**

#### Description

A description of what this milepost is trying to accomplish, and the subarea (of
this project) that work on this milepost will restrict itself to. Make sure to
include @mentions of all collaborators who are (or may be) involved in this
milepost, and what their roles are.

#### Files

- Create `path/to/file`
- Remove `path/to/file`
- Update `path/to/file`

#### Issues

List of issues that need to be closed for closing this milepost:

- [ ] #29 - Brief description of issue #29
- [x] #30 - Example of an issue that has been closed
- [ ] #28 - Example of an issue that's shared with another MP **(shared with MP #50)**
```

Mileposts **must** be assigned to someone, called the **milepost lead**.

## Projects using Mileposts

- [Group Income Simple](https://github.com/okTurtles/group-income-simple)

_To add your project: send a PR with your project name added to the end of this list._

## The Milepost "Spec"

A milepost is an issue that has this format:

- **MUST** have a tag that is one of: `Milepost` or `milepost` or `MILEPOST`.
  - The tag's color **SHOULD** stand out from other tags (black or white are good choices).
- **MUST** use a title that represents the subarea being worked on.
- **MUST** be assigned to the milepost lead.
- **MUST** state and link to the branch that's tracking the _latest progress_ for the milepost. The branch **MAY** point to a fork of the current project.
- **MUST** contain a description of the subarea that's being worked on.
- **SHOULD** state the (user)names of any other collaborators who are (or might) be working on this milepost.
- **MUST** contain a list of files that might be modified, created, or deleted.
  - **IF** a milepost shares files with another milepost, then that **MUST** be _clearly and explicitely_ stated (e.g. `(shared with MP #30)`).
- **MUST** have a list of issues (with checkboxes) that are being worked on as part of this milepost.
  - Each issue in the list **SHOULD** have a brief description (can just be the issue's title).
  - **IF** a milepost shares an issue with another milepost, then that **MUST** be _clearly and explicitely_ stated (e.g. `(shared with MP #30)`).
- **SHOULD** contain a roadmap describing what the plan is to close the milepost.
- **MAY** be assigned to a milestone.

Mileposts **SHOULD** contain comments of the following nature:

- Regular or semi-regular updates on the current status/progress of the Milepost.
- Contain information about who is working on what part of the milepost.
- Questions & answers from other existing or new contributors about the nature/status of the milepost.

repository: taoeffect/mileposts

repo_name: taoeffect/mileposts


text:
# RLereWolf

## What is this?

RLereWolf is a, Python developed, framework for the social deduction game [Werewolf](https://en.wikipedia.org/wiki/Ultimate_Werewolf). The development of which is part of my undergraduate thesis at [University of Aberdeen](https://www.abdn.ac.uk/). RLereWolf provides the base Werewolf game which can be played multiplayer with either other people or bots (agents).

It also provides AI developers with an easy to use and integrate to framework for training agents to play Werewolf. The game's implementation allows users to create/join games of up to 75 players in which the players can be other humans, "dummy" agent players, rule-based agent players and/or reinforcement learning agent players, trained with OpenAI Gym.

RLereWolf provides the following:
1. The implementation for the Werewolf game
2. A basic TCP/IP Server-Client infrastructure to support multiplayer games
3. A testing platform for Werewolf AI agents
4. Verbose logging
5. A development platform for Werewolf AI and further game expansions

## Setup
The development of RLereWolf is done in Visual Studio 2019 as a "PyProject" using Python 3.7. In order to setup RLereWolf for development "out of the box" you need to

1. Install Python 3.7
2. Install Visual Studio 2019 with Python support (You can use your preferred editor/IDE, just be aware setting it up might be a bit more awkward)
3. Install the requirements - "pip3.7 install -r requirements.txt"
4. Select any of the pre-made boot configurations (Client, Server, Client + Server etc.) or add your own in the [project startup settings](https://github.com/GeorgeVelikov/RLereWolf/blob/main/Werewolf.sln.startup.json), as seen in:
![image](https://user-images.githubusercontent.com/45877509/110208917-acce1500-7e81-11eb-8d52-6e47b80a66c4.png)

## Structure

### Client

The client contains a basic tkinter and pygubu GUI which sends calls to the server in order to play the games hosted on the **Server**.

![image](https://user-images.githubusercontent.com/45877509/110209199-0125c480-7e83-11eb-9157-2c1ff8242388.png)

![image](https://user-images.githubusercontent.com/45877509/110209305-9de86200-7e83-11eb-87a1-b59bd1250e96.png)

### Server

The socket server that controls multiple games and the players in them. The server keeps logs of the server status, each game and is the effective _game moderator_.

### Shared

Various logic, dtos, utility methods that are used accross the **Client**, **Server** and **Werewolf** projects.

### Werewolf

Holds the game, game logic and currently holds the agent players and is referenced by the **Server** project.

repository: GeorgeVelikov/RLereWolf

repo_name: GeorgeVelikov/RLereWolf


text:
# KarFramework

[简体中文](./README-zh.md)

## What's this

Here is a framework of bungee/~~bukkit~~ Spigot and standard application.

Using this framework. You can:
- Building commands with link calling.
- Loading/Saving your configuration anywhere.
- Template support!
- Regex Replacer. in `RegexUtils`

## How to use

First, add our repository (https://raw.githubusercontent.com/Karlatemp/karlatemp-repo/master/)
into your repositories

Gradle:
```groovy
repositories {
    maven {
        url = 'https://raw.githubusercontent.com/Karlatemp/karlatemp-repo/master/'
        name = 'Karlatemp Repo'
    }
}
```

Now, you can use our framework now!

```groovy
dependencies {
    compile 'io.github.karlatemp.kar-framework:kar-framework:1.4.3'
}
```

Latest version: `1.4.3`

## Command Node

### Common Command Node

You can create command node with link calling.

First. You need a command-framework.

```java
class TestFramework
    // extends AbstractCommandFramework<PrintStream>
    implements ICommandFramework<PrintStream> {}
```

You can found example [here](common/src/test/java/io/github/karframwork/common/test/TestCommand.java)

Then, we can register our commands now.

```java
class TestFramework implements ICommandFramework<PrintStream> {
    public static void register() {
        ICommandFramework<PrintStream> framework = new TestFramework();
        final ICommandNode<PrintStream> command = new CommandTree<>(framework)
                .registerSubCommand(framework.newSingleCommand()
                        .setName("test")
                        .setDescription("Description")
                        .setExecutor((sender, arguments, sourceArguments) -> {
                            sender.println("Hello!");
                            sender.println(arguments);
                            sender.println(sourceArguments);
                        })
                        .build())
                .registerSubCommand(framework.newSingleCommand()
                        .setName("text")
                        .setDescription("D2")
                        .setExecutor((sender, arguments, sourceArguments) -> {
                            sender.println("TEXT HERE");
                        })
                        .build());
        command.execute(System.out, Arrays.asList("test"));
    }
}
```

### Spigot/Bungee Command Node

In ~~bukkit~~ Spigot/bungee. We have standard frameworks. You can get they with
`KarFrameworkBukkit.getInstance()/KarFrameworkBungee.getInstance()`.

Here is an example.
```java
public class CommandRegister {
    public static void register() {
        KarFrameworkBukkit framework = KarFrameworkBukkit.getInstance();
        final ICommandNode<CommandSender> command = new CommandTree<>(framework)
                        .registerSubCommand(framework.newSingleCommand()
                                .setName("test")
                                .setDescription("Description")
                                .setExecutor((sender, arguments, sourceArguments) -> {
                                    sender.sendMessage("Hello!");
                                })
                                .build())
                        .registerSubCommand(framework.newSingleCommand()
                                .setName("text")
                                .setDescription("D2")
                                .setExecutor((sender, arguments, sourceArguments) -> {
                                    sender.sendMessage("TEXT HERE");
                                })
                                .build());
        framework.provide(MyPlugin.getInstance()).provideCommand("my-command", command);
    }
}
```

## Configuration with SpongePowered

We have integrated 3 configurations format support(HOCON, JSON, YAML),

Powered by [SpongePowered/Configurate](https://github.com/SpongePowered/Configurate)

You can use them in ~~bukkit~~ Spigot/bungee, or other applications.
Just need implements your own [IPluginProvider](common/src/main/java/io/github/karlatemp/karframework/IPluginProvider.java)

Here is an example on ~~Bukkit~~ Spigot

```java
public class MyPlugin extends JavaPlugin {
    private static IPluginProvider provider;
    private ConfigurationNode config;
    public void onLoad() {
        provider = KarFrameworkBukkit.getInstance().provide(this);
    }

    public void reloadConfig() {
        ConfigurationLoader<? extends ConfigurationNode> loader = provider.loadConfiguration("config.conf");
        assert loader != null;
        config = provider.loadConfiguration(loader);
    }

    public org.bukkit.configuration.file.FileConfiguration getConfig() {
        return new YamlConfiguration();
    }
}
```

## NBT Framework

On ~~bukkit~~ Spigot, We provided NBT Framework.
You can use our framework to access nbt
without having to visit nms by yourself.

First. You need get our nbt framework with
`IBukkitNbtProvider provider = KarFrameworkBukkit.getNbtProvider();`.

Access nbt will be very easy.

```java
public class TestNBT { public static void test() {
    ITagCompound item = provider.newCompound();
    item.setString("id", "minecraft:stone");
    ItemStack itemStack = provider.fromCompound(item);
} }
```

## NMS Framework

On ~~bukkit~~ Spigot, We provided

- `void sendPacket(Player, Object packet)`
- `void sendTitle(Player, BaseComponent, BaseComponent, int, int, int)`
- `void sendAction(Player, BaseComponent)` (sendActionBar)
- `CommandMap getCommandMap()`
- `Function<@NotNull String, @Nullable String> getSystemLocale()`
- `Object getHandle(Entity)`
- `BaseComponent[] toComponents(ItemStack)`
- `BaseComponent[] getItemName(ItemStack)`

in `KarFrameworkBukkit.getNmsProvider()`.

repository: Karlatemp/KarFramework

repo_name: Karlatemp/KarFramework


text:
---
Module Name: PnP.PowerShell
schema: 2.0.0
applicable: SharePoint Online
online version: https://pnp.github.io/powershell/cmdlets/Copy-PnPFile.html
external help file: PnP.PowerShell.dll-Help.xml
title: Copy-PnPFile
---

# Copy-PnPFile

## SYNOPSIS
Copies a file or folder to a different location

## SYNTAX

```powershell
Copy-PnPFile [-SourceUrl] <String> [-TargetUrl] <String> [-Overwrite] [-Force] [-IgnoreVersionHistory] [-NoWait] [-Connection <PnPConnection>]

```

## DESCRIPTION

Copies a file or folder to a different location. This location can be within the same document library, same site, same site collection or even to another site collection on the same tenant. Notice that if copying between sites or to a subsite you cannot specify a target filename, only a folder name. It is currently not possible to copy files between a OneDrive for Business site to SharePoint or vice versa.

Copying files and folders is bound to some restrictions. You can find more on it here: https://learn.microsoft.com/office365/servicedescriptions/sharepoint-online-service-description/sharepoint-online-limits#moving-and-copying-across-sites

## EXAMPLES

### EXAMPLE 1
```powershell
Copy-PnPFile -SourceUrl "Shared Documents/MyProjectfiles" -TargetUrl "/sites/otherproject/Shared Documents" -Overwrite
```

Copies a folder named MyProjectFiles in the document library called Documents located in the current site to the root folder of the library named Documents in the site collection otherproject. If a folder named MyProjectFiles already exists, it will overwrite it.

### EXAMPLE 2
```powershell
Copy-PnPFile -SourceUrl "/sites/project/Shared Documents/company.docx" -TargetUrl "/sites/otherproject/Shared Documents"
```

Copies a file named company.docx located in a document library called Shared Documents in the site collection project to the Shared Documents library in the site collection otherproject. If a file named company.docx already exists, it won't perform the copy.

### EXAMPLE 3
```powershell
Copy-PnPFile -SourceUrl "Shared Documents/company.docx" -TargetUrl "/sites/otherproject/Shared Documents" -IgnoreVersionHistory
```

Copies a file named company.docx located in a document library called Documents in the current site to the site collection otherproject. If a file named company.docx already exists, it won't perform the copy. Only the latest version of the file will be copied and its history will be discarded.

### EXAMPLE 4
```powershell
Copy-PnPFile -SourceUrl "/sites/project/Shared Documents/Archive" -TargetUrl "/sites/otherproject/Shared Documents" -Overwrite
```

Copies a folder named Archive located in a document library called Shared Documents in the site collection project to the Shared Documents library in the site collection otherproject. If a folder named Archive already exists, it will overwrite it.

### EXAMPLE 5
```powershell
Copy-PnPFile -SourceUrl "Documents/company.docx" -TargetUrl "Documents/company2.docx"
```

Copies a file named company.docx located in a document library called Documents to a new document named company2.docx in the same library.

### EXAMPLE 6
```powershell
Copy-PnPFile -SourceUrl "Shared Documents/company.docx" -TargetUrl "Shared Documents2/company.docx"
```

Copies a file named company.docx located in a document library called Documents to a document library called Documents2 in the same site.

### EXAMPLE 7
```powershell
Copy-PnPFile -SourceUrl "Shared DocuDocuments/company.docx" -TargetUrl "Subsite/Shared Documents"
```

Copies a file named company.docx located in a document library called Documents to the document library named Documents in a subsite named Subsite keeping the file name.

### EXAMPLE 8
```powershell
Copy-PnPFile -SourceUrl "Shared Documents/company.docx" -TargetUrl "/sites/otherproject/Shared Documents" -Overwrite
```

Copies a file named company.docx located in a document library called Documents in the current site to the site collection otherproject. If a file named company.docx already exists, it will still perform the copy and replace the original company.docx file.

### EXAMPLE 9
```powershell
Copy-PnPFile -SourceUrl "Shared Documents/MyDocs" -TargetUrl "/sites/otherproject/Documents" -Overwrite
```

Copies a folder named MyDocs in the document library called Documents located in the current site to the site collection otherproject. If the MyDocs folder exist it will copy into it, if not it will be created.

### EXAMPLE 10
```powershell
Copy-PnPFile -SourceUrl "SubSite1/Documents/company.docx" -TargetUrl "SubSite2/Documents"
```

Copies a file named company.docx in the library named Documents in SubSite1 to the library named Documents in SubSite2.

### EXAMPLE 11
```powershell
$job = Copy-PnPFile -SourceUrl "Shared Documents/company.docx" -TargetUrl "SubSite2/Shared Documents" -NoWait
$jobStatus = Receive-PnPCopyMoveJobStatus -Job $job
if($jobStatus.JobState == 0)
{
  Write-Host "Job finished"
}
```

Copies a file named company.docx from the current document library to the documents library in SubSite2. It will not wait for the action to return but returns job information instead. The Receive-PnPCopyMoveJobStatus cmdlet will return the job status.

## PARAMETERS

### -Force
If provided, no confirmation will be requested and the action will be performed

```yaml
Type: SwitchParameter
Parameter Sets: (All)

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -IgnoreVersionHistory
If provided, only the latest version of the document will be copied and its history will be discarded. If not provided, all historical versions will be copied.

```yaml
Type: SwitchParameter
Parameter Sets: (All)

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Overwrite
If provided, if a file already exists at the TargetUrl, it will be overwritten. If omitted, the copy operation will be canceled if the file already exists at the TargetUrl location.

```yaml
Type: SwitchParameter
Parameter Sets: (All)

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -SourceUrl
Site or server relative URL specifying the file or folder to copy. Must include the file name if it is a file or the entire path to the folder if it is a folder.

```yaml
Type: String
Parameter Sets: (All)
Aliases: SiteRelativeUrl, ServerRelativeUrl

Required: True
Position: Named
Default value: None
Accept pipeline input: True (ByValue)
Accept wildcard characters: False
```

### -TargetUrl
Site or server relative URL where to copy the file or folder to. Must not include the file name.

```yaml
Type: String
Parameter Sets: (All)
Aliases: TargetServerRelativeLibrary

Required: True
Position: 1
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -NoWait
If specified the task will return immediately after creating the copy job. The cmdlet will return a job object which can be used with Receive-PnPCopyMoveJobStatus to retrieve the status of the job.

```yaml
Type: SwitchParameter
Parameter Sets: (All)

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

## RELATED LINKS

[Microsoft 365 Patterns and Practices](https://aka.ms/m365pnp)

repository: radityoardi/PnP-PowerShell

branch_name: refs/heads/dev

gha_license_id: NOASSERTION

repo_name: radityoardi/PnP-PowerShell


text:
# JavaScript Translation

This module performs the translation of Kotlin source code to JavaScript.

There are various Kotlin APIs to JavaScript environments in the [standard library](../libraries/stdlib/js).

## Compiling the Kotlin Standard Library for JavaScript

The Kotlin Standard Library for JS is built with gradle, see the corresponding module's [ReadMe](../libraries/stdlib/js/ReadMe.md).

## Reusing JVM based test cases in JavaScript

Any Kotlin test cases using the **org.junit.Test** annotation and the [kotlin.test](../libraries/kotlin.test) package, such as [this test case](../libraries/stdlib/test/text/StringNumberConversionTest.kt#L16) are automatically converted to JavaScript using [QUnit](http://qunitjs.com/).

This allows the test cases to be [run directly in a web page in any web browser](../libraries/stdlib/js/ReadMe.md).

## Using the Kotlin Library in JavaScript

There is a [simple sample](../libraries/examples/browser-example/ReadMe.md) which shows how to use the [Kotlin Standard Library](https://kotlinlang.org/api/latest/jvm/stdlib/index.html) from inside JavaScript in a web page.

## Contributing

We love contributions! The JavaScript translation could really use your help! If you fancy contributing:

* check the [contributing section](https://github.com/JetBrains/kotlin/blob/master/ReadMe.md) on general stuff like getting the code etc
* try fix one of the pending [JavaScript translation issues](https://youtrack.jetbrains.com/issues/KT?q=Subsystems:%20%7BBackend.%20JS%7D%20-Resolved)

repository: haerulmuttaqin/kotlin

repo_name: haerulmuttaqin/kotlin


text:
+++
title = "aws_ecs_services Resource"
platform = "aws"
draft = false
gh_repo = "inspec-aws"

[menu.inspec]
title = "aws_ecs_services"
identifier = "inspec/resources/aws/aws_ecs_services Resource"
parent = "inspec/resources/aws"
+++
Use the `aws_ecs_services` InSpec audit resource to test properties of multiple AWS ECS Services.

The AWS ECS Service resource creates an Amazon Elastic Container Service (Amazon ECS) service that runs and maintains the requested number of tasks and associated load balancers.

For additional information, including details on parameters and properties, see the [AWS documentation on ECS Service](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-service.html).

## Installation

{{% inspec_aws_install %}}

## Syntax

Ensure that a service exists.

```ruby
describe aws_ecs_services(cluster: "CLUSTER_NAME") do
  it { should exist }
end
```

## Parameters

`cluster` _(required)_

: The short name or full Amazon Resource Name (ARN) of the cluster on which your service is running.

## Properties

`service_arns`
: The ARNs of the services.

`service_names`
: The names of the services.

`cluster_arns`
: The Amazon Resource Name (ARN) of the cluster that hosts the services.

`status`
: The status of the service. The valid values are `ACTIVE`, `DRAINING`, or `INACTIVE`.

`desired_count`
: The desired number of instantiations of the task definition to keep running on the service.

`running_count`
: The number of tasks in the cluster that are in the `RUNNING` state.

`pending_count`
: The number of tasks in the cluster that are in the `PENDING` state.

`launch_types`
: The infrastructure on which your service is running.

`task_definitions`
: The task definitions to use for tasks in the service.

`platform_versions`
: The AWS Fargate platform versions on which the tasks in the task set are running.

For additional information, see the [AWS documentation on ECS describe services method](https://docs.aws.amazon.com/sdk-for-ruby/v2/api/Aws/ECS/Client.html#describe_services-instance_method).

## Examples

**Ensure a specific service is available on a cluster.**

```ruby
describe aws_ecs_services(cluster: "CLUSTER_NAME") do
  its('service_arns') { should include 'SERVICE_ARN' }
end
```

## Matchers

{{% inspec_matchers_link %}}

The controls will pass if the `describe` method returns at least one result.

### exist

Use `should` to test that the entity exists.

```ruby
describe aws_ecs_services(cluster: "CLUSTER_NAME") do
  it { should exist }
end
```

Use `should_not` to test the entity does not exist.

```ruby
describe aws_ecs_services(cluster: "CLUSTER_NAME") do
  it { should_not exist }
end
```

### be_available

Use `should` to check if the service is available.

```ruby
describe aws_ecs_services(cluster: "CLUSTER_NAME") do
  it { should be_available }
end
```

## AWS Permissions

{{% aws_permissions_principal action="ECS:Client:ListServicesResponse" %}}

repository: inspec/inspec-aws

repo_name: inspec/inspec-aws


text:
# Text-Extraction-using-CRAFT-and-Deep-Text-Recognition
Extracting Text from US Driving Licence Using CRAFT and Deep Text Recognition

The Code is in initial stage.

## Getting started
### Install dependencies
#### Requirements
- lmdb==0.98
- natsort==7.0.1
- nltk==3.5
- numpy==1.18.3
- opencv-contrib-python==<IP_ADDRESS>
- Pillow==7.1.2
- pip==20.1
- scikit-image==0.16.2
- scipy==1.4.1
- setuptools==39.0.1
- six==1.14.0
- torch==1.5.0+cpu
- torchvision==0.6.0+cpu
- wheel==0.34.2
```
pip install -r requirements.txt
```
### Model
Download Pre-trained Model/Weight
- [craft_mlt_25k.pth](https://drive.google.com/open?id=1Jk4eGD7crsqCCg9C9VjCLkMN3ze8kutZ),

- [TPS-ResNet-BiLSTM-Attn.pth]((https://drive.google.com/drive/folders/15WPsuPJDCzhp2SvYZLRj8mAlT3zmoAMW))

### Test
Run the below code:

```
python extract.py -i data/AL.jpeg -o result
```
where
"extract.py" -> filename

"data/AL.jpeg" -> data is input directory and AL.jpeg is image file

"result" -> output directory where extracted text will be saved

## Acknowledgements
This implementation has been based on these repository [clovaai/CRAFT-pytorch](https://github.com/clovaai/CRAFT-pytorch), [clovaai/deep-text-recognition-benchmark](https://github.com/clovaai/deep-text-recognition-benchmark).

## Links
- WebDemo : https://demo.ocr.clova.ai/

Combination of Clova AI detection and recognition, additional/advanced features used for KOR/JPN.


text:
---
layout: post
title:  "New Resource - BTEC Level 3 Information Technology - Unit 4: Programming"
author: scott
categories: [ Digital ]
published: true
#image: assets/images/author.jpg
---

During this course, you will learn the basics of computer programming, along with algorithms and object-oriented programming through the Python programming language. The course includes comprehensive materials and plenty of programming exercises - all of which are tested using automatic testing via Github.

The slide deck is mapped to the scheme of work provided by Pearson and is designed to be a self-contained resource for the course.

You can access the course exercises and materials here: [scott3142.uk/python-programming](https://scott3142.uk/python-programming)

The slide deck can be accessed here: [Unit 4: Programming](https://docs.google.com/presentation/d/1kpiRf4DE1erA5osrpjkyU9-Y3sODTq-egrTk3Z9aLj4/edit#slide=id.g7fe12e2550_0_0)

gha_language: CSS


text:
---
weight: 1
title: "Overview"
layout: bundle
---

## Upkip Administration

**Purpose:** Upkip Administration application is used for different configurations:

- To configure **users and groups** in Upkip
- To configure **organization structure** as tree starting with Factory, Departments and Machines.
- To configure **factory layout** with machines
- For each machine are configured **Properties, Tags and Alarms**
- **Events** configurations – used for triggering warnings or notifications
- **Warnings** – configure different alarms, warnings or information when some event occurred.
- **Notifications** – configure notifications to users’ emails, messages to user Viber phone number, to user phone as SMS, to Teams channel.
- **Gateways** with Windows or Linux adapters
- Configured persister servers, analysis servers and notification servers are visible

In the **Upkip Administration** user can log with its **Microsoft user account** if configured for Upkip with role **system administrator** or **organization administrator.**

- **System Administrator** – has full functionalities for different organizations
- **Organization Administrator** – has full functionalities for one organization


text:
# ``stripplot_error.py``
This function generates a [seaborn-styled stripplot]() except with error bars on the value axis.

# Installation
Clone or copy this function to your project or add it to your `$PYTHONPATH`.

# Example Usage
This code contains only one function, `stripplot_err`. See the `example.py` file for an example on it's usage. A representative plot is shown below.

![](example.png)

# License
This code is licensed under [MIT](https://en.wikipedia.org/wiki/MIT_License) and is as follows:

```
Copyright (c) 2016 Griffin Chure

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```


text:
## Steps
To connect your app to Salesforce Community, you will:
1. [Get Salesforce credentials](#get-salesforce-credentials)
2. [Find your Salesforce Community's base path](#find-your-salesforce-communitys-base-path)
3. [Create and enable a connection in Auth0](#create-and-enable-a-connection-in-auth0)
4. [Test the connection](#test-the-connection)

repository: forrest-ua/docs

repo_name: forrest-ua/docs


text:
# React Native Audio Player

Mobile audio player developed with React Native.

## Features

1) Load, play and pause music.
2) Load Lyrics.
3) Automatic Lyrics-to-Audio Alignment (basically scroll down and highlight the line of lyrics as the music plays).
4) Jump to the position in the music when clicking on the lyrics, and vice versa.
5) Jump to previous or next track.
6) Enable/disable looping on a single track and whole playlist.

## Preview
### Start Screen

### Select track from playlist to load music

### Load music and start playing (looping on track disabled by default)

### Load music and start playing (looping on track enabled)

### Jump to the position in the music when clicking on the lyrics or drag the progress bar

### Play list indicate the current playing track

## Installation
:exclamation:You need to download the project to run this application.

Use the package manager [npm](https://www.npmjs.com/) to install dependencies.

```bash
npm install expo-cli --global
npm install
```

Use npm to launch the application.

```bash
npm start
```

Scan the QR code on your browser with camera, and launch it via [expo](https://expo.io/).

## Upcoming Features

1) Add micro-interatcions to enhance user experience
2) More powerful playlist (rearrange track order, delete track, create/delete playlist)
3) Shuffle playing mode
4) Display track info (album, genre, year, etc), album art and lyrics with different views
5) Music library according to artist, albumn, genre and playlist

## Languages and Tools

 ## License
[MIT](https://choosealicense.com/licenses/mit/)


text:
# Console Development

## Tips

* Stop UAC prompt from disconnecting Remote Desktop
    1. __Start / Edit group policy__
    1. Computer Configuration / Windows Settings / Security Settings / Local Policies / Security Options
    1. Double-click __User Account Control: Switch to the secure desktop when prompting for elevation__
    1. Click __Disabled__ and __OK__

repository: subor/sdk

gha_language: C#

repo_name: subor/sdk


text:
---
id: 574
title: HP EVA management pack
date: 2009-06-17T21:39:00+10:00
author<EMAIL_ADDRESS>
guid: /blogs/scom/archive/2009/06/17/hp-eva-management-pack.aspx
sc_member_order:
  - "0"
  - "0"
  - "0"
  - "0"
  - "0"
post_views_count:
  - "1837"
  - "1837"
  - "1837"
  - "1837"
categories:
  - SystemCenter
  - Uncategorized
tags:
  - community
  - HP
  - HP EVA
  - Management Pack
  - Opmsgr 2007 R2
  - opsmgr
  - opsmgr R2
  - Performance
---
Alain Côté has written his own HP EVA management pack!  This Management pack will monitor the performance of an HP EVA, the official HP Storage MP only does alerting.

This Management pack is based on the evaperf.exe command and has several collection rules, diagnostic task and one monitor for the latency.

The management pack assumes evaperf.exe is in C:Program FilesHewlett-PackardEVA Performance Monitor and is configured properly.

[](http://scug.be/scom/files/2012/06/clip_image0014_00D5BAB9.gif)

[](http://scug.be/scom/files/2012/06/image_38F9DF6B.png)

Thanks to Alain Côté for sharing this with the communty !

Have fun,
Alexandre Verkinderen

gha_language: HTML


text:
hermes-pkgstore-recv(1)
========================

## SYNOPSIS

Receive a package closure sent over stdin/stdout with the send/recv protocol.

`hermes-pkgstore recv [option] ...`

## DESCRIPTION

`hermes-pkgstore recv`receives a package and its dependencies (also referred to as a package closure)
from an instance of `hermes-pkgstore recv`. To use this command you must arrange the stdout and stdin
of the send end to be connected to the stdin and stdout of the recv end.

The receiving package store must have the sending package store's public key added to the public key list
as a package store can only receive signed packaged.

It is safe to abort and retry a package send at any time

## OPTIONS

* -o, --output VALUE:
  Path to where package output link will be created.

* -s, --store VALUE=:
  Package store to receive the closure.

## SEE ALSO

hermes-pkgstore(1), hermes-pkgstore-send(1)

repository: roobie/hermes

repo_name: roobie/hermes